chippy posted:

I just found this line of C# to check that two ints (noDetails, noPictures) are equal. it took me a second to even parse it's purpose.

code:

var areEqual = new[] { noDetails, noPictures }.Distinct().Count() == 1;

Bruegels Fuckbooks posted:

isn't that present tense? i mean, facebook did move from "Move fast and break things" to "Move Fast With Stable Infra," and google has progressed to actually supporting products for longer than a year before the programmers get bored, but job postings are still slobbering all over the agile bullshit, and the visionaries at my company decided to take the SAFe agile poo poo seriously so within the past two weeks, my inbox has been clogged with diagrams that look like:

a hot gujju bhabhi posted:

It is definitely present tense. And I don't think agile is to blame so much as misapplication of it.

Steve French posted:

You know what to call a tool that nobody can figure out how to use correctly?

A lovely tool.

Bruegels Fuckbooks posted:

isn't that present tense? i mean, facebook did move from "Move fast and break things" to "Move Fast With Stable Infra," and google has progressed to actually supporting products for longer than a year before the programmers get bored, but job postings are still slobbering all over the agile bullshit, and the visionaries at my company decided to take the SAFe agile poo poo seriously so within the past two weeks, my inbox has been clogged with diagrams that look like:

taqueso posted:

I know I'm a little late and this is C#. I'm not a rust genius, but wouldn't the equivalent in rust compile to a simple comparison? (I've been reading the rust book so it is on my mind)

Seems like it is one step away from being generic for any size collection.

e: pre-emptive "this isn't clearer and isn't better code than the standard aaa == bbb for this case, just musing"

taqueso posted:

I know I'm a little late and this is C#. I'm not a rust genius, but wouldn't the equivalent in rust compile to a simple comparison? (I've been reading the rust book so it is on my mind)

Seems like it is one step away from being generic for any size collection.

e: pre-emptive "this isn't clearer and isn't better code than the standard aaa == bbb for this case, just musing"

HappyHippo posted:

While I generally agree with this sentiment, in this case I think what happened is a bunch of marketers and consultants turned agile into Agile™ in order to cash in on the hype. Of course that means it has to be as complicated as possible because otherwise you wouldn't need to pay consultants to tell you how to figure it out

Jabor posted:

Also the name is literally a racial slur.

chippy posted:

*e: Actually, I'd probably be more likely to do something like

code:

allEqual = listOfInts.All(x => x == listOfInts.First())

, after checking the list is not empty obviously.

chippy posted:

I don't know Rust, or enough about any compiler to know if any of them would optimise this away to a single comparison.

And yeah, you're right, it's not a bad way to do it for a variable-sized collection really. It also looks quite a lot like something I would write if I was dealing with a variable number of ints*, and not something something the dev in question would write; he would almost definitely use a loop. So I can only conclude he actually lifted the pattern from some of my code, but why he went to the trouble of doing that instead of just writing isEqual = noDetails == noPictures is beyond me.

*e: Actually, I'd probably be more likely to do something like

code:

allEqual = listOfInts.All(x => x == listOfInts.First())

, after checking the list is not empty obviously. It would probably perform a fair bit better because All() will exit and return false as soon as it finds an unequal value, instead of having to Distinct() and Count() an entire list just to find that out.

NihilCredo posted:

No need to do that, if the list is empty .All() will immediately return true anyway

QuarkJets posted:

You only dislike the weak bosons because they have a mean decay time greater than your longest-held erection

Send your wife over my way I will show her what real alpha decay looks like

Jeb Bush 2012 posted:

this is the most owned I have been since 50 CERN researchers published a paper on my "low energy physics"

Klades posted:

Steve French posted:

You know what to call a tool that nobody can figure out how to use correctly?

A lovely tool.

taqueso posted:

I know I'm a little late and this is C#. I'm not a rust genius, but wouldn't the equivalent in rust compile to a simple comparison? (I've been reading the rust book so it is on my mind)

Seems like it is one step away from being generic for any size collection.

e: pre-emptive "this isn't clearer and isn't better code than the standard aaa == bbb for this case, just musing"

VikingofRock posted:

Just tested it out, and the answer is yes! Both for iterator-style and imperative style.

Input:

Rust code:

extern crate itertools;

#[no_mangle]
pub fn foo_iter(x: u32, y: u32) -> bool {
    use itertools::Itertools;
    vec![x, y].into_iter().dedup().count() == 1
}

#[no_mangle]
pub fn foo_imperative(x: u32, y: u32) -> bool {
    let mut v = vec![x, y];
    v.dedup();
    v.len() == 1
}

output assembly (compiled with --release, lto=true):

code:

	.section	__TEXT,__text,regular,pure_instructions
	.globl	_foo_iter
	.p2align	4, 0x90
_foo_iter:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	cmpl	%esi, %edi
	sete	%al
	popq	%rbp
	retq
	.cfi_endproc

	.globl	_foo_imperative
	.p2align	4, 0x90
_foo_imperative:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset %rbp, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register %rbp
	cmpl	%edi, %esi
	sete	%al
	popq	%rbp
	retq
	.cfi_endproc


.subsections_via_symbols

I'm impressed.

Doom Mathematic posted:

Agile and Waterfall are not mutually exclusive. They aren't even the same kind of thing.

QuarkJets posted:

Oh hey I remember you, our arxiv post suggested that your manhood represented a breakthrough discovery because even in an excited state it has less energy than the vacuum ground state lol. Tell your mom that the ATLAS liquid argon calorimetry group says hi

(BTW argon is odorless, unlike your breath)

Eela6 posted:

That's wild. I would be interested to hear about the compiler magic behind that.

taqueso posted:

Rust code:

extern crate itertools;

use std::iter::IntoIterator;
use itertools::Itertools;

pub fn foo_generic<T, U>(items: T) -> bool
where T: IntoIterator<Item=U>,
      U: PartialEq
{
    items.into_iter().dedup().count() == 1
}

This works with slices and vectors, but I'm getting lost looking at the source output trying to find the code generated. I have to go for a bit but I wanted to post it before I left.

Klades posted:

Spatial posted:

C++ code:

    // Have to do this twice or it doesn't detect devices on startup. lol
    for (uint32_t i=0; i<2; i++) {
        USB_Init( HIDIF.Config.PortNumber, USB_MODE_Host );
    }

Is the horror me or the USB library?

a hot gujju bhabhi posted:

I didn't say nobody could figure it out, I said that some people were using it poorly or incorrectly.

Steve French posted:

Yeah, I know you weren't saying that, and I didn't mean to imply that you were, though now I see that I did.

What I was alluding to is that agile horror stories are incredibly common, and almost always someone responds to them with a suggestion or claim that they weren't doing it right.

Well, yeah.

The indication to me here when that's so common is that it's a failure of the tool, not just a failure of those misusing it.

There have been lots of discussions about Git here, and the sharp edges it has, and inevitably someone responds with a comment about how it's really not that hard and something about directed graphs. Personally, I don't have issues with it, but I totally get the perspective that when those issues are so common, there's a tool problem, even though I have seen it used very well.

I think of agile in the same way

taqueso posted:

Rust code:

extern crate itertools;

use std::iter::IntoIterator;
use itertools::Itertools;

pub fn foo_generic<T, U>(items: T) -> bool
where T: IntoIterator<Item=U>,
      U: PartialEq
{
    items.into_iter().dedup().count() == 1
}

This works with slices and vectors, but I'm getting lost looking at the source output trying to find the code generated. I have to go for a bit but I wanted to post it before I left.

Doom Mathematic posted:

Agile and Waterfall are not mutually exclusive. They aren't even the same kind of thing.

iospace posted:

Please explain how they're A. not mutually exclusive, and B. not even the same kind of thing.

repiv posted:

Rust Playground allows you to import the most popular crates (which includes itertools) so you can easily peek at the disassembly on there

https://play.rust-lang.org/?gist=95ac417519ad84d133ac7982bc496059&version=stable

VikingofRock posted:

I couldn't figure out how to turn on LTO there, which is necessary to get itertools iterators to compile away.

repiv posted:

Rust Playground allows you to import the most popular crates (which includes itertools) so you can easily peek at the disassembly on there

https://play.rust-lang.org/?gist=95ac417519ad84d133ac7982bc496059&version=stable

taqueso posted:

Thanks!