The Daily WTF: Curious Perversions in Information Technology

2014-04-03 Reply Admin

[quote user="Matt Westwood"] Especially since the translation of "regular expression" in french is a troll in itself. Some (including me) argue for "expression rationnelle", other argues for "expression régulière" (which sort of translates to "recurring expression").[/quote]

"expression norme" or "expression canonique" may be appropriate.

Although now its etymology has been called into question, I now wonder what's so "regular" about a "regular expression".[/quote]

I believe regular is reference to regular language, which basics of regular expression is based on altough often expanded.

New top level domains might cause issues in future, as we can't always expect . in domain anymore. And really most validation things are quite hard to do if you get to details, why can't we just build some nice simple systems for everything?

2014-04-03 Reply Admin

Trello:
Balu:
Trello:
TRWTF is using a regex for validating emails.
What do you suggest? (disclaimer: I know most people do email address validation wrong, but email addresses can be validated using regular expressions)

They can, but getting it right is difficult (also it might not do exactly what you want). See http://www.regular-expressions.info/email.html

I'm willing to bet that almost every hand-rolled email address validator doesn't really conform.

Captcha: letatio - if you use your own half-baked regex to validate email addresses you won't be getting any letatio from me later

Strictly speaking, you cannot validate an email address with a regular expression, actually. (That link there is basically a multi-paragraph explanation/excuse for why his regex doesn't match RFC 5321). The RFC allows for infinite nesting in the local-part and as any fule kno, that requires a stack machine (i.e. a context-free grammar) to parse at minimum. You can sort of fake it with this one: http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html

But don't do that. Check for an "@" sign. Maaaaaaaaybe check for a "." in the domain, although that's technically stricter than the RFC and will break things for intranet applications.

2014-04-03 Reply Admin

Clarence Darrow:
Did your monkeys try switching languages before?

TRWTF is employing monkeys. Or was Yvonne just being condescending?

Nice

2014-04-03 Reply Admin

The Real WTF is that you had a long winded story about things getting lost in translation and could have skipped the fluffery

Julia · 2014-04-03 Reply Admin

Matt Westwood:
CigarDoug:
Balu:
Trello:
TRWTF is using a regex for validating emails.
What do you suggest? (disclaimer: I know most people do email address validation wrong, but email addresses can be validated using regular expressions)
For one thing, stop overthinking the problem. Require the email to have an '@' symbol. That's it. If the process sends a confirmation email with a link you must click to continue, and you type in [email protected] (my personal favorite), then YOU DON'T GET THE EMAIL. What possible validation could you need more restricted than that?

This.

Although I do feel a certain amount of anguish on behalf of the poor person for whom [email protected] is their email address.

I pity the foo - or more specifically [email protected]: http://bar.com/

2014-04-03 Reply Admin

Hm. I saw Lost in Translation on a recent flight to Europe or Africa or somewhere. Rather enjoyed it, even over the plane noise.

operagost · 2014-04-03 Reply Admin

aigarius:
The only thing that you can truly rely on is that a valid email address will contain "@" somewhere. Everything else is ... optionalish. You can have the hostname part be without a dot, you can have almost anything in the username part.

If it's on the internet, it has to have at least one dot to the right of the "@". I'm pretty sure no one is running a mail server on any TLDs.

2014-04-03 Reply Admin

Balu:
Trello:
TRWTF is using a regex for validating emails.
What do you suggest? (disclaimer: I know most people do email address validation wrong, but email addresses can be validated using regular expressions)

No, they can't. Stop trying, because you're wrong. It doesn't matter what regex you use, validating anything more than "There must be an @" is wrong.

And for a subset of cases, "There must be an @" is also wrong.

2014-04-03 Reply Admin

Anon:
It doesn't matter what regex you use, validating anything more than "There must be an @" is wrong. And for a subset of cases, "There must be an @" is also wrong.

This is a classic example of overgeneralization. "'foobar' is a valid email address in some intranets, so testing for [email protected] is wrong."

No, it isn't. Quite simply because if you develop for an intranet, you usually do not take the email address as login identifier.

You use the email address as login for services like facebook or pinterest. And those services will communicate with you per email over the internet. "foobar" won't work, even if it is theoratically a valid email address. For the point of view of the service, "valid" is defined as: "an address I can send an email to", and for that definition of valid "foobar" will not do. "[email protected]" will do however, because if the account "foo" at bar.com exists, then the email can be delivered.

DCRoss · 2014-04-03 Reply Admin

Balu:
Trello:
TRWTF is using a regex for validating emails.
What do you suggest? (disclaimer: I know most people do email address validation wrong, but email addresses can be validated using regular expressions)

For starters, don't try validating HTML with a regexp either.

Once you figure that part out living in fear of regular expressions, which is a very good thing to do, just comes naturally.

dkf · 2014-04-03 Reply Admin

operagost:
aigarius:
The only thing that you can truly rely on is that a valid email address will contain "@" somewhere. Everything else is ... optionalish. You can have the hostname part be without a dot, you can have almost anything in the username part.
If it's on the internet, it has to have at least one dot to the right of the "@". I'm pretty sure no one is running a mail server on any TLDs.

I advise checking that there's an "@" that isn't at either end, and that there's a "." after the "@" with at least one character between the "@" and the ".", and the "." and the end. It will reject some technically legal email addresses, but you probably don't want to send email to them anyway (and it's likely that your MTA won't cope anyway).

Apart from that? Trim/normalise spaces, newlines, etc. as normal with user input, and watch out for commas, but otherwise whatever. (The number of non-malicious users with multiple spaces in their mailbox name is likely zero. And all of them could be considered to be malicious anyway for just existing.)

2014-04-03 Reply Admin

Yeah, it’s unlikely that anyone would add an automatic translator to a web page (did the existing non-English-speaking developers not notice something wrong?)

I did have to recently head off a localization effort here at work where a developer put all the UI strings through Google translate rather than talk to our paid translators. I don’t how how he chose “Retten” for “Save” considering Google translate gives “Speichern” as an alternative at or near the top of the list, but that’s how I noticed what he was doing. Luckily I had spent a few months in Germnany 20 years ago. Although I couldn’t remember the correct words, some just didn’t feel right, and “Retten” was obviously wrong.

But an automatic translator is an order of magnitude worse.

realmerlyn · 2014-04-03 Reply Admin

The actual shortest single regex that can match any uncommented RFC822 (et. seq.) address is (remove newlines before using):

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)

And yeah, I bet most people don't use something like this in their Javascript. (By the way, this is a Perl regex, so your mileage may vary.)

2014-04-03 Reply Admin

nllp:
I did have to recently head off a localization effort here at work where a developer put all the UI strings through Google translate rather than talk to our paid translators.

I had a similar experience once with french. I looked at the french translations of some of our messages trying to learn a bit of french from them but one message struck me as being rather oddly formulated.

So I went to my french colleague and ask him "Is that how you say ... in french?" to which his answer was: "no, it isn't".

The twist of the story was that those messages had been translated from english to french not by google translate but by some french employee in one of our offices in france.

Sometimes human translators are no better than google translate.

2014-04-03 Reply Admin

I'd build a two-tiered system...

First, we'd validate email addresses that can be delivered to. If it has [text]@[text with at least one dot], assume it can be delivered to. If not, don't accept it at all.

Next, run a different validation to see if it's a "normal" email address. For example, "[email protected]" would technically follow that first regex (and be valid according to the RFC), but doesn't end in one of the common TLDs. Give a warning if it fails this one (Something like "Your email address appears invalid, please verify it is correct"). The user can ignore the warning if they have some super-eccentric address, but it would catch most people who do something like forget the .com...

Captcha: damndum - damn that translation program was num[b] to the real meaning of that word...

realmerlyn · 2014-04-03 Reply Admin

MerdeMan:
Try this regex buddy:
[a-zA-Z0-9._-]+@(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,6}

Fails on fred&[email protected], a perfectly valid address (and an auto-responder… try it!).

2014-04-03 Reply Admin

faoileag:
And believe me, your customers will thank you for telling them that it's "foobar@gmail.com" instead of just silently ignoring "foobar@gmail".

Yeah. Tell that to the site that rejected my email address [email protected] because it didn't end in .com. After all, everyone knows that Internet addresses end in .com.

2014-04-03 Reply Admin

dkf:
operagost:
aigarius:
The only thing that you can truly rely on is that a valid email address will contain "@" somewhere. Everything else is ... optionalish. You can have the hostname part be without a dot, you can have almost anything in the username part.
If it's on the internet, it has to have at least one dot to the right of the "@". I'm pretty sure no one is running a mail server on any TLDs.
I advise checking that there's an "@" that isn't at either end, and that there's a "." after the "@" with at least one character between the "@" and the ".", and the "." and the end. It will reject some technically legal email addresses, but you probably don't want to send email to them anyway (and it's likely that your MTA won't cope anyway).
Apart from that? Trim/normalise spaces, newlines, etc. as normal with user input, and watch out for commas, but otherwise whatever. (The number of non-malicious users with multiple spaces in their mailbox name is likely zero. And all of them could be considered to be malicious anyway for just existing.)

So now we're calling RFC-Compliant Email addresses "Malicious" simply for existing?

You gonna start complaining about non-English languages, too, since they force you to use Unicode?

2014-04-03 Reply Admin

Matt Westwood:
Dentricx:
DaveK:
Some programmers, when they think of solving a problem with regular expressions, can't remember the French for 'regular expression'.
Now they have three problems.

Especially since the translation of "regular expression" in french is a troll in itself. Some (including me) argue for "expression rationnelle", other argues for "expression régulière" (which sort of translates to "recurring expression").

"expression norme" or "expression canonique" may be appropriate.

"norme" is a noun, can't work here. "Expression normalisatrice" would work, but seems too pompous and disconnected from language theory. "expression canonique" is already used in high school math for something else.

faoileag:
Or you could use google to find some french sites about programming and take the correct translation from one of those sites: "Expressions régulières" seems to be the accepted term (found in http://formation-perl.fr/guide-perl-08.html et al.).

Have you read your linked site ?

TFW:
[...] on utilise en anglais le terme regular expression [...] une traduction correcte "expressions rationnelles" et une traduction mot à mot "expressions régulières".

The guy actually agree that "expression rationelles" is correct, while the other is a word-to-word translation, even through he decide to use the latter.

Wikipedia agrees with "expression rationelles" (and god damn there are heavy trolls on wikipedia FR)

2014-04-03 Reply Admin

jkupski:
aigarius:
The only thing that you can truly rely on is that a valid email address will contain "@" somewhere.
Strictly speaking, an email address doesn't require an @ (i.e. user is local). Also, I send my emails using bang paths, you insensitive clod.

I once had a president's daughter who was a path-banging insensitive clod. I assure you it was no laughing matter.

ZPedro · 2014-04-03 Reply Admin

Les gars… "expression régulière" ou "expression rationnelle" ou autre, tout ça c'est schtroumpf vert et vert schtroumpf.

cellocgw · 2014-04-03 Reply Admin

jkupski:
aigarius:
The only thing that you can truly rely on is that a valid email address will contain "@" somewhere.
Strictly speaking, an email address doesn't require an @ (i.e. user is local). Also, I send my emails using bang paths, you insensitive clod.

You have bang paths? We had to print our emails, photo them on a wooden table, and hand-carry them to ihnp4 or uunet !

ubersoldat · 2014-04-03 Reply Admin

What does the whole Email validation has to do with the WTF? Context? I don't think so!

2014-04-03 Reply Admin

What I don't understand is why they had such big problems to communicate. All programmers share at lease one language (cursing) so they could easily have communicated like:

A: You just have do do the #%&!! job B: OK. I'll %*#!? do it.

(The result will then as usually be #?&%!)

2014-04-03 Reply Admin

Balu:
Trello:
TRWTF is using a regex for validating emails.
What do you suggest? (disclaimer: I know most people do email address validation wrong, but email addresses can be validated using regular expressions)

Actually, while email addresses are relatively easy to describe in a grammar, it is impossible to create a regex which validates all syntactically correct addresses while rejecting all syntactically incorrect ones.

Usually, we just check to see if it looks like an email address.

2014-04-03 Reply Admin

realmerlyn:

The actual shortest single regex that can match any uncommented RFC822 (et. seq.) address is (remove newlines before using):

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*)

And yeah, I bet most people don't use something like this in their Javascript. (By the way, this is a Perl regex, so your mileage may vary.)

And we have TRWTF

no laughing matter · 2014-04-03 Reply Admin

Grandpa:
jkupski:
aigarius:
The only thing that you can truly rely on is that a valid email address will contain "@" somewhere.
Strictly speaking, an email address doesn't require an @ (i.e. user is local). Also, I send my emails using bang paths, you insensitive clod.

I once had a president's daughter who was a path-banging insensitive clod. I assure you it was no laughing matter.

And i can assure you, Grandpa: The next time i'll path-bang you, it will be no laughing matter!

DrPepper · 2014-04-03 Reply Admin

Lets not forget the WTF of having a site that is translated into french (and presumably other languages) and pushing it out to production without first pushing it to stage and testing that the site works -- in each language!!!

2014-04-03 Reply Admin

This regex is fucking wrong.

2014-04-03 Reply Admin

I tried fucking your sister but she was too ugly even with a bag over her head

Kivi · 2014-04-03 Reply Admin

operagost:
I'm pretty sure no one is running a mail server on any TLDs.

Unusual but it happens. I had a friend Ian with the address n@ai . True story.

Gene Wirchenko · 2014-04-03 Reply Admin

Your Name:
Strictly speaking, you cannot validate an email address with a regular expression, actually. (That link there is basically a multi-paragraph explanation/excuse for why his regex doesn't match RFC 5321). The RFC allows for infinite nesting in the local-part and as any fule kno, that requires a stack machine (i.e. a context-free grammar) to parse at minimum. You can sort of fake it with this one: http://www.ex-parrot.com/~pdw/Mail-RFC822-Address.html

No, it does not require a stack. Nothing needs to be done with each section. The regular expression for that part might be something like:

Let CHARS be the set of characters acceptable in a part. This would exclude "." and other characters (and I do not know the full list).

Let PARTEXPR = [CHARS]+

The local part regex would be something like PARTEXPR (. PARTEXPR)*

AIUI, the problem is that there is a comment part that is not amenable to regex.

Sincerely,

Gene Wirchenko

chubertdev · 2014-04-03 Reply Admin

faoileag:
the article:
Where they expected to see:
for (var i = 1; i < a.length; i++) {
Was instead:
pour (var i = 1; i < a.length; i++) {
Very mysterious. I would have expected the translated javascript statement to be:
pour (var i = 1; i < a.longueur; i++) {
Which adds to the suspicion that everything apart from the obious wtf ("we ran the whole html page through a translater, not only the content, ha, ha, ha, stupid us") is embellishment.

No kidding. So many WTFs here.

-The author, obviously -That lack of translation -People thinking that not validating client-side when you can is even remotely a good idea -Yvonne being tired all the time. She's probably pregnant with the president's kid. Is this a president's daughter origin story?

da Doctah · 2014-04-03 Reply Admin

John:
Clarence Darrow:
Did your monkeys try switching languages before?

TRWTF is employing monkeys. Or was Yvonne just being condescending?

Nice

Actually, "monkeys" is TDWTF's translation of the original submission, which specified "frogs".

2014-04-03 Reply Admin

Dentricx:
Wikipedia agrees with "expression rationelles" (and god damn there are heavy trolls on wikipedia FR)

To the French, language arguments are serious business... I mean, affaires sérieuse!

2014-04-03 Reply Admin

Matt Westwood:
Pippo:
TRWTF is French. There, I said it, so sue me if it's wrong. My wife, who's French and a lawyer, doesn't seem to disagree with me.

J'ondule mes parties intimes à votre tante. Je pète à votre direction générale.

Ohlalalala, de quel bled venez-vous? Que la flotte vous emporte.

Mr. AHole DBA · 2014-04-03 Reply Admin

Wouldn't the compiler stop when it got to a unrecognized word/command such as "POUR" or was their compiler bilingual? O.o

chubertdev · 2014-04-03 Reply Admin

Mr. AHole DBA:
Wouldn't the compiler stop when it got to a unrecognized word/command such as "POUR" or was their compiler bilingual? O.o

JavaScript is an interpreted language.

PleegWat · 2014-04-03 Reply Admin

In javascript? It'll throw an notice for unknown function pour, another for missing ) before ;, a third for ) without (, and a final one for no ; before {. Probably.

chubertdev · 2014-04-03 Reply Admin

hah

http://thedailywtf.com/Comments/Nobody-Likes-Andy.aspx?pg=2#430480

akismet says that my link to this site is spam

AndyCanfield · 2014-04-03 Reply Admin

Why bother validating e-mail addresses? Your code can, at best, reject "merde" and accept "[email protected]", but there is no user named "merde" on Yahoo. Sending a confirmation message takes a few seconds but validates not only the account format but the account existance also. Lots of sites do this during signup.

2014-04-03 Reply Admin

Rnd(:
[q‍uote user="Matt Westwood"] Especially since the translation of "regular expression" in french is a troll in itself. Some (including me) argue for "expression rationnelle", other argues for "expression régulière" (which sort of translates to "recurring expression").[/q‍uote]
"expression norme" or "expression canonique" may be appropriate.

Although now its etymology has been called into question, I now wonder what's so "regular" about a "regular expression".[/q‍uote]

I believe regular is reference to regular language, which basics of regular expression is based on altough often expanded.

New top level domains might cause issues in future, as we can't always expect . in domain anymore. And really most validation things are quite hard to do if you get to details, why can't we just build some nice simple systems for everything?

You know so much about regular expressions, why didn't you use one to check your quoting?

2014-04-03 Reply Admin

Muphry:
Rnd(:
[q‍uote user="Matt Westwood"] Especially since the translation of "regular expression" in french is a troll in itself. Some (including me) argue for "expression rationnelle", other argues for "expression régulière" (which sort of translates to "recurring expression").[/q‍uote]
"expression norme" or "expression canonique" may be appropriate.

Although now its etymology has been called into question, I now wonder what's so "regular" about a "regular expression".[/q‍uote]

I believe regular is reference to regular language, which basics of regular expression is based on altough often expanded.

New top level domains might cause issues in future, as we can't always expect . in domain anymore. And really most validation things are quite hard to do if you get to details, why can't we just build some nice simple systems for everything?
You know so much about regular expressions, why didn't you use one to check your quoting?

Uh, maybe because checking nested quotes needs a context free grammar instead of regular expression?

2014-04-03 Reply Admin

CigarDoug:
Balu:
Trello:
TRWTF is using a regex for validating emails.
What do you suggest? (disclaimer: I know most people do email address validation wrong, but email addresses can be validated using regular expressions)
For one thing, stop overthinking the problem. Require the email to have an '@' symbol. That's it. If the process sends a confirmation email with a link you must click to continue, and you type in [email protected] (my personal favorite), then YOU DON'T GET THE EMAIL. What possible validation could you need more restricted than that?

You need to change your favourite. example.com is reserved exactly for this purpose so you won't need to abuse the mail servers of b.com and various other organizations that actually exist.

2014-04-03 Reply Admin

faoileag:
Very mysterious. I would have expected the translated javascript statement to be:
pour (var i = 1; i < a.longueur; i++) {

I would have expected:

pour (var je = 1; je < un.longueur; je++) {

2014-04-03 Reply Admin

Anon:
dkf:
(The number of non-malicious users with multiple spaces in their mailbox name is likely zero. And all of them could be considered to be malicious anyway for just existing.)
So now we're calling RFC-Compliant Email addresses "Malicious" simply for existing?
You gonna start complaining about non-English languages, too, since they force you to use Unicode?

Huh? Plain ordinary words like 円 don't need Unicode; JIS and Shift-JIS and EUC have been handling them for decades. English characters like £ need Unicode.

But I agree with you on the spacing. "dkf" looks like initials. If dkf ever gets an e-mail address with two spaces in dkf's full name, dkf will be a malicious user.

2014-04-03 Reply Admin

Erik Gern:
This call with Andre was the last in a dozen late-night conferences with the temperamental, but always polite, programmer, who lived in Normandy.

The late night conference between Yvonne and Andre is believable. Even though Yvonne has a French name chosen by her Tahitian grandmother, she lives in New Zealand and only studied French in high school. Daytime in France is late night in New Zealand. That's believable.

A temperamental programmer in Normandy? That's more than believable, that's the way our industry is.

A polite programmer in Normandy? No way.

2014-04-03 Reply Admin

Harrow:
faoileag:
Very mysterious. I would have expected the translated javascript statement to be:
pour (var i = 1; i < a.longueur; i++) {
I would have expected:
pour (var je = 1; je < un.longueur; je++) {

Plus un. Cela me fait LOL.

2014-04-03 Reply Admin

One of the rare occasions that I can say "Been there, done that." here.

I think most people who begin employing autotranslation function to the "whole page content" does that. :P

2014-04-03 Reply Admin

faoileag:
Very mysterious. I would have expected the translated javascript statement to be:
pour (var i = 1; i < a.longueur; i++) {
Which adds to the suspicion that everything apart from the obious wtf ("we ran the whole html page through a translater, not only the content, ha, ha, ha, stupid us") is embellishment.

Or, just as likely, the tool that extract text from the page failed to recognise "length" as a word due to being preceded by a period instead of whitespace.

Translate Everything!

Leave a comment on “Translate Everything!”