How would you change your favorite programming language to make it better? (blog.fogus.me)

It's a good question. I wish I had a favorite programming language, though. I think if you spend more than ten years in the business and you still are in love with a particular tool, you probably haven't really done anything big, or you haven't ever looked around to see how other people do things.

JavaScript is probably the language I hate the least. And I'd make some of the CoffeeScript syntax standard, and maybe bring in some concepts to keep spaghetti callbacks under control.

    > And I'd make some of the CoffeeScript syntax standard,
    >  and maybe bring in some concepts to keep spaghetti
    > callbacks under control.

I'd take python and add optional variable declaration and flexible explicit typing constraints (a variable can be declared as either having certain methods returning a certain type, or as being of a set of types, or as being of any type, but all type declarations are optional) that are verified at compile time.

Java isn't my favorite language, but since I use it fairly often I would love to have functions be first class.

  Closeable dbConnection;
  try {
    dbConnection = CloseableFactory.getConnection();
    doWork(dbConnection);
  } catch (CloseableException ex) {
    // log it or whatever
  } finally {
    // the really annoying, stupid, crufty boilerplate bullshit
    try { 
      if (dbConnection != null) 
        dbConnection.close();
    } catch (CloseableException ex) {
      // it's probably already closed
    }
  }

  with (Closeable dbConn = CloseableFactory.getConnection()) {
    doWork(dbConn);
  }

  throw "x does not equal zero"

   catch( e ) { 
    if( e == "x equals zero" ) { return( e + " handled
    locally." ) } 

    try { 
      // Maybe throws IOException
    } catch (e : IOException) {
      // Handle it
    }

Python. Faster.

I ask this question as well. I work mostly with PHP developers and it's telling most of them don't have an answer or only say "consistent function argument order".

If you claim to have 7+ years using a language, surely there's a list of things you could add to make it better.

I think it's standard in the PHP ecosystem though.

    list($firstElement) = $this->method();
    array_map(array($this, 'doSomething'), $array);

I recall being asked a variation: Given your two strongest languages, which features from each one do you miss when programming in the other, and why?

I find it interesting to that the question "Which features do you miss when using a language?" is not equivalent to "Which features would you add to the language?" The former feels like it speaks to my vision of my personal style, while the latter can be construed to include all of the pragmatic concerns of adoption, such as features alleged to assist large teams of indifferent programmers or features that would break backwards compatibility.

Haskell could really need a better record syntax. I really don't know how that should be designed though...

JavaScript.

Kill the "new" operator. Make prototypes less magical (i.e. use something like `Object.create` to construct).

Secondarily, kill getters and setters. (That includes `Array#length`.) I want code and data, not code, data, and code which pretends it's data.

I don't mind the JavaScript syntax much (`function () {` isn't that difficult to type or scan through after you've dealt with it for a while). I'm fine with the small core object and function set. I'm fine with the DOM (except the getters/setters part). I'm okay with `Object.prototype.hasOwnProperty.call`; that can be swept away into a function. Just don't make me write code which looks like statically-typed classical OO spaghetti. I want dynamic prototypal functional spaghetti. =]

    var enemy = new Enemy(enemyList);
    enemyList.push(enemy);

    // Now enemy is inside of enemyList,
    // but it's not enforced.  I find this
    // method prone to mistakes.

    var enemy = new Enemy(enemyList);

    // Now enemy is inside of enemyList;
    // I wouldn't expect that postcondition!

    var enemy = enemyList.createEnemy();
    // or
    var enemy = createEnemy(enemyList);

    // Now enemy is inside of emptyList

    var enemy = Object.create(Enemy.prototype, {
        enemyList: { value: this } // Ugh!
    });
    this.push(enemy);
    Enemy.call(enemy); // Necessary evil if you use standard JS "classes"
    return enemy;

    var enemy = enemyProto { enemyList: this }; // Basically binds the object literal with the enemyProto prototype, returning the modified object.
    this.push(enemy);
    // enemy ctor logic here; e.g. Enemy.call(enemy) as above
    return enemy;

I will take on the challenge of Lisp then.

First it needs to have a much bigger standard library, much like Java.

Second it needs a really effective foreign function interface possibly one which allows direct call to C++. This enables the programmer to take advantage of all the libraries written in C or C++ without having to write C or C++. In particular it allows using wxWidgets, gtk, qt and native win32/64.

Finally I would fix the output of the compiler (having an image is nice, combining it with the compiler to produce an executable makes sense) since (at least for SBCL) the output is 50mb for Hello World (granted, it doesn't grow much after that).

My favorites were C, Postscript, NewtonScript, and Objective-C. Objective-C improved C. A compiled F-Script with some way to drop back down to C would be great. NewtonScript needs a new implementation and a switch from the Pascal-like syntax.

C# is pretty nice though perhaps not my favourite language. One thing I found nuts about it is that you need to check whether anything is subscribed to an event before raising it. If you raise an event that nothing currently cares about, you get a NullReferenceException!

So if a tree falls in the forest with no one around then the universe implodes.

  static tuple SomeMethod(){
    return new tuple { SomeNumber = 1, SomeString = "hello" };
  }

  static void Main(){
    var t = SomeMethod();

    Console.WriteLine(t.SomeNumber + " "+t.SomeString);
  }

If I could make one change to one language I currently use a lot, it would be to add implicit returns to javascript functions.

Intellisense.

Not a huge fan of C# but that part is awesome.

Today, development means more and more work with external APIs, Open Source projects, and general code written by others. A huge time waster is coming back to a piece of code, and finding this: `foo(bar, true, false, true)`. Now you need to go and check the documentation of whatever you're using. IDE solve this half way with auto-complete. We sometimes use ENUMS for the boolean flags, and write yelling code `foo(bar, YES, TOTALLY, DX9_D3D_HWIN_OK_BOOL_FLAG)`. (I hate your guts DirectX). But a verbose code with argument names makes it really easy to create DSLs. Ruby wins over Python here.

`some_function arg1: val1 arg2: val2` with parentheses just to solve ambiguity.

On another note, I always did not understand why there's no For..Else construct, but then I met python.

I'd combine certain ruby-isms into python, but retain pythons speed and readability. Specifically I would default dicts to return nil unless typed as strict dicts (opposite of current practice). I think the way kwargs are handled is cool and would move into Ruby. I like detatched functions way more in Python. I prefer the consistency in pass by ref vs pass by value in python, whereas in Ruby I'm never 100% sure. I like how both languages can communicate with C very easily.

Edit:

In python 0 should not equal False and 1 should not equal True. This has hit me a couple times and it is really annoying. Furthermore, 0 should be cast to True, as in Ruby. Only None and False should be cast to false.

I use Smalltalk so this never comes up. http://redline.st

For the sake of argument (let ((my-favorite-programming-language (find-language "common-lisp")))):

I would like to see Lisp and *nix have babies. Take the best ideas of both and make something greater than their sum.

Anonymous functions in C, in heap not on the stack.

GCC can do it, but it puts them on the stack which is limiting.

Ruby: proper namespacing, ala Python

Python: blocks, ala Ruby

JavaScript: Strong (but dynamic) typing, ala Python & Ruby

edit: formatting

Better blocks in Python

I would add coffeescript-style instance variable setting to ruby method definitions like so:

  def initialize(foo, bar, baz)

    @foo=foo

    @bar=bar

    @baz=baz

  end

Would now be:

  def initialize(@foo, @bar, @baz)

  end

This would save hundreds of lines of code in large programs-- lines which could no longer be a source of typos or errors.

Oh, also I'd make binding_of_caller work.

  {@kbar, fu: @bar, blitz: [@first, @rest...]} = someHash

Unless I'm talking about Erlang, my answer is almost going to be "I really miss Erlang's pattern matching". (I know it's not exclusive to Erlang, but that's where I learned it).

My dream language right now would be something with the expressiveness of Ruby and the concurrency abilities and pattern matching from Erlang.

Hmm. I think I need to go look at where Reia (http://reia-lang.org/) has got to since I last looked at it.

Not quite favourite, and not a language change, but in C, C#, Java, I would change the IMO ridiculous idea to write CONSTANTS in uppercase.

I understand that preprocessor macros have to stand out because they have different semantics (arguments might be evaluated multiple times, use of ## to fabricate tokens, etc), but i do not think

- In C, macro names are by convention uppercase

- in C, one used to use macros to define constants

- hence, in each C-inspired language, constant names must, by convention be uppercase

is a valid syllogism.

Adopting Ruby-style code formatting as a common idiom for Scala and Java, where I'd eliminate the usage of curly braces and instead use indentation for code blocks.

Python: Generic functions and real lambdas.

SBCL: tree shaker for creating executables.