Comment On You’ve Got to Give to Retrieve

Three-D:

And here I was hoping it was going to be the division by 2D. WTF is that?

int i = 5 / 2; //i is 2

double d = 5 / 2; //d is 2.0 (autocast int -> double, but only after the division)

double d = 5 / 2d; //d is 2.5

Mike:

So, clearly the real WTF is Java (again)

Mike:

So, clearly the real WTF is Java (again)

faoileag:

This CodeSOD is a good example on why I have ambivalent feelings about Getters/Setters - people tend to think that they are just a smart way of expressing "public decimal mMidPrice" and tend to forget that underneath the nice syntax they are really fully-fledged methods.

Steve The Cynic:

faoileag:

...that underneath the nice syntax...

You mean "the deceptive syntax", don't you?

Steve The Cynic:

One of your differently abled fine colleagues

Dee:

The real WTF is the person debugging the code.

nonRunnerForm.MidPrice = ((Convert.ToDecimal(row.Item(HermesColumns.Events.LiveBuyPrice)) + Convert.ToDecimal(row.Item(HermesColumns.Events.LiveSellPrice)) ) / 2D)

Doesn't work, so break it down:

nonRunnerForm.MidPrice = ((Convert.ToDecimal(row.Item(HermesColumns.Events.LiveBuyPrice))

Doesn't work either, so check LiveBuyPrice - looks good, so see what 'MidPrice' is doing. Ah, there's the bug.

HerrDerSchatten:

If this is Visual Studio, the Debugger would NOT step into the property call - unless you place a breakpoint in the call. This is a very deceptive behavior, which has caused me very similar pain.

HerrDerSchatten:

If this is Visual Studio, the Debugger would NOT step into the property call - unless you place a breakpoint in the call. This is a very deceptive behavior, which has caused me very similar pain.

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

A proper single-step would have stepped into the setter, at which point you would see both on the screen doing obviously different things.

HerrDerSchatten:

If this is Visual Studio, the Debugger would NOT step into the property call

StuWood:

HerrDerSchatten:

If this is Visual Studio, the Debugger would NOT step into the property call - unless you place a breakpoint in the call. This is a very deceptive behavior, which has caused me very similar pain.

That's just... wrong. Of course, the debugger would (and does) step into the property call. At least, it does by default in 2005... I'm not familiar enough with later versions to say for sure how they handle it.

VB Coder:

StuWood:

HerrDerSchatten:

If this is Visual Studio, the Debugger would NOT step into the property call - unless you place a breakpoint in the call. This is a very deceptive behavior, which has caused me very similar pain.

That's just... wrong. Of course, the debugger would (and does) step into the property call. At least, it does by default in 2005... I'm not familiar enough with later versions to say for sure how they handle it.

The newer versions have an option in the debugger settings that will step into property getters/setters. It is off by default, but I don't know why you would want it off.

Zylon:

Dear Bruce,

DON'T EXPLAIN THE JOKE.

Valued Service:

VB Coder:

StuWood:

HerrDerSchatten:

If this is Visual Studio, the Debugger would NOT step into the property call - unless you place a breakpoint in the call. This is a very deceptive behavior, which has caused me very similar pain.

That's just... wrong. Of course, the debugger would (and does) step into the property call. At least, it does by default in 2005... I'm not familiar enough with later versions to say for sure how they handle it.

The newer versions have an option in the debugger settings that will step into property getters/setters. It is off by default, but I don't know why you would want it off.

What's all this?

I have two keys, F10 steps over and basically steps per line at the current stack level.

F11 steps into everything, including properties.

a feature that was his responsibility. A feature that, if it wasn’t delivered, would mean a failed sprint for the entire team.

DrPepper:

The fundamental cause of this bug is a DEVELOPER. The developer who wrote the implementation of the getter and setter MUST preserve the functionality of the get/set paradigm. If you want to, you can add side effects (the real reason to use getter/setter over bare properties). However, you don't break the paradigm.

The developer who broke the property should be [publicly humilitated][repremanded][dragged into the square and shot]

faoileag:

This CodeSOD is a good example on why I have ambivalent feelings about Getters/Setters - people tend to think that they are just a smart way of expressing "public decimal mMidPrice" and tend to forget that underneath the nice syntax they are really fully-fledged methods.

attr_accessor :foo

faoileag:

I'm still wondering if the lesson learned from that experience should be: "don't do things you're coworkers would not expect", even if said things were the better way to do it (ternary operators, any one?).

shadowphiar:

a feature that was his responsibility. A feature that, if it wasn’t delivered, would mean a failed sprint for the entire team.

Is this the real WTF? It sounds like you're using "near-scrum" agile development. Either bugs are the responsibility of individual developers, or missing features mean a failed sprint for the entire team, in which case its everybody's problem. Having the whole team take responsibility for hitting the schedule is not supposed to result in everybody pointing their fingers at one developer and saying "it was his fault".

Hmmmm:

Zylon:

Dear Bruce,

DON'T EXPLAIN THE JOKE.

It wasn't a joke until it was explained. This wouldn't have been very funny...

It was a dark and stormy night, but the weather was not a deterrent to Craig.

Jazz:

This is why I love Ruby. Here's the complete code for both a getter and a setter for the property foo in a Ruby class:

attr_accessor :foo

That's it, that's all. The rest is magically generated by the language. It's pretty hard to screw that up.

Public Property MidPrice() As Decimal

This is why I love Ruby. Here's the complete code for both a getter and a setter for the property foo in a Ruby class:

attr_accessor :foo



That's it, that's all. The rest is magically generated by the language. It's pretty hard to screw that up.

faoileag:

This CodeSOD is a good example on why I have ambivalent feelings about Getters/Setters - people tend to think that they are just a smart way of expressing "public decimal mMidPrice" and tend to forget that underneath the nice syntax they are really fully-fledged methods.

Steve The Cynic:

DrPepper:

The fundamental cause of this bug is a DEVELOPER. The developer who wrote the implementation of the getter and setter MUST preserve the functionality of the get/set paradigm. If you want to, you can add side effects (the real reason to use getter/setter over bare properties). However, you don't break the paradigm.

The developer who broke the property should be [publicly humilitated][repremanded][dragged into the square and shot]

Defenestrated.

Because it's an awesome word.

Jazz:

faoileag:

This CodeSOD is a good example on why I have ambivalent feelings about Getters/Setters - people tend to think that they are just a smart way of expressing "public decimal mMidPrice" and tend to forget that underneath the nice syntax they are really fully-fledged methods.

This is why I love Ruby. Here's the complete code for both a getter and a setter for the property foo in a Ruby class:

attr_accessor :foo

That's it, that's all. The rest is magically generated by the language. It's pretty hard to screw that up.

(Captcha: 'acsi' -- ascii's little brother.)

public int Value { get; set; }

Bananas:

Hmmmm:

Zylon:

Dear Bruce,

DON'T EXPLAIN THE JOKE.

It wasn't a joke until it was explained. This wouldn't have been very funny...

It was a dark and stormy night, but the weather was not a deterrent to Craig.

But It was a dark and stormy night, the kind of night envisioned by Mr. Bulwer-Lytton. would have at at least sent a bunch of readers scurrying off to Google.

Valued Service:

public int Value { get; set; }

public int value;

Steve The Cynic:

...
example: C's square bracket array index notation is a nice syntax:

A[index] == *(A+index) <<== Always true in C, provided index is in range.

But it has its deceptive aspects, because A could be a naked pointer... (Thus leading to the common misbelief that C pointers and arrays are the same thing.)

chubertdev:

Jazz:

This is why I love Ruby. Here's the complete code for both a getter and a setter for the property foo in a Ruby class:

attr_accessor :foo

An auto-implemented property should have been used in this case:

Public Property MidPrice() As Decimal

instigator:

.net has that too. In c# it's: SCOPE TYPE NAME {get; set;}

Valued Service:

.net 4.0

public int Value { get; set; }

faoileag:

... if the setter and the getter are not close together in the source ...

dkf:

The NULL value apparently came from a function that would specifically make the process panic nicely if the memory allocation failed;

dkf:

make the process panic nicely

dkf:

panic nicely

dkf:

panic nicely

dkf:

panic nicely

Manni_reloaded:

I always choose my programming language based not on lines of code, but on the # of characters on each line.