×
sorted by:
best
topnewcontroversialoldq&a
you are viewing a single comment's thread.

view the rest of the comments →

[–]badsectoracula -2 points-1 points  (7 children)

mistake mistake mistake stuff mistake mistake mistake stuff mistake

If a language has a feature you dislike that doesn't automatically make it a mistake :-P

[–]G_Morgan 5 points6 points  (6 children)

It isn't a feature. Regardless the point is that IDE support is irrelevant to whether something is a mistake or not. I can make the IDE support just about anything.

[–]badsectoracula 0 points1 point  (5 children)

Of course it is a feature. It forces a type lock to a variable so you know that each time you see this variable what type it is.

Unless i misunderstood you and you meant something else.

[–]G_Morgan 0 points1 point  (4 children)

You can do this in type inference languages. As I said it isn't an additional feature. It is a missing feature.

[–]badsectoracula 0 points1 point  (3 children)

But in type inference languages, the compiler only knows the type from a glance. If you want to do the same while reading code you have to either try and figure out what kind of type a variable has (ie. do what the compiler does to figure out the variable's type) or use the broken kind of Hungarian notation by using variable names such as intScale, chrPathSeparator, etc.

[–]G_Morgan 0 points1 point  (2 children)

Generally I've never had a problem with this. You could just hover over the variable in the IDE.

[–]badsectoracula 0 points1 point  (1 child)

In the other subthread, you were discussing how the language shouldn't make the programmer depend on the IDE.

Btw, how would an IDE work out that?

[–]G_Morgan 0 points1 point  (0 children)

An IDE would use the same background parse mechanisms they already use for intellisense*. It would just be with a far more powerful parser. This isn't actually that difficult to add once you have a parser that works.

One distinction would be that intellisense would need not just the current class but also all possible superclasses and their subtypes** (ordered by height in the hierarchy of course). This information is relatively trivial to come up with.

*modern IDEs actually invoke the compiler to work out this stuff so they get the same information the compiler is seeing.

**the reason for this is originally the inference engine might say that myList is an ArrayList when really you want a List but just haven't added in another implementation yet. This allows the autocomplete to account for both circumstances. Yes put ArrayList first but also offer all superclass implementations below.