The Laziness of LINQ
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
I could have told you 20 years ago that that's a battle you're certain to lose. But I guess you know that by now. ;P
Kitty at my foot and I waAAAant to touch it...
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
Lambdas are exactly the same - thousands of inline functions all called f()... (Some people still think that Maths is the only metaphor in IT[^] )
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
-
Everyone prefers a minified version of code, you know...
You have just been Sharapova'd.
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
Oh oh, I think he's complaining about me :(
-
Why is that mate? It helps with little to no compromise, does it not?
Dictionary> someDictionary = new Dictionary>()
vs.
var someDictionary = new Dictionary>()
even
var order = GetOrder(orderId)
is hinting with (1) the variable name and (2) the function name and
var users = account.Select(a => new { Name = a.FullName, Role = a.Role } )
is simply cool. Or are you referring to things like the following?
var money = 123m
-
I disagree, the single-letter name (in a tiny scope) clearly indicates that the reader needn't spend any extra time thinking about the value. It's a throw-away.
I love when someone writes a library and uses single-letters for the parameters. It makes finding out what the function actually needs very difficult.
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
-
Quote:
I am not a big fan of var. I think it encourages lazy programming, though used well it makes sense.
Rarely is the "var" keyword used as it was intended. I blame this on lazy programmers blindly following ReSharper's suggestion to replace every single variable declaration with "var".
"There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult." - C.A.R. Hoare Home | LinkedIn | Google+ | Twitter
Dominic Burford wrote:
blindly following ReSharper's suggestion to replace every single variable declaration with "var".
My Resharper doesn't do that, and I don't think I've changed any of the defaults :confused: Even obvious stuff like:
string message = string.Format("Error in xyz method: {0}", ex.Message);doesn't get flagged by it. -
I have to admit I use single characters for linq but I do at least try to to use the first letter of the object type (Person => p) etc. I am not a big fan of var. I think it encourages lazy programming, though used well it makes sense.
thought someone would mention this (but then read the dislike of var :( ) With
return source.Select(t => new
{
Index = rand.Next(),
Value = t
})What is 't' short for? Table? With loops, 'i' and 'x' (I assume) come from iterator and Maths use of variables. (then subsequently y follows from 'x') with linq, it is a sort of replacement for the item working on. In the case above 'source' so maybe 's' or 'src' if 'source' is too long to type.
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
If it's a single lambda parameter, and its use is limited to a few lines, I nearly always only use a one char parameter, like:
var bachelors = _people.Where(p => !p.IsMarried);
I'm also a one letter man with basic loops.
iandjall the way.No object is so beautiful that, under certain conditions, it will not look ugly. - Oscar Wilde
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
I think everyone is right here. The var keyword was put in specifically for LINQ. Yes - it does introduce a chance to code sloppy. Its a trade off. I like to use LINQ to slice over CSV Files, and other such collection queries. I don't like var though, outside on its own, without a leash. Where there's smoke, there's a Blue Screen of death.
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
Well, I wouldn't say you're TOO grumpy though I always considered those three (i,j,k) to be reserved as loop variants (Ever since FORTRAN IV) and still only use 'em for that even in my C# code! Yeah, variable names ought to be a bit more descriptive!
-
PIEBALDconsult wrote:
clearly indicates that the reader needn't spend any extra time thinking about the value. It's a throw-away.
Which is fine when you're writing it, or just reading through the code - but not when you're trying to debug non working code (esp. when more complex than the example) you need to stop and decipher.
PooperPig - Coming Soon
Quote:
(esp. when more complex than the example)
But that's the key. We're not talking about thing more complex.
Truth, James
-
Because LINQ is evil.
Regards, Rob Philpott.
Hear hear!
I may not last forever but the mess I leave behind certainly will.
-
It compromises all over the place! It saves you a couple of seconds of typing, but makes it harder to maintain because you can't just glance at the code and see what type a variable is. When you see code like:
var order = GetOrder(orderId);
You can't trust that
orderis of type Order because you are relying on the previous programmer (who you know to be lazy) to have still returned an Order from his method and not something totally different but been too lazy to change the name! Seeing it as:Order order = GetOrder(orderId);
Make it absolutely obvious at a glance - and will immediately throw a compiler error if you change the method return type. Or if the wrong
usingblock has been added and GetOrder comes from the wrong assembly alltogether. Yes, these are extreme cases - but an extra second or two of your time and it would be clear.varhas it's place, and it's vital for Linq - but that's where it should stay! :laugh:Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
The entire point of
var order = GetOrder(orderId);
is to be able to change the return type of your method, without having to track back through all the usages of that method and update all of that code as well. That said this is the one usage of var where I get a little uncomfortable for the same reasons you said. Generally speaking code using var as opposed to the actual type is easier to work on, less touch points while refactoring.
-
I disagree, the single-letter name (in a tiny scope) clearly indicates that the reader needn't spend any extra time thinking about the value. It's a throw-away.
Agree completey, and I will add that if x,y,z,etc bother you I highly doubt the other devs on the team will care if you refactor the 'x' into 'theNewFooToInsert'. Since the linq statement is fully enclosed the refactor can be done 100% using the tools built into VS or ReSharper... making it arbitrarily easy to do.
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
This isn't isolated to LINQ. You see the same behavior in for/foreach loops as well. The only time I use single letters is when the variable is for an index.
Scott E. Corbett
-
We've spent 20 years trying to teach developers not to use variables like
i,jandk. So why is it that every time I see some LINQ code it's like this:return source.Select(t => new
{
Index = rand.Next(),
Value = t
})
.OrderBy(p => p.Index)
.Select(p => p.Value);Is it really that painful to do
return source.Select(item => new
{
Index = randomiser.Next(),
Value = item
})
.OrderBy(sortItem => sortItem.Index)
.Select(sortItem => sortItem.Value);Or am I just too old and grumpy for my own good.
cheers Chris Maunder
I agree with you on the first Select because there's a little complexity in that lambda, but for the OrderBy and second Select, its one line of code, and if it isn't obvious what the parameter represents and how its being used, then a longer variable name isn't going to help the reader much. Personally, for those one-liners, I prefer the simple 'p' argument -- less for my eye to read and my brain to parse (and ignore), which means I reach understanding of the code a lot faster.
We can program with only 1's, but if all you've got are zeros, you've got nothing.
-
It compromises all over the place! It saves you a couple of seconds of typing, but makes it harder to maintain because you can't just glance at the code and see what type a variable is. When you see code like:
var order = GetOrder(orderId);
You can't trust that
orderis of type Order because you are relying on the previous programmer (who you know to be lazy) to have still returned an Order from his method and not something totally different but been too lazy to change the name! Seeing it as:Order order = GetOrder(orderId);
Make it absolutely obvious at a glance - and will immediately throw a compiler error if you change the method return type. Or if the wrong
usingblock has been added and GetOrder comes from the wrong assembly alltogether. Yes, these are extreme cases - but an extra second or two of your time and it would be clear.varhas it's place, and it's vital for Linq - but that's where it should stay! :laugh:Bad command or file name. Bad, bad command! Sit! Stay! Staaaay...
OriginalGriff wrote:
been too lazy to change the name!
Ha! The other day I wrote a GetType sort of method, it returned a Type. But then I decided to have it return a ConstructorInfo instead -- but I didn't change the name! :-D (Until the following day.)
