News for hackers. Stuff that matters.
Re:The memory safety problem isn't bad coders by jschwartzi on Tuesday February 12, 2019 @01:27PM (#19146078)
I don't really use auto unless I'm interfacing with some templatized nightmare body of code where the typename is very difficult for my tiny human brain to interpret. Using "auto" is usually a code smell, because it means your type system is too complex for you to reason about.
Re:The memory safety problem isn't bad coders by scarface74 on Tuesday February 12, 2019 @01:40PM (#19146184)
This is a valid, strongly typed C# object:

var foo = {bar = 1, baz = “Hello”, boo = “World”};

You get auto complete help and compile time type checking.

foo.bar = “Goodbye”;

Won’t compile. What would it buy you to not use ‘var’ and create a one time use class/struct?

Re:The memory safety problem isn't bad coders by maxxxxx on Tuesday February 12, 2019 @01:50PM (#19146276)
I use auto almost always. Makes the language "feel" more dynamic but you still have type safety.
Re:The memory safety problem isn't bad coders by gmueckl on Tuesday February 12, 2019 @03:06PM (#19147003)
It would make me ask why you need a one time use struct at all and probably remove it.
Re:The memory safety problem isn't bad coders by scarface74 on Tuesday February 12, 2019 @03:47PM (#19147327)
More complicated example:

var seniorMales = from c in customer where c.age > 65 && c.Sex == “male” select new {c.FirstName, c.Lastname, c.Age}

foreach(var customer in seniorMales) { Console.WriteLine(customer.Firstname + “ “ + customer.Lastname); }

Why would I create a class/struct for that use case?

Side note: this is why I find ORMs in most languages besides C# useless. Here, “customers” can represent an in memory List, a Sql table or a MongoDB collection and the LINQ expression will be translated appropriately to the underlying query syntax.

The “ORM” is integrated into the language and yes anyone can write a LINQ provider.

Re:The memory safety problem isn't bad coders by gmueckl on Tuesday February 12, 2019 @06:00PM (#19148574)
This us one of the cases where I would want you to write an explicit type for seniorMales. Reasoning about the LINQ expression is just complex enough that by not constraining its type to your expectations you can easily obscure a mistake in your thinking that would otherwise show up in the data types.
Re:The memory safety problem isn't bad coders by scarface74 on Tuesday February 12, 2019 @06:16PM (#19148703)
How so? You couldn't pass the anonymous type to another method or return it so the locality would be strong and the anonymous type is just a strongly typed POCO. Creating a class doesn't add anything semantically.

How do you feel about deconstructuring that is available in most languages?

Re:The memory safety problem isn't bad coders by maxxxxx on Tuesday February 12, 2019 @07:22PM (#19149150)
I think the anonymous type is much better. It's type safe, you can easily see how it's defined but you don't pollute the rest of your code with one-off classes that make only sense within the function.

If I had to review the code and saw an explicit type I would recommend an anonymous type.

Re:The memory safety problem isn't bad coders by gmueckl on Tuesday February 12, 2019 @07:57PM (#19149379)
It is not better. I don't know what type FirstName or Age is. Can Age be negative? Is FirstName an array of char or a string? Can FirstName be more than 10 characters long? It could be a double value for all I can tell from that line of code!
Re:The memory safety problem isn't bad coders by scarface74 on Tuesday February 12, 2019 @08:09PM (#19149444)
The select statement is projecting the Customer type from either an external data source or an in memory source. That information wouldn’t be encoded into the POCO whether or not it was anonymous.

Changing select new {...} to Select new SeniorPeople {...} wouldn’t give you any more information. At most if I was writing that as part of a repository class I would be sending you back an IEnumerable<SeniorPeople>.

If you were to send me an expression to use in the where clause you would send me an

<Expression<Func<SeniorPeople,bool>>

You have no idea what that expression is going to be translated to until runtime.

Either way, you are just working with non concrete Expression Trees that could be transformed into IL, SQL, a MongoQuery etc. All of the constrainsts would be handled by your data store.

You don’t even know before hand whether you are iterating over an in memory list, or streaming from an external data source.

I could switch out Sql Server for Mongo and you as the client wouldn’t be any the wiser.

And we haven’t even gotten to the complication if the result set was the result of a LINQ grouping operation.

Re:The memory safety problem isn't bad coders by gmueckl on Tuesday February 12, 2019 @08:30PM (#19149554)
You are comstructing an elaborate strawman that does nothing to work in your favor. If anything, yur essay just makes it clear that it is impossible to glean the data type from the LINQ expression itself.

Yet, any code using its result will contain implicit assumptions about that data. Therefore, in order to maintain type safety, the expected type of the return value must he stated.

That type must also be independent from whatever LINQ does internally to produce that return value. Otherwise, the LINQ providers wouldn't be as exchangeable as you claim.

Re:The memory safety problem isn't bad coders by scarface74 on Tuesday February 12, 2019 @08:54PM (#19149659)
You also included information about “constraints” like is it a positive or negative number and string length. That wouldn’t be encoded in the type. Why would I go look up the types either way? I’m using a strongly typed language, the IDE would tell me that anyway. While I am writing code, I see a red dot showing me immediately if I’m using the type incorrectly. Any assumptions that were incorrect, I would get immediate feedback.
Re:The memory safety problem isn't bad coders by gmueckl on Tuesday February 12, 2019 @10:34PM (#19150148)
Not necessarily. Is Age unsigned or not? This constrains the possible range of values. In other contexts, there is a lot more information inferred by the integer type used.
Re:The memory safety problem isn't bad coders by maxxxxx on Tuesday February 12, 2019 @09:46PM (#19149914)
Do you actually work with C#, LINQ and generics?
Re:The memory safety problem isn't bad coders by gmueckl on Tuesday February 12, 2019 @10:14PM (#19150047)
Yes. I am quite familiar with them.
Re:The memory safety problem isn't bad coders by maxxxxx on Tuesday February 12, 2019 @10:30PM (#19150115)
Then tell me how you can model in C# a type where a property can’t be negative or a certain length.
Re:The memory safety problem isn't bad coders by gmueckl on Tuesday February 12, 2019 @11:55PM (#19150530)

    class Foo {
      public uint Bar { get; set; }

      private char[] _baz;

      public char[] Baz { get { return _baz;} }

      public Foo() { _baz = new char[5]; }
    }
This is cheating a bit on the array part. But the length of that char array is set in stone and cannot be changed from the outside. However, the Bar property uses a standard C# datatype.
Re:The memory safety problem isn't bad coders by maxxxxx on Wednesday February 13, 2019 @06:27AM (#19152249)
I honestly thing that you haven't done any real work with LINQ or you are imagining problems that don't exist. The char array is not usable as string or we have to go back to 0 terminated strings like C.
Re:The memory safety problem isn't bad coders by gmueckl on Wednesday February 13, 2019 @02:27PM (#19155968)
I am not imagining problems that don't exist in the application domains I work on.

If your environment is so relaxed that aspects like signedness of an integer don't matter, so be it. But then you are also far removed from a domain where software correctness is non-negotiable.

Re:The memory safety problem isn't bad coders by scarface74 on Thursday February 14, 2019 @09:40AM (#19162151)
It’s not aspects “like signednes” that’s the only constraint that you could embed in your defined POCO and still use as a select projection that would survive a LINQ expression that was turned into an expression tree. Your data store would enforce the other constraints. Your C style character array as a string wouldn’t work with either LINQ nor any of the standard library.

Are you really trying to go back to the bad old days with Microsoft C/MFC/WIN32/COM where you had over a dozen ways to represent a string that you had to convert to and from depending on which API you were using?

Re:The memory safety problem isn't bad coders by scarface74 on Wednesday February 13, 2019 @12:51AM (#19150773)
And your class wouldn’t work as part of the LINQ example. EF for example wouldn’t know how to translate it.
Re:The memory safety problem isn't bad coders by maxxxxx on Tuesday February 12, 2019 @08:21PM (#19149503)
How do you want to model this in C#? Write a full class with all kinds of checking for a single LINQ operation? That will be a very bloated codebase.
Re:The memory safety problem isn't bad coders by maxxxxx on Tuesday February 12, 2019 @01:48PM (#19146267)
Not necessarily. The types may just have very long names. In C++ for iterating through STL container auto is a godsend. The types are very straightforward and easy to reason about but just long.

for (auto it = s.begin(); it != s.end(); it++) {

is much easier to write than

for (vector<int>::iterator it = s.begin(); it!=s.end(); it++) {

Re:The memory safety problem isn't bad coders by jschwartzi on Tuesday February 12, 2019 @02:03PM (#19146411)
I try to avoid using STL because it A) throws exceptions, B) has really convoluted type names, and C) dynamically allocates memory. These are all things you avoid in the embedded space.
Re:The memory safety problem isn't bad coders by maxxxxx on Tuesday February 12, 2019 @02:22PM (#19146586)
Makes sense for embedded.
Re:The memory safety problem isn't bad coders by gowld on Tuesday February 12, 2019 @02:51PM (#19146870)
Any use of templates has the same problem, including templates that are used to generate highly efficient static constants and non-branching-at-runtime code.
Re:The memory safety problem isn't bad coders by llukas on Tuesday February 12, 2019 @03:15PM (#19147083)
Example?

Templates (template metaprogramming) help to avoid exceptions. You can check invariants first and jump into efficient code.

Re:The memory safety problem isn't bad coders by llukas on Tuesday February 12, 2019 @03:16PM (#19147094)
or almost like python:

for (auto &element: s){

even better with structured bindings:

for (auto [key, value]: map){

Re:The memory safety problem isn't bad coders by jcelerier on Tuesday February 12, 2019 @03:33PM (#19147225)
why we can't have nice things, in one comment.

auto is not a code smell on the contrary, it is used when your type system is easy enough to reason about that you don't need to write the actual type.

Re:The memory safety problem isn't bad coders by jschwartzi on Tuesday February 12, 2019 @05:00PM (#19148023)
If it's so easy to reason about, why can't you just state the type of the variable? Doing so helps me understand what's popping out from the rvalue in assignment so that I can follow what your code is doing.

If you're worried about spending time changing type names during a refactor, look at it instead as an opportunity to evaluate the correctness of the code in the context of your replacement type. Use of the auto keyword avoids doing that and as a result enables you to create new and exciting bugs in your code.

Re:The memory safety problem isn't bad coders by jcelerier on Wednesday February 13, 2019 @09:30AM (#19153313)
> If it's so easy to reason about, why can't you just state the type of the variable?

because : - easy to reason about and easy to type are two differents things - naming everything increases mental load

> Use of the auto keyword avoids doing that and as a result enables you to create new and exciting bugs in your code.

to the contrary, porting a lot of my code to use almost-always-auto did actually remove bugs in the form of silent type conversions happening - e.g. std::pair<std::string, int> instead of std::pair<const std::string, int> (yay memory allocations), bad fp conversions...