rjmccall posted:

Curly braces inside parentheses are how you get functional composition of expressions in C.

Orzo posted:

It's possible that someone just started creating a class that implements some interface (error / notify) but forgot to finish it, and hopefully forgot to even hook it up to anything. Not really that unusually or horrible.

npe posted:

Ugg boots posted:

I love how one of them has data.Length < 7, and one has data.Length < 8. Obviously this is correct, but it means that there was a bit of attention paid to the functions...

Hot Dog Day #55 posted:

My boss woke up the other morning and decided we'd be writing all future code in Python 2.4. We develop high speed real time systems and we're all C++ developers.

Smugdog Millionaire posted:

Coding horror or no?

It might be be the best solution (better imo) but at least it does something you don't get from just writing the code out sequentially.

Ryouga Inverse posted:

I can't think of a real-world scenario in which this is a valid option. You're calling four pairs of methods that take no parameters in parallel and you can't figure out how to refactor that to call the same two methods four times with a parameter?

And if they're doing totally different things, then this code is misleading, because the for loop structure implies that you're doing something similar in each step.

It looks like the only "gain" here is that you don't have to wrap each individual method in a try-catch, but again, refactoring the called methods to take a parameter would be the way to go.

This is a horror because it's not obvious what is happening. Your linked code isn't really any better.

Ugg boots posted:

Why wouldn't you do this? (.NET 4.0) I don't know why you're using that Parallel ForEach poo poo.

Smugdog Millionaire posted:

...

Ugg boots posted:

Here's an improved version of yours:

code:

WaitAndLogExceptions(
    () => {
        DoSomethingForOne();
        DoOtherThingForOne();
    },
    () => {
        DoSomethingForTwo();
        DoOtherThingForTwo();
    },
    () => {
        DoSomethingForThree();
        DoOtherThingForThree();
    },
    () => {
        DoSomethingForFour();
        DoOtherThingForFour();
    }
);


private static void WaitAndLogExceptions (params Action[] actions) {
    Task[] tasks = new Task[actions.Length];
    for (int i = 0; i < actions.Length; i++)
        tasks[i] = Task.Factory.StartNew(actions[i]);

    try {
        Task.WaitAll(tasks);
    }
    catch (AggregateException e) {
        foreach (var ex in e.InnerExceptions) {
            logger.LogException(ex);
        }
    }
}

I bet we can make it prettier, too.

necrobobsledder posted:

I thought the for-case pattern starts becoming valid when you start running things out of sequence like in a series of random tests and may be useful to show that they're different test cases with so much test coverage of inputs:

Plorkyeran posted:

i.e. when it's not actually for-case?

Trapick posted:

I'm doing a group project for uni, and there's some *horrendous* code flying around. I mean, I don't know what I'm doing, but I know better than this...

code:

function renamedFunction(parm1)
{
    if(someOtherFunction(global1, global2))
    {
        return true;
    }
    return false;
}

There's about a dozen functions just like this. It hurts my brain every time I think about it, for several reasons.

Amarkov posted:

Unfortunately, things like that are kinda inevitable when working in group projects. If you told your partners you'd make a function named X that does Y, you sometimes have to deliver that function, even if it turns out you need to do things like wrap another function inside it and use global variables. There are just too many people who will refuse to refactor their code with the changes you made.

karoshi posted:

It also can be dereduntalely rewritten reducing it's written redundant redundacy as:

pre:

function renamedFunction(parm1)
{
    return someOtherFunction(global1, global2);
}

Amarkov posted:

I was considering pointing that out too, but I've had at least one somewhat competent guy explain to me that he really prefers it when people have an explicit branch. Not that it isn't a retarded way to write code, but I don't like to cry coding horror when some poor dude is just following the style guide.

bobthecheese posted:

Just be ecstatically happy that you're in a group where other people actually write code at all.

Plorkyeran posted:

Some of my favorite group projects in college were the ones where other people didn't try to write code. A terrible group member is much worse than one that does nothing.

Trapick posted:

It's worked out pretty good, actually. We have a group member who can't write code to save his life, but he knows it, so he's doing an insane amount of testing. Very, very handy.

Zaxxon posted:

why do I keep seeing crap like this.

#define BSP_DISABLE_RXMP __BSP_DISABLE_RXMP__

and such. Really who does this poo poo help?

evensevenone posted:

it's the end of the quarter, and I already wrote transpose, so why waste time?

code:

GraphRef copyGraph(GraphRef G)
{
	return transpose(transpose(G));
}