What do you wish was automatic in your favorite programming language?

Question

As a programmer, I often look at some features of the language I'm currently using and think to myself "This is pretty hard to do for a programmer, and could be taken care of automatically by the machine".

One example of such a feature is memory management, which has been automatic for a while in a variety of languages. While memory management is not that hard to do manually most of the time, doing it perfectly all the way through your application without leaking memory is extremely hard. Automation has made it easy again so that we programmers could concentrate on more critical questions.

Are there any features that you think programming languages should automate because the reward/difficulty ratio is just too low (say, for example concurrency)?

This question is intended to be a brainstorm about what the future of programming could be like, and what languages could do for us to let us focus on more important tasks, so please post your wishes even if you don't think automation is practical/feasible. Good answers will point to stuff that is genuinely hard to do in many languages, as opposed to single-language pet-peeves.

Answer 1

Whatever the language can do for me automatically, I will want a way of doing for myself.

Answer 2

Concurrent programming/parallelism that is (semi-)automated, opposed to having to mess around with threads, callbacks, and synchronisation. Being able to parallelise for loops, such as:

Parallel.ForEach(fooList, item =>
{
    item.PerformLongTask();
}

is just made of win.

Certain languages already support such functionality to a degree, however. Notably, F# has asynchronous workflows. Coming with the release of .NET 4.0, the Parallel Extensions library will make concurrency much easier in C# and VB.NET. I believe Python also has some sort of concurrency library, though I personally haven't used it.

What would also be cool is fully automated parallelism in purely functional languages, i.e. not having to change your code even slightly and automatically have it run near optimally across multiple cores. Note that this can only be done with purely functional languages (such as Haskell, but not CAML/F#). Still, constructs such as example given above would be very handy for automating parallelism in object-oriented and other languages.

I would imagine that libraries, design patterns, and even entire programming languages oriented towards simple and high-level support for parallelism will become increasingly widespread in the near future, as desktop computers start to move from 2 cores to 4 and then 8 cores and the advantage of automated concurrency becomes much more evident.

Answer 3

exec("Build a system to keep the customer happy, based on requirements.txt");

Answer 4

In Java I would like a keyword that would make the entire class immutable.

E.g.

public immutable class Xyz {
}

And the compiler would warn me if any conditions of immutability were broken.

Answer 5

In Java, create beans less verbosely.

For example:

bean Student
{
    String name;
    int id;
    type1 property1;
    type2 property2;
}

and this would create a bean private fields, default accessors, toString, hashCode, equals, etc.

Answer 6

Concurrency. That was my main idea when asking this question. This is going to get more and more important with time, since current CPUs already have up to 8 logical cores (4 cores + hyperthreading), and 12 logical cores will appear in a few months. In the future, we are going to have a hell of a lot of cores at our disposal, but most programing languages only make it easy for us to use one at a time.

The Threads + Synchronization model that is exposed by most programming languages is extremely low level, and very close to what the CPU does. To me, the current level of concurrency language support is roughly equivalent to the memory management support in C: Not integrated, but some things can be delegated to the OS (malloc, free).

I wish some language would come up with a suitable abstraction that either makes the Threads + Synchronization model easier, or that simply completely hides it for us (just as automatic memory management make good old malloc/free obsolete in Java).

Some functional languages such as Erlang have a reputation of having good multithreading support, but the brain-switch required to do functional programming doesn't really make the whole ordeal much easier.

Answer 7

.Net:

A warning when manipulating strings with methods such as Replace and not returning the value (new string) to a variable, because if you don't know that a string is immutable this issue will frustrate you.

Answer 8

In C++, type inference for variable declarations, so that I don't need to write

for (vector<some_longwinded_type>::const_iterator i = v.begin(); i != v.end(); ++i) {
    ...
}

Luckily this is coming in C++1x in the form of auto:

for (auto i = v.begin(); i != v.end(); ++i) {
    ...
}

Answer 9

Coffee. I mean the language is call Java - so it should be able to make my coffee! I hate getting up from programming, going to the coffee pot, and finding out someone from marketing has taken the last cup and not made another pot.

Answer 10

Persistence, it seems to me we write far too much code to deal with persistence when this really should be a configuration problem.

Answer 11

In C++, enum-to-string.

In Ada, the language defines the 'image attribute of an enumerated type as a function that returns a string corresponding to the textual representation of an enumeration value.

C++ provides no such clean facility. It takes several lines of very arcane preprocessor macro black magic to get a rough equivalent.

Answer 12

For languages that provide operator overloading, provide automatically generated overloads for symmetric operations when only one operation is defined. For example, if the programmer provides an equality operator but not an inequality operator, the language could easily generate one. In C++, the same could be done for copy constructors and assignment operators.

I think that automatically generating one-side of a symmetric operation would be nice. Of course, I would definitely want to be able to explicitly say don't do that when needed. I guess providing the implementation of both sides with one of them being private and empty could do the job.

Answer 13

Everything that LINQ does. C# has spoiled me and I now find it hard to do anything with collections in any other language. In Python I use list comprehensions a lot, but they are not quite as powerful as LINQ. I haven't found any other language that makes working with collections as easy as in C#.

Answer 14

In Visual Studio environment I want "Remove unused usings" to run across all file in the project. I find it a significant loss of time to have to manually open each individual file and call this operation of a file basis.

Answer 15

From a dynamic languages perspective, I'd like to see better tool support. Steve Yegge has a great post on this. For instance, there are lots of cases where a tool could look inside various code paths and determine if the methods or functions existed and provide the equivalent of the compiler smoke test. Obviously, if you're using lots and lots of truly dynamic code, this won't work, but the fact is, you probably aren't, so it would be pretty nice if Python, for instance, would tell you that .ToLowerCase() wasn't a valid function at compile time, rather than waiting until you hit the else clause.

s = "a Mixed Case String"
if True:
   s = s.lower()
else:
   s = s.ToLowerCase()

Answer 16

Easy: initialize variables in C/C++ just like C# does. It would have saved me multiple sessions of debugging in other people's code.

Of course there would be a keyword when you specifically do not want to init a var.

noinit float myVal; // undefined
float my2ndVal;     // 0.0f