Ranked in these QuestionsQuestion Ranking
Pro No installation required
Pro Required for web development
Pro Runs on both the browser and the server
Pro Instant gratification
Pro First-class functions with lexical closures
Pro Massive ecosystem
Pro Easy to build an application
By using the UI capabilities in HTML and CSS you can develop substantial applications with graphical interfaces more quickly and with less effort than in other languages which would require you to learn a windowing library.
Building a useful application is one of the best ways to learn a new language and because of the low learning curve for creating applications you can create more substatial programs and learn more practical programming priciple faster.
Pro C-like syntax
Pro Complete dev stack can be run online
Pro JSON is native to JS
JSON is arguably a "must-learn". With JS, that's one less additional syntax to learn.
Pro Very good debugger
Has a built in debugger with break points, watches that work on local values, and a console that you can use to edit anything at any time. Both in the browser (eg: Chrome), and server (eg: Nodejs).
Pro Can be very simple (teachable)
By setting a few ground-rules (effectively coding in a subset of JS), JS is one of the simplest languages to learn (requiring very few must-learn prerequisite concepts).
Pro Great tools for development
Flow, JSHint/ESLint, Babel, npm, etc.
Pro Several Platforms to use the web stack and JS to create multi-platform apps
Opens the door to native application development as well as just websites. Use with React Native, Weex or Quasar (Vue), PhoneGap or Cordova, NativeScript... (etc) to build native apps. Use mostly the same code base for multi-platform and web.
May also be a con.
Pro Prototype based Object Oriented System
For example, in a prototypical language, you think of a rectangle, and define it. You now have a rectangle. Let's say you want a red rectangle, you copy the rectangle and give it the property red. Want a blue one? Copy rectangle again give it a blue. Big blue rectangle? Copy blue rectangle and make it big. In a class-based language, first you describe a rectangle, describe a red rectangle as a type of rectangle, describe blue and big blue rectangles, and now that you have described them, you must create instances of them, and only then do you have the rectangles. Essentially: Classes are factories for objects, prototypes are objects themselves, and the latter method was created to be more intuitive, which is particularly advantageous to beginners.
Pro Modern ESNext is far better than the JS of days past
Modern JS has made great strides, and can be targerted to older (or non-standard) browsers using Babel. There are new language constructs that can make programming in JS comfortable.; e.g.: async / await ( <3 ).
Pro Speed (most implementations)
JS/ES is in the running for the fastest interpreted language given the optimizations and JIT integration of popular implementations. On the other hand, it fails utterly when compared with compiled (to native or VM code) languages.
Pro Integrates very well with UE4
Coding an immersive 3D game can retain the attention of new programmers. ncsoft/Unreal.js.
Pro Extremely popular
Pro The most used language in the whole Solar System in amount of scripts/applications
Because it runs in many different environments, it is the most used language in the world.
Pro Understanding of basics
Because of the verbosity and easy syntax, Pascal language is relatively easier to be learned and understood, even for someone who has no programming knowledge. It's said that Pascal code —if written well— is like reading pseudo code.
Pascal / Object pascal was used in schools during the 2000's to teach kids the basics of object oriented programming.
Pro Clear syntax
Pascal's syntax is clear and concise, for example:
procedure test(); begin DoSomething(); end;
Pro Cross platform
Pro Fast compilation
The compiler is fast, really fast. Compared to C/C++, the delphi compiler is designed to compile a decent sized desktop application in seconds rather than minutes.
Pro Enforces good programming practice
Numerous strong compile time checks with optional runtime checks ensure one doesn't do stupid things and even when one does (because the compiler can't prove it at compile time), the binary will check and report it at runtime.
Correct modular programming implementation with proper namespacing, no file inclusion hack.
Using the Free Pascal Compiler (the main Pascal distribution) you can code in a language that can be procedural and imperative now, but it can became object-oriented simply adding a directive at the start of the source
Pro Easy GUI creation
Visual Basic may have predated Delphi but Delphi was the ground breaking visual designer which set the standards expected today by most GUI developers. Its rich component set was well designed, structured and extensible, it even has the ability to display live data from the attached database in its data controls.
Pro Tons of academic reading
Being known as the programming language for education, especially in the 90's, there many academic reading and tutorials available on the internet.
Pro Assembler Code and DLL/SO creation
You can put Assembler code in Intel or AT&T formats, to achieve great results of speed and accuracy. It is possible to create Dynamic Link Libraries or their equivalent in Unix-like systems so it's relatively easy to use and powerful.
Pro Rich existing libraries
Both shipped with implementations and spread all over the web. Both natively written or bindings to libraries written in other languages. Typically to build non-trivial applications there's no need to surf the web as many things are implemented already. Streaming, output templating, socket & networking, web, database, image manipulation, high performance graphics, (de)compression, (de|en)cryption, regex, unit testing, json manipulation, google API, indexing, multithreading, external process management, the list just goes on and on!
Pro Well balanced for desktop development
For desktop development, Delphi is productive, the code is easy to understand, compilation speed is blazing, and it produces well performing applications that are easy to deploy. The perfect balance between C# and C++.
Pro Automatic Memory Management
The new Delphi compilers are powered by Automatic Reference Counting to ease development.
Pro Still active
From the early roots of Pascal, Delphi has been developed and is still actively supported. It is used in many desktop applications today, and even supports multi platform coding.
Pro Fast execution
The compiler generates fast and optimized code. No stop-the-universe garbage collection.
Pro Extensive third party libraries
There are large collections of third party components, many free which enable developers to add wide ranging and complex functionality to their code with ease
Pro Language depth
Object Pascal is being used to write custom kernels (Ultibo) and operating-systems for various ARM boards. So the way you work with the code scales from low-level to pure OOP high-level. Object Pascal has the same level of depth that you find in C/C++ but with added productivity.
Pro Suitably close to modern languages, without the pitfalls
It was developed as a teaching language and it shows. No syntax pitfalls and gently encourages good style.
Pro Reliable language and code base
Most code from the Turbo Pascal days in the 80s still compiles, yet the language has since been adapted and extended with modern concepts, introducing OOP and interfaces, exception handling, native Unicode support, anonymous methods, generics, ARC and more.
Pro Dynamic evolution of language.
Pro Component based (reusability, decoupled, rich design architecture)
Pro Excellent Database development
Con Many errors pass silently
Con Easy to accidentally use globals
If you forget a
Con Weird type coercions
'5' - 1 == 4, but
'5' + 1 == 51. There are other examples that make even less sense.
Con Does not teach you about data types
Con The "this" keyword doesn't mean what you think it means
this is bound to whatever object called the function. Unless you invoke it as a method. Unless you invoke it as a constructor. Unless it's an arrow function.
Con Each browser has its own quirks when executing the same code in some cases
Beginner programmers often make the mistake of coding something, seeing it works in the browser they tested it in, and then scratching their heads when it doesn't work in another browser. Ideally you'd want a language that works consistently across all platforms in order to be able to focus more on the programming and less on the underlying environment. It just takes time away from learning and forces you to spend time figuring out why this worked in browser X but not browser Y.
Con Asynchronous coding is not easy for beginners
Con Array-like objects
Many cases when you should get an Array, you just get an Array-like object instead and none of the Array methods work on it.
Con Limited standard library
Much often needed functionality is not in the standard library. (Contrast with Python.) However, there are well established libraries such as Lodash, to fill the gap (however, due to the diverse/fractured ecosystem it may not be clear what library to use).
Con The `null` and `undefined` objects aren't really objects
Therefore, attempts to call methods on them will fail. This is especially frustrating since these are often returned instead of throwing exceptions. So a failure may appear far away from the actual cause, which makes bugs very hard to find.
Con Numbers that begin with 0 are assumed octal
This is very surprising for beginners. Especially since
07 seem to work just fine. And this isn't just for hardcoded numbers. The
parseInt() function has the same problem, but only on some systems.
Con Fast moving
The language and the web platform move fast these days. this makes it difficult for students as there is a lot of fragmentation and outdated information.
Con Many tutorials, code, and resources, are structured for older ES5 code
Con The constant churn of tooling and language
Con Easy to fall into bad manners and bad mind structure
It wouldn't consolidate a good mind structure for moving to other languages. Too open.
Con Good tools are pretty much a MUST for new programmers
You really want to be using a good editor (light IDE) and a linter, type checker (e.g.:Flow), etc. until you grok the language. And choosing / setting-up that development environment is it's own learning curve. If taught in a classroom, using a subset of JS with solid tools, there is an argument that JS could be an ideal first language... however, that is a lot of ceremony to protect the new programmer from JS gotchas. But without the tools, JS can be a very painful painful first language (trying to figure out why your code isn't doing what you intended).
Con Has really bad parts you're better off avoiding altogether
Con Counter-intuitive type conversion
3+5; // 8; "Hello "+"world"; // "Hello world"
+ with a string and a non-string operand, the non-string operand is converted to a string and the result is concatenated:
"the answer is "+42; // "the answer is 42" "this is "+true; // "this is true"
In any other case (except for Date) the operands are converted to numbers and the results are added:
1+true; // = 1+1 = 2; null+false; // = 0+0 = 0;
Con Fractured ecosystem
Angular, React, Ember, Meteor, Backbone, Knockout, Express, Mithril, Aurelia. The web frameworks pass in and out of fashion too quickly to keep up with. The endless civil wars are becoming tiresome.
Con Niche language
Most use of this language will be found in jobs supporting legacy code. It will be hard to find things to do with this language outside of that niche.
Con No up-to-date version of language standards
In 1983, and update in 1990, the language was standardized with two standards: ISO/IEC 7185:1990 Pascal and ISO/IEC 10206:1990 Extended Pascal. However, Object Pascal extensions to the language have no official standards but in 1993, a draft proposal for object oriented Pascal standard was re; for review purposes only. There are no standards for modern features and enhancements, thus various Pascal dialects like Delphi or HP Pascal has their own enhancements and features.