Welcome to the Lounge

CDP1802 wrote:

mark other's code with the unsafe

Pete O'Hanlon wrote:

Secondly, learn how to use the power of LINQ, that Where statement is redundant so the statement can become myList.SingleOrDefault(p => p.Id == aUniqueId);

1.
var found = collectionClass.FirstOrDefault(i => i.Field == searchValue);

or
2.
var found = collectionClass.Where(i => i.Field == searchValue).FirstOrDefault();

or
3.
foreach(item in collectionClass)
{
if (item.Field = searchValue)
{
found = item;
break;
}
}

bool IsValid(Entity myEntity)
{
    if (myEntity.Property = null) return false;

    myEntity.OtherProperty = SomeValue;
    DbService.Save(myEntity);

    OtherEntity= DbService.GetOtherEntity(myEntity.Property);

    return true;
}

if (!notSaved || !isInvalid)

Charl wrote:

2. Refusing to commit code until it is "perfect"

var i, o;
for(i = 0; (function() { ... })(); ++i) {
   o = new (objlist[i])();
}

Allow me to submit something a bit off-axis: a habit of thought.

In more than one place where I've worked, I've encountered persons so confident in their skills that they didn't bother to test "trivial changes." Such "trivial changes" caused major crashes in important products, more often than I (or they) would care to remember. Inasmuch as for many years it's been a large part of my responsibilities to train young software engineers, it's been the very first thing I've pounded on: there is no such thing as a change too small to test.

Some took the advice to heart, but not all -- and when the bills came due, the incredulity of the sinner at issue was often thick enough to slice: "But all I did was...!"

We're fallible, each and every one of us, from the dunces to the geniuses, and from the brand-new graduates to the fifty-year veterans. But an engineer's ego can be resistant to that homily...until he's experienced the consequences on his own hide.

My "favorite" case of excessive confidence involves a young turk -- let's call him Andy, as that was his name -- who was assigned a component in a large monolithic application intended to run on a VAX under VMS. Andy was excessively fond of assembly language, and was eager to write his piece in VAX assembler. I counseled him against it -- the rest of the application was written in C -- but couldn't dissuade him. To shorten the story a bit, some weeks later Andy presented me with his component, which I added to the build without comment. The resulting application ran for approximately twenty seconds before it crashed -- and it didn't just bring down the app; it crashed VMS with a "bug check" error.

The problem was, of course, in Andy's module. I pointed it out to him at once. The subsequent exchange ran roughly as follows:

FWP: Did you test it?

Andy: Well...

FWP: This instruction [I pointed it out] is out of sequence. You have to allocate and enable mapping registers before it will be valid.

Andy: Well...

FWP: I expected you to test this before you brought it to the link.

Andy: But it assembled without errors, so I figured it was right!

Words fail me, friends.