5 ms·

Sure, with an execution model that is so complex that it takes scientific experimentation to determine the /best/ (in terms of execution speed) to write code to

Sure, with an execution model that is so complex that it takes scientific experimentation to determine the /best/ (in terms of execution speed) to write code to manipulate a simple memory mapped device. (This, from the lecture). That is so complex, it is the only language that I need the language at hand to read someone else's code. Not a library reference, a /language/ reference. Indeed, I am maintaing one C++ application. This is a wrapper for CEF3 (https://cefbuilds.com/ https://cefbuilds.com/). This is the Chromium browser as a library. I have to support the library and wrapper on two platforms: Linux 64 bit and Windows 64 bit. Note that the usual Windows build uses the Microsoft C++ compiler. But, I am uses mingw. This requires source code edits to compile! I blame the complexity of the language. Indeed, C++ is so difficult that the shop I work for (which is, by the nature of our product, very conservative) has gone to Java instead.

pjmlp 10y ago
We did the same in 2006, and are mainly a Java/.NET consulting shop nowadays, but I still use C++ on side projects. Given language difficulty, while I hope never to maintain C++ code that makes use of SFINAE, Java's simplicity is misleading. The language might appear simple, but mastering the whole Java eco-system (JSE, JEE, Spring, embedded, Android, features per JDK version), performance monitoring tools, commercial JDKs and IDEs, isn't that easier either.
- satysin 10y ago
  There is nothing "simple" about Java once you get past the basics. When you get into the EE world it gets extremely complicated.
  - pjmlp 10y ago
    Which is exactly my point. Also the reason I argue that those that think Go will be kept simple, just aren't prepared for the eventual mainstream enterprise adoption. Imagine when IBM or similar, releases their vision of GoEE.
    - satysin 10y ago
      I think Go depends in if Google want to take it from a language that solves their problems well to one that solves generic enterprise problems.
  - qwertyuiop924 10y ago
    No. There's everything simple about Java. The semantics of Java are actually pretty simple, at least compared to C++. What's complicated are the monstrosities people build with Java, but those aren't inherent in the language. Saying that Java is complicated because EE exists is like saying that C is complicated because Linux exists: Complexity can be built atop simplicity. And for some reason, Java is a complexity magnet.
    - MereInterest 10y ago
      I would say that the complexity of a language and the complexity of programs within that language are inversely correlated. Java is a very simple language, but as a result, the programs written in it must be more complicated to make up for the shortcomings of the language. As an example, Java's lifetime rules are much simpler than those of C++. At some point after all references are gone, the object will be garbage collected. Simple. But as a result of this simplicity, you don't know when the finalizer will be called. You can't use it, for example, to flush and close a file, because you don't know when file will be closed. Instead, you need to use try/except/finally, and so you can't add this to an existing class, because it would require code modification from all the users of the class. Up until Java 8 and lambda functions, functions could not be passed as arguments to other functions. Therefore, the developer needed to make an entirely new classes derived from "Callable". Complexity that came from the simplicity of the language. C++ has a lot of complexity in the language itself. I won't deny that. What I will argue is that the complexity of the language enables simplicity in programs. Edit: Lambda statements came in Java 8, not Java 7.
      - qwertyuiop924 10y ago
        No, not really. Complexity is not about the language: It's about how you use it. It's not necessarily Java's featureset that makes it so complex, it's its idioms. C++'s lifetime rules, on most variables, are this: It's allocated until you say it isn't. Some of the vars might be refcounted or GCed, but with GC you've still got the same problem on your hands as finalizers, and refcounting can't handle cycles. Manual memory management is dramatically more error-prone than finalizers ever were (unless you're using RAII, but that's not entirely idiomatic, and cannot be). As for functions not being able to be passed as args, that's not simplicity, that's a straight up limitation. What makes a language simple is uniformity, simplicity, and consistency. Java has a good deal more of all of these than C++ Complexity in the language doesn't enable simplicity in programs, though, because now your program has to deal with 6000 different special cases. In any case, Lisp and Scheme are possibly the simplest languages, and are celebrated for their power, clarity, and the simplicity with which they can express programs.
TickleSteve 10y ago
Platform API differences != language complexity. These are two different things, platform differences are normally handled by a simple abstraction layer (or ifdefs if you're into masochism).

pjmlp 10y ago

We did the same in 2006, and are mainly a Java/.NET consulting shop nowadays, but I still use C++ on side projects. Given language difficulty, while I hope never to maintain C++ code that makes use of SFINAE, Java's simplicity is misleading. The language might appear simple, but mastering the whole Java eco-system (JSE, JEE, Spring, embedded, Android, features per JDK version), performance monitoring tools, commercial JDKs and IDEs, isn't that easier either.

satysin 10y ago
There is nothing "simple" about Java once you get past the basics. When you get into the EE world it gets extremely complicated.
- pjmlp 10y ago
  Which is exactly my point. Also the reason I argue that those that think Go will be kept simple, just aren't prepared for the eventual mainstream enterprise adoption. Imagine when IBM or similar, releases their vision of GoEE.
  - satysin 10y ago
    I think Go depends in if Google want to take it from a language that solves their problems well to one that solves generic enterprise problems.
- qwertyuiop924 10y ago
  No. There's everything simple about Java. The semantics of Java are actually pretty simple, at least compared to C++. What's complicated are the monstrosities people build with Java, but those aren't inherent in the language. Saying that Java is complicated because EE exists is like saying that C is complicated because Linux exists: Complexity can be built atop simplicity. And for some reason, Java is a complexity magnet.
  - MereInterest 10y ago
    I would say that the complexity of a language and the complexity of programs within that language are inversely correlated. Java is a very simple language, but as a result, the programs written in it must be more complicated to make up for the shortcomings of the language. As an example, Java's lifetime rules are much simpler than those of C++. At some point after all references are gone, the object will be garbage collected. Simple. But as a result of this simplicity, you don't know when the finalizer will be called. You can't use it, for example, to flush and close a file, because you don't know when file will be closed. Instead, you need to use try/except/finally, and so you can't add this to an existing class, because it would require code modification from all the users of the class. Up until Java 8 and lambda functions, functions could not be passed as arguments to other functions. Therefore, the developer needed to make an entirely new classes derived from "Callable". Complexity that came from the simplicity of the language. C++ has a lot of complexity in the language itself. I won't deny that. What I will argue is that the complexity of the language enables simplicity in programs. Edit: Lambda statements came in Java 8, not Java 7.
    - qwertyuiop924 10y ago
      No, not really. Complexity is not about the language: It's about how you use it. It's not necessarily Java's featureset that makes it so complex, it's its idioms. C++'s lifetime rules, on most variables, are this: It's allocated until you say it isn't. Some of the vars might be refcounted or GCed, but with GC you've still got the same problem on your hands as finalizers, and refcounting can't handle cycles. Manual memory management is dramatically more error-prone than finalizers ever were (unless you're using RAII, but that's not entirely idiomatic, and cannot be). As for functions not being able to be passed as args, that's not simplicity, that's a straight up limitation. What makes a language simple is uniformity, simplicity, and consistency. Java has a good deal more of all of these than C++ Complexity in the language doesn't enable simplicity in programs, though, because now your program has to deal with 6000 different special cases. In any case, Lisp and Scheme are possibly the simplest languages, and are celebrated for their power, clarity, and the simplicity with which they can express programs.

TickleSteve 10y ago

Platform API differences != language complexity. These are two different things, platform differences are normally handled by a simple abstraction layer (or ifdefs if you're into masochism).