When comparing C++ vs Ceylon, the Slant community recommends C++ for most people. In the question“What is the best programming language to learn first?” C++ is ranked 29th while Ceylon is ranked 42nd. The most important reason people chose C++ is:
C++ is a large language with an even larger community and following. It has libraries for every kind of task that is possible to do with C++
Specs
Ranked in these QuestionsQuestion Ranking
Pros
Pro Huge language supports most everything
C++ is a large language with an even larger community and following. It has libraries for every kind of task that is possible to do with C++
Pro Powerful memory management
Allows puting large arrays on the "heap" to avoid "stack overflow".
Pro Teaches fundamental OOP
Teaches you to leverage object oriented programming.
Pro Excellent compiler optimization
Both open source compilers (such as Clang and GCC), and proprietary ones (like Intel's and Microsoft's) are very good at analyzing program flow and program optimization. This is mostly due to the widespread usage of C/C++ applications running everything from mobile/desktop/server Operating Systems, to search engines and webserver software, and the demand for performance.
Pro Teaches problem solving
The great STL is the most powerful Data Structure and Algorithms Library. It would benefit you very much in problem solving, your main main way to love programming. The code is much compact compared to Java and C#. No unnecessary classes are in your way; yet when you need classes they are available unlike C. The code runs very fast.
Pro Teaches low-level programming, but doesn't have as many pitfalls as C
Teaches data types, low-level program flow and the so common C-style syntax while not being as much of a pain as C itself.
Pro STD is often updated
The functionalities keep growing throughout the years. C++11 gave us a soft type of garbage collecting with the smart pointers.
Pro C code can be used in C++ code
Most C code will work as C++.
Pro Faster execution of the same algorithms
Because C++ (and its precursor C) are "lower level" than a lot of popular programming languages they are also faster at executing code than Java or C# which require VMs and garbage collection threads.
Pro Universal, portable, best complexity/efficiency trade-off
Pro Best way to understand algorithms
Pro Has lots of library
C++ is mature and everything has standardized library.
Pro Try it out in the browser
It has a Web IDE: http://try.ceylon-lang.org/ with impressive demos: http://try.ceylon-lang.org/?gist=bd41b47f325b6d32514a so you can try it without installing anything, and see the JS generation / interop in action.
Pro Strong static typing, null safe and flexible, almost dynamic type system
The compiler prevents you from using a potentially null variable, unless you check it is not null. Ie. it forces you to check a potentially null value before using it.
The type system is strict, but flexible, allowing union and intersection of types, covariant and contravariant types, reified types, etc.
Type inference and union types allows a dynamic programming style, close of JS spirit.
Pro Designed from the start to generate JavaScript
It brings type safety to JS, allowing to define interfaces to existing JS APIs, yet using the dynamic
keyword for flexible calls in the JS ecosystem.
Pro Excellent IDE support
Ceylon has reified generics, so it doesn't loose the type of collections at runtime. This makes autocompletion, debugging, etc. first-class. The Eclipse plugin makes it a full-fledged Ceylon IDE, and an IntelliJ IDEA plugin is in the works.
Pro Great tutorial
Gavin King, main author of the language, has a great, clear technical writing style, making understandable difficult concepts like variance or sound type system.
Pro Excellent documentation
The language specification is very complete and up to date; also, the language module is very well documented.
Pro Javascript interoperability
Ceylon has special language-level support for interoperation with dynamically typed languages like JavaScript, and its module system even interoperates with npm.
Pro Easy to learn even if you don't have prior programming experience
Ceylon is indeed fairly easy and readable. Of course those ones who know OOP and a bit of functional programming concepts will feel almost at home right from the start.
Pro Generate HTML
HTML generation is supported right in the SDK.
Pro Same code in backend and frontend
If you don't use platform-specific features, you can reuse the same code in your backend server (be it in Java or JavaScript) and in your client-side browser code, for example for storing data, validating input etc.
Cons
Con Huge language gets in the way of learning
C++ is such an atrociously over-complicated language that its learning curve may get in the way of learning fundamentals. Learning C++ well is a ten-year project, and even experts are frequently surprised by the language.
Con Tough to learn as the first language
Many of the concepts are hard to grasp if you have no prior programming experience.
Con Undefined behavior
Subtle errors can render the entire program "undefined" by the complicated C++ standard. The standard imposes no requirements in such cases. Thus C++ compiler writers are free to ignore the existence of such cases and Bad Things are prone to happen instead. Even experts can't reliably avoid undefined cases in C++, so how can beginners be expected to do so?
Con Module system is not great
C++ uses the #include
mechanism provided by C. Which unfortunately is a poor way of accessing the API of a library. Some of the reasons why the module system is weak are:
Compile time scalability: The compiler must preprocess every header included in a file, and every header included in those headers. This process must be repeated for every translation unit in the program. As can be imagined, this doesn't scale very well. For each header added you are increasing the compilation time exponentially.
Fragile: modules included are treated as textual imports by the compiler. This causes all sorts of problems since they are subject to any macro definitions in the time of the inclusion. If any of these macro definitions collide with a name in the library it can break the library API .
Con C++ succombs under its own weight
The years of cramped backward compatibility start to show in the syntax, complexity and very top-heavy language structures. Trying to keep up with far more elegant languages like C# doesn't do C++ any good either, because the committee always seems to be able to mess it up. After numerous years, still no modules... you must be kidding!
Con Painfully slow compilation
Beginners need fast feedback
Con Duplicates C features in incompatible ways
Arrays, strings, pointers, etc. have both C and C++ versions. Sometimes the C++ versions are worse. This is more useless trivia beginners have to sort through.
Con Undefined behaviors and weak limited type safety
Undefined behavior in a program can cause unexpected results, making it hard to debug. With UB, program behavior may vary wildly depending on optimization settings. There are many cases that invoke UB, such as signed overflow, invalid dereferences, large integer shifts, uninitialized variables, etc. C++ allows for non-type safe operations such as logic errors, wild pointers, buffer overflow, etc. UB and type safety issues create a large number of bugs and security vulnerabilities.
Con No two programmers can agree on which 10% subset of C++ to use
C++ is such a huge and complicated language, that programmers have to learn a disciplined subset of it to reliably get anything done. The problem is, no-one can agree on which subset to use and they can't understand each other.
Con Retains nearly all bad habits of C
Con No reflection
C++ objects are frustratingly opaque. This makes debugging especially difficult, something beginners have to do a lot.
Con Memory leaks and segmentation faults
Because C and C++ allow the user direct access to memory and don't provide garbage collection threads, there is a probability that a program may have a "memory leak", which occurs when something a programmer allocated in the heap is not deallocated properly. Also, attempting to dereference memory protected by the operating system causes a segmentation fault and kills the program.
Con Arcane binding rules
Con Incomprehensible operator overloading resoution
Con After all these years of trying, still no decent string library.
Although you have several ways to handle strings, all of them are messy and error-prone, giving birth to many crashes and memory corruptions in the field. It's one of the worst languages ever, if you have to do strings.
Con Bugs easily corrupt the memory you need to find them
You can usually get a core dump, but often the call stack gets completely overwritten. Compilers are not even consistent in how they map the binary objects to code.
Con No way to locate definitions
No modules, just files, and no way to tell where anything came from.
Con Complicated types
Con Standard library missing important features
Con Exceptions incompatible with C++ manual memory management
Con Lack of physical or electronic books
We should hope Red Hat or anyone interested would take the time and write one. That would strengthen the maturity of the language, but Ceylon is rapidly developing which can make the author's efforts futile because his or hers work will become obsolete soon.
The second hindrance is, of course, popularity of the language which can't give much to the pockets of the author (however, Dart's unpopularity at start didn't prevent it to have a lot of printed material, but that's Google's child, we know).
Con Currently has large runtime
Ceylon 1.2 needs a language runtime of 1.55 MiB, and the Collection library adds another 370 KiB. That's a lot for the Web...
Now, this has to be put in perspective: if you use Ceylon to make a web application, these files will be loaded once, then cached by the browser (that's not casual browsing).
Moreover, most servers compress such resource, and the numbers become respectively 234 KiB and 54 KiB, which is more reasonable...