This apology isn't global enough and it isn't accepted.



There were several errors in the code and not enough information was
provided for a proper diagnosis. It's the OP's job to fix the code. I
did not notice the declaration, but my point is that trivial errors
should never be a basis for a months-long campaign of character
assassination.

Mine was a simple oversight, but you imply above that you did not even
realize that VB.Net doesn't have a Set statement.

If you noticed that the OP was using VB.Net this disqualified you from
replying. If you did not so notice then you made a simple error as I
did when I failed to see the Decimal declaration the first time (I did
later).

I doubt your competence, but not on the basis of trivial errors. I
doubt it because you prefer to start campaigns of libel and
harassment, including libelous notes to my publisher, based on dubious
interpretations and simple error son your part.

People with questions in this ng have to wade through garbage because
you do not have the self-discipline to refrain from global challenges
to people's competence and you are misusing usenet.

Any simple error is forgiveable. Even if you were unaware that VB.Net
dropped the Set statement, an understanding of which fact happens to
be key to understanding the entire .Net paradigm, this would be
forgiveable because information wants to be free, and after I told you
the facts, they would be yours as well.

But I don't accept your apology since clearly you have no plans to
reform your behavior in this ng and you think this deviance is normed.

Edward G. Nilges attacks:

Aw, gee, shucks.

Oh, I quite agree! I always overlook trivial errors. (You may
recall, for example, I overlooked (once pointing it out) your
trivial malloc error.)

It was your more serious--and STILL unacknowledged--major errors
of design I railed 'gainst. Once more, Eddie, how many fields
in the following CSV: ",John,,Rogar,Mick,"

Remember this bit, Eddie:

All that cudgelling, all that thinking and pondering.... didn't
seem to do much good, eh? And in your chosen language, m'boy.

Tch, tch, tch.

I didn't "imply", I SAID so.

And that I did reply, what does THAT imply, eh?

Yep. Consider the difference. I didn't note the Subject or the
"VB.Net" in the OP's big paragraph (the former is due to this new
News client I'm using--not used to it). The latter is probably
due to aging eyes (and using my laptop during the transition).

You, on the other hand, looked at code in a language you supposedly
use as your primary. At least a language you've presumed to write
a book using!

See the difference?


Trust me, old soak, the feeling is entirely mutual.

Yep. It's those endless repeating ones that doom you.

If you mean I have no intention of changing my free expression of
opinions, thoughts and evaluations, you are correct. As I've told
you several times, I react to you much the way I would react to an
overflowing toilet.

With extreme distaste.

Going after you is nothing but sport, Eddie. It's entertainment,
not unlike shooting rats at the dump. Plus, just like the rats,
it's a bit of a public service shooting you (down).

I think it is what it is--a social group made of all sorts of
humans, some smart, some less so, some experienced, some less
so, some entertaining, some less so.

What does it say about a man's character that he rails and rails
'gainst what he defines as deviance (even briefly pretending to
leave because of it), but yet constantly and consistantly stoops
to it?


Anyway, enjoy wallowing in the glory Eddie. Yep, I blew it.
I have no doubt you'll be reminding me of it for years.
--
|_ CJSonnack <Chris@Sonnack.com> _____________| How's my programming? |
|_ http://www.Sonnack.com/ ___________________| Call: 1-800-DEV-NULL |
|_____________________________________________|___ ____________________|

Programmer Dude <Chris@Sonnack.com> wrote in message news:<acddb0dro5r481djjfug2cd28v2q6tlkr0@4ax.com>. ..
For the last time, I discovered and fixed my error, the implementation
of the regular expression "([^ ]*[ ]+)*" and not the correct regular
expression "([ ]*[^ ]+)*" the same evening in May 2002 I posted the
original code. I then used the error in my book to demonstrate the
utility of a software laboratory for testing regular expressions.

In short I made constructive use of an error I found. Instead of
collegially participating with me you chose, because you were
emotionally manipulated by Richard Heathfield, to initiate a libelous
"flame" war and to actually send actionable messages to my publisher
which had no effect whatsoever on my reputation, my publisher being
far more concerned with the bottom line, and my genuine tendency to
write well, but off-topic.

And now we see that you are capable of an elementary blunder, the
famous Set statement of a language which needs no separation between
object and value, which showed you unqualified to assist the OP.

I suggest you access the better angels of your programming nature and
realize that programming isn't a matter of looking good and never
making mistakes like a "real man". It is at times learning from your
mistakes.

humor. I made a simple correct suggestion for starting the cleanup of
the OP's code which was not fully posted yet obviously had a lot of
elementary problems.



You made an error which shows you weren't qualified to reply.

I don't accept your claim about "aging eyes". I would have had you
manifested simply solidarity, collegiality and charity in May 2002 but
today I can only say that competetent programmers know how to
compensate for disabilities. In fact, some of the best programmers of
former years (before the nasty dot.com white-male-abled dominated
culture entered in the 1990s) were blind or visually challenged in the
extreme.


the claim that the shit is all in one's opponents who are then
narrated as "lice", "bacilli", and "overflowing toilets".

It'd be interesting to learn if you are a Bush supporter.

I will, at least until in the interests of truth and justice you post
an apology for your disruption of this thread. And I shall also be on
the alert for similar errors.

I'm pretty certain your error was a brain fart and in no wise a
systematic misapprehension of VB.Net, just as my implementation of the
incorrect regular expression was a brain fart. But one reason why
American programming jobs are migrating offshore, and why in all
probability your job at 3M is always in play, and constantly under
review by fat women in Human Resources who know nothing about
programming, is that too much energy is spent in CYA. This consists of
two forms of energy.

It consists in the energy you expend in initiating these wars and in
the energy I necessarily must then spend in replying to your garbage.

[There's nothing of value herein--just a dogfight]

Edward G. Nilges writes:

You've either misunderstood or are continuing your long time lie.
Just answer the question, please. How many fields? A number.
I understand why you're afraid to answer... but do it anyway.


Do you mean this in some bizarre metaphorical sense? REs were no
part of either your C attempt or your VB version. (And are you
under the misapprehension either RE above will tokenize CSV? Neither
stand a chance!)

And if you don't recant on THIS complete lie, I'll be forced to
once again dig up those old posts. Or maybe I can just post the
review I posted recently. It makes the *real* progression of
events--including your soon-ate-crow bleatings when Richard at
first thought the bug I found wasn't.

Nope, it was a couple days before you acknowledge the "malloc"
brain fart (as you call them). You NEVER--not ONCE--acknowledge
the more serious design errors. In four years, you've consistantly
refused to answer a simple question about your own parsing rules.

It's hard to be a bald-faced lier, Eddie, when your words are stored
for all to see on soooooo many servers.

[shrug] Do you know anyone who isn't?

Which, I suspect, is exactly why most of us here are vastly better
programmers than you'll ever be.

Hey, hurrah, you finally got the company name right!

And your twisted, sick view of a humorless corporation? Boyo, if
you only knew how much fun I've had over the years....ribs for
lunch with the new "gang" just today is a perfect example. All in
all, I'd have to say corporate life's been pretty good.

Surprised. I. Not.

Hardly. Twice in 24 years. (And the first time was a false alarm.)
(And do you have some sick, twisted reason for mentioning my company
twice like that? FYI, I'm sitting at home right now listening to
jazz and enjoying a beer.)

You are SUCH a jackass. You need your ears boxed. ;-\

--
|_ CJSonnack <Chris@Sonnack.com> _____________| How's my programming? |
|_ http://www.Sonnack.com/ ___________________| Call: 1-800-DEV-NULL |
|_____________________________________________|___ ____________________|

Programmer Dude wrote:
Then why burden us with it? Make starvation, not war.

--
Chuck F (cbfalconer@yahoo.com) (cbfalconer@worldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

Programmer Dude <Chris@Sonnack.com> wrote in message news:<2kq2c0pin1iv6tloo38h22n222nnq4mbcu@4ax.com>. ..
You are conducting this discussion in bad faith. I found and fixed the
problem in the code the same evening it was posted without your
assistance. There are duh six fields in the string.

I have solved the problem about twenty times in twenty different
languages which is why I found the error so quickly. You are
conducting a campaign of professional assassination and if I had a pot
to piss in you'd be in court.

me can use a regular expression as a basis for coding without a re
tool, whereas a clown like you thinks this ability "bizarre".

You are referring to my re for the "set delimited" case which the code
disambiguated. If there is a separate bug in that leg of the code,
repost the code HERE (no pointers to your vanity sites, please) and
write an explanation HERE (no pointers to your vanity sites, please)
of why it has a bug.

If you do so AND maintain a professional tone, I shall respond. If I
made any error and you can prove it of course I'll admit the error.

The re for the string delimiter case is BTW (x(yx){0,1})* where x is a
string not containing y and y is the delimiter. This allows the x
string to be a null string, which it cannot be in the set delimited
case. For the CSV instance the RE is, I believe, ([^,](,[^,]){0-1})*.

I don't have the time to waste on you by testing this, therefore
anyone is welcomed to correct this if I'd made a mistake in a
collegial fashion. But for real work I have written a relab re tester
which allows me to do so, and you can get it if you buy my book. I am
also working on a relab explainer to document res and avoid childish
scenes such as you deliberately foment.

In fact, in critical applications, I use formal techniques which I
learned in 1971 in a book "Formal Languages and Their Relation to
Automata" to PROVE the re does its job and this evening when I have
time I will post either a proof that the above re works or a
correction.

Your lower-middle class game foregrounds your own professional
advancement and not the advancement of learning and I suggest you
knock it off.
You make these lower-middle class threats. I invite you to straighten
out and start a collegial interchange. In that interchange, people
will make errors and learn from them. But you're afraid.

Yes, it's hard to be a "lier" [sic] and I post my own content lavishly
because I am not a "lier". I am not afraid and you are afraid, of the
opinions of others.

....but you expect forgiveness for a truly massive error which
seriously misled readers of your post, while withholding collegiality
here!


"programming" as a trivial and nasty skill, having mastered it to the
extent where, for example, I can code a re by hand the wrong way, the
right way, and many other ways without ever considering this an
unnatural act.

ribs. Let's see, they feed me therefore I am competent...very good,
there's the door.


No code, no collegial explanations, and each post descends to a
physical threat. Sad.

Anyway, this evening I shall post further on a technique for proving
that an re does what it sets out to do.

CBFalconer writes:

You may have the right of it... I'm just too busy lately...

--
|_ CJSonnack <Chris@Sonnack.com> _____________| How's my programming? |
|_ http://www.Sonnack.com/ ___________________| Call: 1-800-DEV-NULL |
|_____________________________________________|___ ____________________|

Edward G. Nilges writes:

A bald-face lie. As I recall, it was at least a couple days before
you even admitted the minor malloc error. You've never admitted
the major errors. It's taken you two years just to answer the little
question I keep asking...

So why did both your C and your VB code count five? THAT is the
major design error I've been trying to get you to face up to for
all this time. Maybe we're finally making progress.

I hope you solved it correctly in the other eighteen. And the
record shows you've never posted any error correction here.

Again? Okay, when I get a chance to dig it out.

We shall see.


--
|_ CJSonnack <Chris@Sonnack.com> _____________| How's my programming? |
|_ http://www.Sonnack.com/ ___________________| Call: 1-800-DEV-NULL |
|_____________________________________________|___ ____________________|

Programmer Dude <Chris@Sonnack.com> wrote in message news:<q97qc05pn8cho9cbu62v6jqqjmbcrj6pna@4ax.com>. ..
You might make more progress on the job if you didn't call people
liars so readily.

allegations because you are using this group in bad faith, to
establish a shaky sense of male dominance as "the" "programmer"
"dude".

productivity is the occasional error: basic mathematics would teach us
that the more code one produces, the error rate will increase
hopefully order n log n only. What's important is correcting the error
courteously as you failed to do when you used your "apology" for a
massive error (the VB.Net "Set" statement) to make a graceless attack.

that this newsgroup is dominated by thugs. I have reduced their
dominance significantly in order to encourage lurkers to post without
fear of professional destruction.

But as to code, from now on, you can get my code by buying my book.

with evidence.

You're afraid to do other than unsubstantiated allegations and post
broken links. I note in particular that you were unequal to
deconstructing my proof that my regex works for comma delimited
expressions because this is precisely the sort of intellectual honesty
and risk taking which your professional corruption in the corporation
had destroyed.

On Mon, 14 Jun 2004, Edward G. Nilges wrote:
Edward G. Nilges, you are a liar.

[re: comma-separated-value strings]
The error was in all editions. And if your error rate is "n log n"
when your rate of code production is "n", then you are producing more
errors per line the more code you write. While this may be a valid
observation, it's not particularly strive-worthy.

Eddie, your proof was laughably trivial. As you so correctly noted,
the regex (.)* accepts any string, and any string is --- by the
definition you used in that article --- a CSV string. (You did
not consider the twin complications of quotation and escape codes,
which make the problem less trivial.) Thus the regex (.)* parses any
CSV string. Any [^,]*[,]{1} gibberish inside the regex is at that
point purely for show.

-Arthur,
signing off

Edward G. Nilges writes:

A lie. A bald-faced lie. Which we now expose (again).
Ed, Your Own Words Name You Liar!

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
Subject; Re: The Data Quality Act
Date; Wed, 26 Jun 2002 16:19:37

[Ed posts his C code string tokenizer...]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
Subject; Re: The Data Quality Act
Date; Thu, 27 Jun 2002 15:10:57

I spent a hour or so re-writing the C version to what I would
consider good C practice (and per my own style just for example).
In the process I found a SERIOUS bug in the C code. It occurs on
line 131 of the C text, in the main parse function:
[...]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
[Ed still in denial two days later...]

Subject; Re: The Data Quality Act
Date; Fri, 28 Jun 2002 12:33:39

CS> The allocated string has no room for the trailing nul.

RH> Sorry for missing this during my own review.

EN> You missed it because you know C and it isn't there.

Sorry, Ed, you're in *serious* denial here. There are two major
bugs in your "parsing" function. The first is exactly what I said
it is, and I'll go over it more carefully for you. [..snip...]

Guess what, Ed. I loaded your original, unmodified (mod line wrapping)
source into VC++ and it DOES crash reporting:

+--------------------------------------------------+
| DEBUG ERROR! |
| Program: Test-D.exe |
| DAMAGE: after Normal block (#40) at 0x00300150 |
| (Press Retry to debug the application) |
| |
| [Abort] [Retry] [Ignore] |
+--------------------------------------------------+

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
[Still swimming in De Nile...]

Subject; Re: The Data Quality Act
Date; Fri, 28 Jun 2002 18:16:52

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
[Finally Ed begins to acknowledge there "may" be a bug...]

Subject; Re: The Data Quality Act
Date; Fri, 28 Jun 2002 18:24:17

No MAY about it.

[...]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
[Finally, four days later, Ed acknowledges (NOT FIXES)...]

Subject; Re: The Data Quality Act
Date; Sun, 30 Jun 2002 23:24:16

Yes.

I'm afraid the other bug still exists. It has to do with what happens
with you "parse" a string using string delimiting, but the string has
no delimiter present.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
[Still no acknowledgement of error or simple test cases...]

Subject; Re: The Data Quality Act
Date; Tue, 09 Jul 2002 17:05:02

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
[And STILL not...]

Subject; Re: The Data Quality Act
Date; Thu, 11 Jul 2002 13:06:19

No, they didn't. Your C solution crashed immediately and refused
to run until I fixed your error. Even then it produced erroneous
results due to the other bug. That's two major bugs in the single
function of substance in your C solution.

Your VB solution at least runs, but it's poorly designed--particularly
for a tool object. Worse, I say it ALSO produces erroneous results:

For the string: ",Moe,,Larry,Curley,,Shemp,Curley-Joe,CurleyJoeBesser,"

[NOTE: That was YOUR test string, Ed.]

Your VB routine claims there are *nine* tokens. Do you feel there
should be a (blank) token *after* the final comma? That would make
10 tokens...

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~
[Present day, years later, finally (after asking a dozen times):]

CS> ..how many fields in the following CSV: ",John,,Rogar,Mick,"

EN> There are duh six fields in the string.

Exactly. So why did both your programs report five?

--
|_ CJSonnack <Chris@Sonnack.com> _____________| How's my programming? |
|_ http://www.Sonnack.com/ ___________________| Call: 1-800-DEV-NULL |
|_____________________________________________|___ ____________________|

Programmer Dude <Chris@Sonnack.com> wrote in message news:<rs0tc05dp21glrl8o58fahguf4kov7vt5k@4ax.com>. ..
I'm not going to even read this. I found and fixed bugs where
appropriate in June 2002 UNTIL I realized you were acting in bad
faith.

You are a typical competence challenged corporate drone programmer, as
evidence by your telling a newbie about the Set statement of VB.Net.
You have come to this newsgroup to establish a shaky sense of
dominance as "the" "programmer" "dude".

Evidencing a narcissistic personality disorder, you reacted to posting
of code form another first and foremost as a threat, and your weak
sense of self was deliberately manipulated by Richard Heathfield.

Good programmers know how to read and change code not their own
without needing to trash other people.

In the intervening years since 2002 I have written 25000 lines of
compiler code and published a book about it, because my mission in
life is not establishing a shaky sense of self-worth in an unmoderated
group. I have also worked internationally, using the skills I have
been interested in cultivating and refusing corporate opportunities to
become nothing more than alienated. During this period I have been at
best only amused by your personality disorder and have made
constructive use of it by theorizing it.

Your antics here resemble Newt Gingrich's farcical "Contract with
America" and Vic Fazio's attack on Hilary Clinton to get her to "sign"
a "contract", because what you rage for is a false closure, in which I
acknowledge your shaky sense of self-esteem by signing off on a
written document.

It is clear that Gingrich and you share a LACK of inner
self-discipline and this generates a need for scenes in which you
present "evidence" or he "contracts" which silence, not so much their
external voice, but an inner voice that reminds them that they might
NOT be "the" "programmer" "dude".

Part of the evidence for your lack of self-discipline is that you have
posted while drunk.

I can't give you what you crave from this ng, and this ng is not the
place for you to get self-esteem.

"Arthur J. O'Dwyer" <ajo@nospam.andrew.cmu.edu> wrote in message news:<Pine.LNX.4.58-035.0406142029350.10149@unix48.andrew.cmu.edu>...
As Hegel found, ALL mathematics is "laughably trivial". And I note
that most programmers find such explanations "laughably trivial"
because they can't write them and prefer to hack, and libel their
coworkers.

I happen to believe that if you can't write you can't program. This is
an unusual view which Dijkstra happened to share. You haven't shown
the ability to write other than abuse.

Furthermore, and as I have said, my name isn't "Eddie". You are
probably a physical coward and as such would not use "Eddie" in any
face to face encounter.

(((\"[^\"]*\")|[\"]*)*,((\"[^\"]*\")|[\"]*)*)* probably handles
quotes. I will test it, and "prove" and discuss it time permitting at
a later date. Escapes are easy to add. This is because any ape can
write regular expressions. The mark of a civilised man is to discuss
them in such a way that they are seen even by dopes like you as
trivial.

The fact is, Artie, that the ONLY correct solution to the problem
"regex for a comma delimited list" accepts all strings because...a
comma delimited list can be anything. Our goal is to get the elements
and not reject the non well formed.

No, it's a basis for semantic actions. Sounds like your experience is
limited.

Furthermore, we need to know such trivia about regular expressions.

Even "trivial" discussion, conducted preferably without the need to
fear interruption by coding apes and other thugs, is preferable to the
silent coding of regular expressions about which nobody, including the
coder, knows nothing.

You have proved yourself incapable of symbolic manipulation because
you regard it as unimportant that the regex (or the new one above) can
be shown to parse "anything", despite the fact that code that
implements the regex can emit comma delimited elements. I conclude
that your computational immaturity is such that you regard the device
as an engine for producing positive and reified results and as such
that you form part of the problem set and not the solution set.

Edward G. Nilges writes:

You're the only one I've so named in recent memory.

Of course. The problem is this error was a fundamental design error.

I just report the facts--using your own publically posted words, Ed.
And if I post broken links, let me know so I can fix them.

Nonsense.

A. I don't have the time to get into another pointless thread with you.
It's taken two years to get you to 'fess up to a serious, major
design error that was blindingly obvious. I don't have the years
it would take to pound more subtle ones through your skull.

2. I really have no interest in participating in a thread that begins
with "...that jerk Sonnack..." See, the terrible irony is that
you claim this moral high ground, whine about our bad behavior,
but then hypocritically dive headfirst into the muck at the least
provocation.

3. Coming up with a sloppy regex that matches ANY input isn't very
interesting or useful.

And you're just not interesting, Ed. You're boring, and I have better
things to do.

--
|_ CJSonnack <Chris@Sonnack.com> _____________| How's my programming? |
|_ http://www.Sonnack.com/ ___________________| Call: 1-800-DEV-NULL |
|_____________________________________________|___ ____________________|

Edward G. Nilges writes:

Not surprising, since you are condemned by your own words.

?!?! Never. Where did you ever get an idea like that?

--
|_ CJSonnack <Chris@Sonnack.com> _____________| How's my programming? |
|_ http://www.Sonnack.com/ ___________________| Call: 1-800-DEV-NULL |
|_____________________________________________|___ ____________________|

Edward G. Nilges writes:

1. You generally don't need to escape double-quotes unless your
regex is in a C-ish language string. You certainly don't need
them here.

2. I think you probably meant [^"]* rather than ["]* to match fields
not enclosed by quotes. Note, too, that ["]* is the same as "*.

3. The above won't match: "foo" , "bar"
because no allowance was made for spaces outside the quotes.

4. It's often nice to allow single-quotes as well as double-quotes.

5. OFF THE TOP OF MY HEAD, I'm not sure it's necessary to match
two fields. I suspect it's doable with one. It is certainly
the case that your code version of the regex didn't need to
have two field spanning loops, but I'll give you leeway assuming
the code was just implementing the regex as is.

Yeah? Let's see you do it.

--
|_ CJSonnack <Chris@Sonnack.com> _____________| How's my programming? |
|_ http://www.Sonnack.com/ ___________________| Call: 1-800-DEV-NULL |
|_____________________________________________|___ ____________________|

Programmer Dude wrote:
Maybe we could get a new newsgroup formed, comp.inanities. We
could then set followups for all the Nilgewater to there, and try
to push Trollsdale from c.l.c there too. They should amuse each
other.

--
fix (vb.): 1. to paper over, obscure, hide from public view; 2.
to work around, in a way that produces unintended consequences
that are worse than the original problem. Usage: "Windows ME
fixes many of the shortcomings of Windows 98 SE". - Hutchison

In article <rs0tc05dp21glrl8o58fahguf4kov7vt5k@4ax.com>, Chris@Sonnack.com
says...
Before I finished reading this all the way through and prior
to reading the Nilgewater "response" to it, I predicted that
he would prevaricate and avoid the truth.

As has been pointed out to him (perhaps a mistake to tell him),
this is why he is so reviled in this group. He calls you a liar
for telling the truth, then ducks the truth when you hit him in
the face with it. He seems to think that newsgroup archives
do not exist. No other explanation, apart from complete stupidity
could explain such behavior.


--
Randy Howard
2reply remove FOOBAR
"I admit that it is probably too much work ... to wade through
my prose to get to anything useful." -- Edward G. Nilges

Programmer Dude <Chris@Sonnack.com> wrote in message news:<uvm0d0dsojbk0p81r4hqlqvo2vt8nrqg30@4ax.com>. ..
Let's see your Mama do it: she did me last week.

Chris, Fascism is the nightmare of childhood. This was Adorno's dark
vision when he realized that dialectically, regression appears not
among the lumpenproletariat, but at the putative zenith, as where
highly-placed university administrators cooperated with the
eradication of Jews from German universities, using the language of
the streets, which I use above in response to your drunken posts.

In fact, the ease of making errors in regular expressions is a concern
of mine since I make errors in regular expressions, although I have
used them since the 1970s; precisely by means of making errors do we
progress: thugs don't realize this because drunken thugs can never
make errors and must set norms for others (like the clown who laid
into me at the Oak Street Beach for wearing Speedos). The notation is
in terms of computer science regressive and gnomic.

This is why my book contains a tool not only for testing regular
expressions but also for documenting and storing them.

Probably because you're drunk, you're playing a silly man's game,
because of course I could merely copy correct regular expressions in
response.

I have in fact found that expressing the regular expression pattern in
Backus Naur Form (which is always possible) and writing by hand a
recursive descent algorithm results in clearer solutions.

You do need to replicate the pattern on either side of the comma
because you need to express the fact that the comma separates like
patterns. Most formalisms allow you to name patterns to make the
replication easier.

Your point (3) is correct and easily fixed.

I will respond to your other points later if you behave yourself.

In article <f5dda427.0406161505.214a4074@posting.google.com>, spinoza1111
@yahoo.com says...

This, coming from the "grown man" who complains about respect when
referred to as "Eddie". Your hypocrisy bit it tied to +5V.

Constantly referring to people as drunk, with zero evidence to back it
up, is a further example. Note: If he is drunk as often as you say,
he's a far better programmer while drunk than you pretend to be while
sober.

You make "your momma" references, then refer to the behavior of
others. Amazing.

--
Randy Howard
2reply remove FOOBAR
"I admit that it is probably too much work ... to wade through
my prose to get to anything useful." -- Edward G. Nilges