[samspot]

I noticed a lot of criticism of Java's verbosity in the comments and I'm a bit curious what people are referring to? I work primarily in Java, but also do quite a bit of Javascript and Perl, and I don't notice Java being especially verbose. Maybe internally I'm giving it a break because it isn't a scripting language? I'm honestly curious to see what you guys think.

[orangecat]

The two areas that most frequently annoy me are processing collections and (lack of) first-class functions.

Java:

  List<String> firstNames = new ArrayList<String>();
  for(Person p : people) {
    firstNames.add(p.getFirstName());
  }

  addCallback(new Runnable() {
    public void run() {
      doSomething();
    }
  });

Python:

  first_names = [p.first_name for p in people]

  add_callback(do_something)

Scala:

  val firstNames = people.map((p) => p.firstName);

  addCallback(() => doSomething());
  

The Python and Scala versions do exactly what they say, while the Java code has a bunch of boilerplate that you have to mentally filter out before you can understand what it's doing. And the Scala code is fully typesafe; the compiler infers types rather than making you continually repeat them.

[exelib]

This is, because you can't Java. How you will find out, where you use

   first_names = [p.first_name for p in people]

? More verbose, but right way in Java is like (you can do this better with enums and/or guava, it's just example):

    class PersonTransformer implements Transformer {
        public Object transform(Object o) {
            return ((Person)o).getFirstName();
        }
    }

and then:

    Collection<String> firstNames = CollectionUtils.collect(people, new PersonTransformer());

You can reuse it and, more important, you can search for it. Same for second example.

[rbanffy]

Why would you want to reuse a construction so trivial? Why would you want to search for it?

A couple days back I commented Java, by making some things harder than needed, induces programmers to over-engineer and build things for needs they don't have and to think that's perfectly normal. Think about what you just wrote.

[exelib]

Because it's DRY-Principle. It's doesn't matter trivial or not. If you distribute you 'trivial' constructions over whole application, you doesn't have any chance to have consistent, robust processing. If you collect/group things logically, you can easy find out where you (re)use constructions and what you can break, if you change it.

It's not over-engineering, it's just how to deal with >300 People and >6 years projects and not to have "design dead software".

[rbanffy]

It's just a list comprehension. Do you imply I should use a function instead? Why not use a very nice syntax feature every Python developer can understand?

Because if you do, I'd advise you not to add integers with the "+" operator, but, instead, build a class with various add methods for different types of arguments or, better yet, build add methods into every class you define so that you can better search for them. This approach would allow you to add things that aren't integers or even not the same type on both sides of the operator.

[exelib]

I give up. You're like a little kid. Codesize or verbosity doesn't matter. Quality is a keyword and it resulting in sustainable pace. If you doesn't understand this, nobody can help you. Your arguments are like as "Why I should use TDD, if I can write code directly".

[runT1ME]

Are you really arguing that the 'java' way in your example is superior to Scala's

[beothorn]

orangecat example is type safe, your example trades a "compile time" error for a runtime error.

[exelib]

Python isn't type safe (but Scala). Especially for you I wrote "you can do this better with ... guava, it's just example" :)

[samspot]

Curious enough in fact, to do some research. I found an interesting article: http://www.informit.com/articles/article.aspx?p=1824790

I also forgot about file i/o, which I don't do much of in web applications.