Comment On Divide and Validate

I'm guessing there is a validation check server side as well. But doing it on the client side saves a potential network traversal, server load, etc. This would be particularly advantageous if you are doing live validation.

Nah, I was talking about the function declaration which should be

var proFormComplete = function(){...}

but of course it could be part of a larger function like you suggested.

instigator:

chubertdev:

I still can't believe that the plus sign can be used to concatenate strings in VB .NET. Talk about a huge WTF.

Why is that a WTF? Its a feature available in many sane languages.

Take two seconds on Google to research it.

chubertdev:

instigator:

chubertdev:

I still can't believe that the plus sign can be used to concatenate strings in VB .NET. Talk about a huge WTF.

Why is that a WTF? Its a feature available in many sane languages.

Take two seconds on Google to research it.

Relying on Google for judging the sanity of operator overloading is the real WTF.

chubertdev:

instigator:

chubertdev:

I still can't believe that the plus sign can be used to concatenate strings in VB .NET. Talk about a huge WTF.

Why is that a WTF? Its a feature available in many sane languages.

You made the assertion, so the onus is yours to provide evidence (via google or otherwise) to support it. Simply stating something, and demanding that other people proove it to themselves

Take two seconds on Google to research it.

You made the assertion, so the onus is on you to provide evidence when challenged. Demanding that other people google something to prove your point is both lazy and foolish.

Trying to post that shit on a phone on a very wobbly train is TRWTF.

TRWTF is posting as different users :facepalm:

Indeed. Still you should really explain yourself if you want people to agree... Hardly anyone ever googles someone elses side of the argument.

I like to think that if anyone ever asked me for a function that reported what percentage of a form was filled out correctly, I would write something a lot like this. Probably not as clear, though.

WTF specifications deserve WTF code.

-Harrow.

instigator:

chubertdev:

I still can't believe that the plus sign can be used to concatenate strings in VB .NET. Talk about a huge WTF.

Why is that a WTF? Its a feature available in many sane languages.

You said it already. Seriously, in weakly-typed languages, there is possible confusing with addition (when the strings can be converted to numbers). In strongly-typed languages, there is no problem. C++, Pascal and others have been doing it for decades.

QJo:

But of course TRWTF is "&& true", amirite? Or is this just a smart-bottomed technique to force its type?

That's what I assumed on first reading. Of course it's not very obvious. When supported (C++, C99, etc.) I'd use an explicit cast to bool, otherwise (C90 and older) I might use "!!foo", which is also not obvious the first time, but at least is a more or less common idiom used for no other purpose (unlike "&& true" which may be left over from a check removed, or a placeholder for a check to be added ...).

Paul:

The bit I really don't like is adding BOOLs.

I don't like the divide because it's not obvious, and not commented (and not self commenting), and there's also the issue that if you add another thing to check for, then the 'percentage complete' calculation would be wrong.

So, if it was me, I'd:
- change the 'adding BOOLs pattern' to using tertiary operators (slower, but for this type of check I can't see it being an issue)
- change the final calcuation to "(ct / 9) * 100" to make it a bit more obvious
- add a comment to say that if you change the number of checks, then change the calculation at the end

1. Maybe, though I don't think it's demaning too much for other programmers to know some basic rules of their language, including ordinal values of booleans (if they're well-defined in the given language).

2. At least that. Though, as others have pointed out, that kind of return value doesn't even give the caller a reliable way to check whether everything is valid (comparing against 100 is not always reliable), and a percentage is not very useful to the end-user either. So just the number of valid fields (and porobably the number of total fields, since this function is where the knowledge is how many fields there are to be validated).

3. Programmers don't read comments. A self-explanatory variable name like "total_validation_fields" stands a slightly better chance to be noticed and maintained.

If you expect maintenance often, maybe something like this, so copying/pasting a line of the validation code will keep track of the total:

total = 0; valid = 0;



total++; valid += typeof(u.nickname)==='string' && u.nickname.length>0;

total++; valid += typeof(u.websiteUrl)==='string' && u.websiteUrl.length>0;

[...]



return make_pair (valid, total);

instigator:

chubertdev:

It's odd that you get a code smell so strong from the language itself. If I were to create a language that forced users to type three equal signs in a row, I'd think, "maybe I'm doing something wrong."

Yes, but you also might be a pretentious prick.

Why only "might"?

I like that it considers 1-character résumés valid.

chubertdev:

I still can't believe that the plus sign can be used to concatenate strings in VB .NET. Talk about a huge WTF.

Then I guess you don't know that dates back to the late '70s, when computers didn't even have enough RAM to contain this web page you're reading right now.

¯\(°_o)/¯ I DUNNO LOL:

chubertdev:

I still can't believe that the plus sign can be used to concatenate strings in VB .NET. Talk about a huge WTF.

Then I guess you don't know that dates back to the late '70s, when computers didn't even have enough RAM to contain this web page you're reading right now.

I think you misunderstand me. I mean in addition to the ampersand operator. It would be like C# having both the plus sign and ampersand available for string concatenation.

anonymouse:

Any value coming from a non-checkbox is a string, not sure why you would check the type every time. Also not sure why a function is being declared anonymously, that's irritating. Also not sure what's up withe the && true statement.

function proFormComplete()

{

    var props = ['websiteUrl', 'linkedin']; // etc.

    var ct = 0;

    var u = user.getUser();

    for(var s in props)

    {

        ct += u[s].length > 0;

    }

    ct += !!u.employerSharing;

    return (props.length+1*100)/9;

}

That last line should be

return 100*ct/(props.length+1)

But as someone else mentioned, TRWTF is % completion.

Tragedian:

It seems quite an unusual method for validation, but I can see some value in quantifying how far through the validation process you are as a decimal value, rather than the usual true/false/filenotfound.

Then I got to the line:

u.employerSharing && true);

I can't even imagine what sort of person thinks "where [the] employer is sharing, and true" is a reasonable statement.

This was my first reaction 2 - forget the rest of it, what's the purpose of the "&& true"?
Or is the problem that u.employerSharing might be any odd number (I think it would have to be odd.....)

But yeah, as others have said, TRWTF is Javascript

chris:

LoremIpsumDolorSitAmet:

TRWTF is JavaScript, right? Coercing those booleans to be integers (0 or 1) is very cheeky at best - I didn't even know you could do that.

If this were ported to VB it would be even more fun because TRUE would become -1, so you'd divide by -0.09.

Coercing booleans to integers comes from C, and I think since JS is loosely-typed and has C as its most obvious ancestor, you can reasonably expect it to work.

No, No, no. C happened not to have a boolean, so people would use integers as booleans, however going the other way (and making an int from a boolean) is impossible, because the boolean type does not exist.

The biggest problem with using the same integers we use as a boolean in C as integers is that true can be multiple values.
The way C uses an integer in a boolean expression equates to something like:

#define false (0)

#define true (!false)

What is the value of true? On many compilers, it's 1. More intuitively, it should probably be 0xff. But it can actually be a whole heap of things.

int main()

{

    int total=0;

    int x=3;

    if(x) printf("%d\n", x);

    printf("%d\n", !x);

    total+=x;

    printf("%d\n", total);

    return 0;

}

which on my compiler prints:
3
0
3

C does not have a (standard) boolean type, so coercing back to an integer isn't really coercing - it's using an integer for what it's meant for. That said, it is often dangerous to use an integer simultaneously in logical and arithmetic expressions (although I'll confess I do it to check pointers are non-null)....

gallier2:

The types

_Bool

and its alias

bool

are in the C language since the C99 standard (it was already in some compilers like gcc as extension long before that).

bool b = 99;

printf("Value of b=%d\n", b);

will print

Value of b=1

OK - I stand corrected, I didn't know about _Bool, but bool gives me an "error: 'bool' undeclared", (both on gcc and it's windows friend mingw)

In that case maybe people do coerce _Bool to int....I don't really think it's a very smart (or necessary) thing to do, but there ya go.....

instigator:

I'm not a javascript expert, but that might have something to do with manipulating the return type. Just as I expect the "0 +" at the beginning of the sum is likely for type casting. But does java not have an explicit cast operator?

Java does, yes. But this is javascript, a completely different beast.

Whenever I write a piece of code, and I'm pleased with how clever it is; I rewrite it to be simpler.

eVil:

chubertdev:

instigator:

chubertdev:

I still can't believe that the plus sign can be used to concatenate strings in VB .NET. Talk about a huge WTF.

Why is that a WTF? Its a feature available in many sane languages.

You made the assertion, so the onus is yours to provide evidence (via google or otherwise) to support it. Simply stating something, and demanding that other people proove it to themselves

Take two seconds on Google to research it.

You made the assertion, so the onus is on you to provide evidence when challenged. Demanding that other people google something to prove your point is both lazy and foolish.

Children, please.
Who gives a rat's left testicle....

Harrow:

I like to think that if anyone ever asked me for a function that reported what percentage of a form was filled out correctly, I would write something a lot like this. Probably not as clear, though.

WTF specifications deserve WTF code.

-Harrow.

Why is everyone obsessed with %complete??? It's like those stupid progress bars that get slower and quicker.

Is a field with no name equivalent to a field with no age (I have several letters in my name, and will probably never reach 3 digits in age).
I sort of understand the "you have filled in 7 of 9 fields", but isn't it perhaps more useful to say "You need to put a name and surname in you fuckstick" - the user doesn't give a shit about random numbers relating to the form, they just wanna know why it keeps getting rejected.

Using http://www.codinghorror.com/blog/2008/07/spartan-programming.html spartan coding you should inline the local variable ct. That is all.

Holly Molly:

chris:

LoremIpsumDolorSitAmet:

TRWTF is JavaScript, right? Coercing those booleans to be integers (0 or 1) is very cheeky at best - I didn't even know you could do that.

If this were ported to VB it would be even more fun because TRUE would become -1, so you'd divide by -0.09.

Coercing booleans to integers comes from C, and I think since JS is loosely-typed and has C as its most obvious ancestor, you can reasonably expect it to work.

No, No, no. C happened not to have a boolean, so people would use integers as booleans, however going the other way (and making an int from a boolean) is impossible, because the boolean type does not exist.

The biggest problem with using the same integers we use as a boolean in C as integers is that true can be multiple values.
The way C uses an integer in a boolean expression equates to something like:

#define false (0)

#define true (!false)

What is the value of true? On many compilers, it's 1. More intuitively, it should probably be 0xff. But it can actually be a whole heap of things.

int main()

{

    int total=0;

    int x=3;

    if(x) printf("%d\n", x);

    printf("%d\n", !x);

    total+=x;

    printf("%d\n", total);

    return 0;

}

which on my compiler prints:
3
0
3

C does not have a (standard) boolean type, so coercing back to an integer isn't really coercing - it's using an integer for what it's meant for. That said, it is often dangerous to use an integer simultaneously in logical and arithmetic expressions (although I'll confess I do it to check pointers are non-null)....

C (before C99) did not have a Boolean type, but well-defined Boolean values, 0 and 1. Each Boolean operator (&&, ||, !) returns 0 or 1. Not on "many compilers", but on all correct compilers. Certainly not 0xff, since the size of int is not specified, but usually larger than 8 bits (or 9 bits signed ;-). Also, I'd argue that 1 is more useful, since it can be used for counting (as in today's example -- that is not the WTF about it), whereas 0xff, -1 or any other value has little practical advantage.

Your example uses just ints, so the results are what they are with ints, no surprise. The two places you use the value of x in Boolean contexts (if, !) don't change the value stored in x (why would they?), so of course total = x = 3.

Not even smart. For x && true, if x is falsy then it evaluates to x without an implicit cast.

true && true   // true

false && true  // false



1 && true      // true

0 && true      // 0



"a" && true    // true

"" && true     // ""

The only case in which it "works" is if employerSharing can be false or truthy, which is chaotic evil.

So in the remaining sane case, where employerSharing can only be false or true, the && true is just redundant and potentially confusing.

chris:

Coercing booleans to integers comes from C, and I think since JS is loosely-typed and has C as its most obvious ancestor, you can reasonably expect it to work.

The Bool type was only introduced in C99. And even now, it is defined as an integer type. I don't think that the idea of "coercing booleans to integers" comes from C...
In spite of the obvious differences, the code is clear and intuitive in BASIC. Because BASIC did not have seperate logical and arithmetic operators, all boolean operations were arithmetic operations. That is why, unlike FORTRAN, BASIC evaluates all terms in a boolean/arithmetic expression, and that is why, unlike C, !0 = -1.

This leads me to suspect that the original author had strong experience with some version of BASIC. To an experienced programmer, the code is obvious. To a C programmer, as indicated in the discussion, not so much.

Tod:

It's still shitty code. No need to repeat all that.

ct=0;

elementslist = [u.nickname, u.websiteUrl, u.linkedin, u.locationString, u.title, u.bio, u.imageUrl, u.resume]

for element in elementslist:

    if typeof(element)=="string" and element.length>0: ct += 1

if u.employerSharing: ct += 1

return 100*ct/(len(elementslist)+1);

Python syntax. I don't know if you can get rid of the "u." in elementslist easily.

You can if you use strings and property indexing:

var ct=0;

var elementslist = ['nickname', 'websiteUrl', 'linkedin', 'locationString', 'title', 'bio', 'imageUrl', 'resume'];

for (var i = 0; i < elementslist.length; i++) {

    var element = u[elementslist[i]];

    if (typeof(element)=="string" && element.length) ct++;

}

Holly Molly:

gallier2:

The types

_Bool

and its alias

bool

are in the C language since the C99 standard (it was already in some compilers like gcc as extension long before that).

bool b = 99;

printf("Value of b=%d\n", b);

will print

Value of b=1

OK - I stand corrected, I didn't know about _Bool, but bool gives me an "error: 'bool' undeclared", (both on gcc and it's windows friend mingw)

In that case maybe people do coerce _Bool to int....I don't really think it's a very smart (or necessary) thing to do, but there ya go.....

You have to include stdbool.h to have the bool alias (required by the standard).

Wow, let's build our own int, so we won't mix types:

function getInt( n ) {

    var i = false + false;

    for (var k = 1; k <= n; k++) i += true;

    return i;

}



function getBootstrappedInt( n ) {

    return getInt( getInt( n ) );

}

Now we only need to add floating point arithmetics ...

Looks like someone didn't get the memo about readable code.

Booleans are assimiled to int since ages, just look at power switch (1/0) or in electronic, the way a line with no signal which maps to a false has 0v. Bools also works as integers: commutative, transitive, etc if you map && to * and || to + mapping anything greater then 1 to 1 to stay within the boolean values. In fact a bool is just a bit 1 or 0 or in C a word (8, 16, 32 or 64 bits) artificially limited to 1 bit.

For the implementation of the function, that's where I would use a map and a reduce (https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/map https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/reduce)

Accuracy and precision requirements very with use. I doubt there is a problem here. Its a display value to give the user some idea how much more agony they have ahead filling out answers to questions that at least to them and quite likely in general are asinine to their purpose.

Yes 101% will look stupid but you won't show them that, when proFormComplete >= 100 you will simply move on to the next application screen. The rest of the time users won't know or care if you display 48% complete when its really 47% or whatever.

luolimao:

...
But as someone else mentioned, TRWTF is % completion.

Clearly you've never had to develop anything at the behest of a "marketing" department who, by definition, know what the customer / end-user wants.

Maybe every one should be made to put up the code they would use, in their choice of language, before their comment. Then we could all safely ignore the rest of the comment if the code is obviously pants. That certainly would have saved me the time it took to read Capitalist's comment.

TRWTF is actually requiring linkedin for application ...

Snowrat:

The real WTF is dividing by 0.09 and incurring a slow division instead of multiplying with 11.11

The problem is: I don't know if your remark is sarcastic or stupid. Let's just say that the form will never be 100% filled with that change.

Canatella:

in electronic, the way a line with no signal which maps to a false has 0v.

It shouldn't be assumed in a digital circuit that voltage high is 'true' and voltage low is 'false'.

why .09, why not .10

Rootbeer:

Canatella:

in electronic, the way a line with no signal which maps to a false has 0v.

It shouldn't be assumed in a digital circuit that voltage high is 'true' and voltage low is 'false'.

Or, for that matter, vice versa. Some circuits go as far as toggling the voltage level on one line for 1 and another for 0. Really. Hardware designers are crazy…

bgodot:

Whenever I write a piece of code, and I'm pleased with how clever it is; I rewrite it to be simpler.

Whenever I write a piece of code, and I'm pleased with how clever it is; I write a large paragraph above it explaining what it does.

Ben:

why .09, why not .10

Because you are only validating against 9 fields.

The math works like this:
Number_of_fields_good / Total_Number_of_fields = %percentage of fields complete.

So (for an example) 8 validated fields out of 9 would return .88(8888etc), which multiplied by 100, will return 88(.88+), which can be used as a percentage.

What this particular developer here instead of multiplying by 100, was use the inverse; he divided the number of fields by 100, and then divided the total number of valid fields (8 in our example: 8/.09=88.88+) so that he would get 88.88+% without needing to do any more math. Then he runs ciel (rounds up to the nearest whole number) yielding 89%.

LoremIpsumDolorSitAmet:

TRWTF is JavaScript, right? Coercing those booleans to be integers (0 or 1) is very cheeky at best - I didn't even know you could do that.

If this were ported to VB it would be even more fun because TRUE would become -1, so you'd divide by -0.09.

When I define my next language, I'm making TRUE coerce to imaginary I. Then, it will never be less or more than anything.

I think it should be a little clever-er, so it can be like installation progress bars. You know, you fill in one field, "9% done!" Fill in two fields "18% done!" Fill in three fields "18% done!" Fill in four fields "18% done!" Fill in five fields "1% done!" Fill in six fields "98% done!" ...

jEDI:

Maybe every one should be made to put up the code they would use, in their choice of language, before their comment. Then we could all safely ignore the rest of the comment if the code is obviously pants. That certainly would have saved me the time it took to read Capitalist's comment.

How typical of you pussy programmers!

Guys like you always talk about maintainability, but when someone proposes a solution that is actually maintainable (add a field: copy/paste one line and you get both counts correct), you get shocked when it doesn't conform to what you know. Two statements on a single line? Hell, how dare he! Seen it all too often. So next time, don't talk about maintainability, talk about not wanting to learn anything new because it bends your little mind.

To me, transforming 100*ct/9 to ct/0.09 is what makes this snippet to go from "meh, not wtf" to "wtf is that dark magic ?" because you cannot tell easily what the programmer is trying to achieve.
Of course using a comment or a descriptive name could have done it, ut neither of them can be found, so in my book this classifies as bad code.

From this snippet this may not seem obvious, but the person that thinks it is better to write 0.09 than 9/100 is probably the same one that gave you this clusterfuck of code that reverses a matrix in 3 undecipherable lines but is not efficient at it and suffers a bug your boss asked you to remove.

gallier2:

It's actually quite clever. Of course it demands from the developer who reads that, some arithmetic and boolean skills.
I know, it's asking a lot from people who actually are supposed to know how to crunch numbers. Transforming 100*ct/9.0 to ct/0.09 should be obvious to anyone, and if it isn't, pull down that keyboard and search for another job, more tuned to your skills (flipping burgers, collecting garbage or whatever).

Not a WTF, in my opinion.

Well, saying it's validation while it's percentage calculation combined with the fact that the actual percentage calculation is hidden is somewhat a WTF.

Here you can find some WTFs that are not really WTFs but they are misunderstandings. When WTF is said not to be WTF, it should be a big red flashing <marquee> warning: some day you will miss a WTF that you made yourself and you will make your coworkers very angry.

Amakudari:

Not even smart. For x && true, if x is falsy then it evaluates to x without an implicit cast.

true && true   // true

false && true  // false



1 && true      // true

0 && true      // 0



"a" && true    // true

"" && true     // ""

The only case in which it "works" is if employerSharing can be false or truthy, which is chaotic evil.

So in the remaining sane case, where employerSharing can only be false or true, the && true is just redundant and potentially confusing.

Nice work, and completely correct. It's amazing that so many others missed this.

To give those here who continue to claim that the code is well written some food for thought, here's a simpler example:

[10:44:25.966] 1 + 2 + 3 + ("" && true) + 4
[10:44:25.968] "64"

Javascript has a nuance that other languages don't with regards to boolean operations: they will always return either the first falsy or last truthy operand in the statement - NOT necessarily a boolean.

This is an extremely powerful feature and allows developers to create short and sweet validation statements. For example:

var firstSurname = (isMarried && maidenName) || currentSurname;

The above is rather a variation on a ternary expression, but you can see the potential for reducing many complex validation tasks down into a single simple step.

Why do you think a TDWTF submission can have only one "the real WTF"? This one is a minor cornucopia of WTF.
As hinted elsewhere, the overall WTF is that you CAN write code like this, and it works (insert frown 'smiley' here).
If you want to identify the specific "real WTF", it's that apparently, u.employerSharing must be True to be valid.
Another WTF, only hinted at, is why check the type of the variables? I don't mean because non-checkboxes will be strings. I mean the type is not a user input. An error there would be a program error (i.e. BUG), not an data validation issue.

Why was "&&true" included with u.employerSharing you ask? Programmer OCD, obviously. All the other fields have 2 conditions tested.

And lastly, regarding math on strings, in Perl you can't do true math on non-numeric strings, but you can do incrementing (++) on alpha-numeric strings, with results like "AA"++ = "AB" and "AZ"++ = "BA".