Add to Chrome
Add to Edge
Add to Firefox
Add to Opera
Add to Brave
Add to SafariWhen comparing JavaScript vs Haskell, the Slant community recommends JavaScript for most people. In the question“What is the best programming language to learn first?” JavaScript is ranked 14th while Haskell is ranked 26th. The most important reason people chose JavaScript is:
If you run a web browser you already have JavaScript installed and can get started right away. Modern browsers such as Chrome also have very powerful programming consoles built into them. Aside from the browser console, you can also use online Javascript playgrounds such as JS Bin and JS Fiddle. Even from a tablet.
Specs
Question Ranking
Pros
Pro No installation required
If you run a web browser you already have JavaScript installed and can get started right away. Modern browsers such as Chrome also have very powerful programming consoles built into them.
Aside from the browser console, you can also use online Javascript playgrounds such as JS Bin and JS Fiddle. Even from a tablet.
Pro Required for web development
If you are looking to create web projects, you will have to learn Javascript in order to develop the client side code. If you learn the foundations of programming in JavaScript you can reapply that education later in building web applications.
Pro Massive ecosystem
JavaScript has one of the largest programming ecosystems, as shown by the being the most popular language for projects on GitHub. As there are so many projects written in JavaScript there are lots of libraries available to build off of and many of them are written to be easy to use and integrate into other projects.
There are also lots of resources available for learning JavaScript. Other than traditional tutorials, language learning sites such as Codecademy have JavaScript courses. The Mozilla Developer Database also serves as a great resource for learning about the standard libraries built into JavaScript.
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 Runs on both the browser and the server
With Node.js, it is now possible to run JavaScript as a web server. This would allow you to be able to create server based applications sooner than would if you had to learn a separate programming language as well for server side code.
As JavaScript is the only language supported by web browsers it puts it in the unique situation of being the only programming language that's available on both the client side and server side.
Pro First-class functions with lexical closures
While certainly not the only language with these features, this pro alone is so powerful that it compensates for most of JavaScript's problems. You'll learn to use closures and higher-order functions well in JavaScript, because you have to. And then you can generalize this knowledge to any other language that has these, and the good ones do.
Pro High demand for JavaScript developers
If you're looking for a career as a developer, JavaScript is the place to focus your attention. There is a huge demand for good developers especially in frameworks such as React and Angular.
Pro Complete dev stack can be run online
With codepen.io and other prototyping tools, you can learn Javascript from a mobile device. You don't even need a computer. It can be learned from an internet cafe or public library.
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.
Pro Atwood's Law "Any application that can be written in JavaScript, will eventually be written in JavaScript."
May also be a con.
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 Instant gratification
While it's easy to argue that Python will give you 'instant gratification' (while actually ruining your understanding of good programming practices), JavaScript is far better in this regard. Make a small change to a page and it's immediately visible in the browser. You can throw in a JavaScript library like jQuery with minimal fuss.
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 Prototype based Object Oriented System
Being object oriented, it supports the predominate and powerful programming approach. Being prototype based, it provides an intuitive approach to OOP. Whereas other popular languages use classes, which focus on thinking in the abstract, Javascript's prototypes allow you to focus on thinking in the concrete.
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 C-like syntax
After learning Javascript, you will feel at home in other languages as C-like syntax is very common.
Pro One of the most underestimated languages
deviously simple in syntax, yet highly powerful in paradigms, this language does not force you to the (actually intrinsically broken) object oriented paradigm, has a healthy dose of functional programming inside, and does not bloat the keyword space. Good javascript is all about structure. Bad javascript is all about lazy hipsters not taking the time to learn 'javascript, the good parts', a must read.
Pro Extremely popular
JavaScript usually tops the lists for most popular languages in use today and rightly so. It's used almost everywhere and it's in high demand, making it very easy to find a job for anyone who knows JavaScript. This helps make it desirable for a first language, as it will often be used in the future.
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 Highly transferable concepts
Haskell's referential transparency, consistency, mathematics-oriented culture, and heavy amount of abstraction encourage problem solving at a very high level. The fact that this is all built upon little other than function application means that not only is the thought process, but even concrete solutions are very transferable to any other language. In fact, in Haskell, it's quite common for a solution to simply be written as an interpreter that can then generate code in some other language. Many other languages employ language-specific features, or work around a lack of features with heavy-handed design patterns that discourage abstraction, meaning that a lot of what is learned, and a lot of code that is needed to solve a particular problem just isn't very applicable to any other language's ecosystem.
Pro Forces you to learn pure functional programming
It is pure and does not mix other programming paradigms into the language. This forces you to learn functional programming in its most pure form. You avoid falling back on old habits and learn an entirely new way to program.
Pro Open source
All Haskell implementations are completely free and open source.
Pro Mathematical consistency
As Haskell lends itself exceedingly well to abstraction, and borrows heavily from the culture of pure mathematics, it means that a lot more code conforms to very high-level abstractions. You can expect code from vastly different libraries to follow the same rules, and to be incredibly self-consistent. It's not uncommon to find that a parser library works the same way as a string library, which works the same way as a window manager library. This often means that getting familiar and productive with new libraries is often much easier than in other languages.
Pro Referentially transparent
Haskell's Purely Functional approach means that code is referentially transparent. This means that to read a function, one only needs to know its arguments. Code works the same way that expressions work in Algebra class. There's no need to read the whole source code to determine if there's some subtle reference to some mutable state, and no worries about someone writing a "getter" that also mutates the object it's called on. Functions are all directly testable in the REPL, and there's no need to remember to call methods in a certain order to properly initialize an object. No breakage of encapsulation, and no leaky abstractions.
Pro Hand-writeable concise syntax
Conciseness of Haskell lets us to write the expression on the whiteboard or paper and discuss with others easily. This is a strong benefit to learn FP over other languages.
Pro Very few language constructs
The base language relies primarily on function application, with a very small amount of special-case syntax. Once you know the rules for function application, you know most of the language.
Pro Quick feedback
It's often said that, in Haskell, if it compiles, it works. This short feedback loop can speed up learning process, by making it clear exactly when and where mistakes are made.
Pro Functions curry automatically
Every function that expects more than one arguments is basically a function that returns a partially applied function. This is well-suited to function composition, elegance, and concision.
Pro Easy to read
Haskell is a very terse language, particularly due to its type inference. This means there's nothing to distract from the intent of the code, making it very readable. This is in sharp contrast to languages like Java, where skimming code requires learning which details can be ignored. Haskell's terseness also lends itself to very clear inline examples in textbooks, and makes it a pleasure to read through code even on a cellphone screen.
Pro Popular in teaching
Haskell is really popular in universities and academia as a tool to teach programming. A lot of books for people who don't know programming are written around Haskell. This means that there are a lot of resources for beginners in programming with which to learn Haskell and functional programming concepts.
Pro Easy syntax for people with a STEM degree
Since the basic syntax is very similar to mathematics, Haskell syntax should be easy for people who have taken higher math courses since they would be used to the symbols used in maths.
Pro Powerful categorical abstractions
Makes categorical higher order abstractions easy to use and natural to the language.
Cons
Con Many errors pass silently
JavaScript looks for every possible way to treat the code you write as runnable and is very reluctant to point out likely errors. For example, you have call a function with too many arguments, the extra arguments are simply discarded.
Con Easy to accidentally use globals
If you forget a var or new, you can clobber the global scope. For tiny scripts (JavaScript's original use case) globals are great, but for larger applications globals are generally regarded as a Bad Thing. This is because changes to one small part of a program can randomly break things anywhere else. These kinds of bugs are notoriously hard to find.
Con Does not teach you about data types
Since JavaScript is a weakly typed language, you don't have to learn about data types if you start using JavaScript as your first language. Data types being one of the most important concepts in programming. This will also cause trouble in the long run when you will have to (inevitably) learn and work with a strongly or statically typed language because you will be forced to learn the type system from scratch.
Con Weird type coercions
'5' - 1 == 4, but '5' + 1 == 51. There are other examples that make even less sense.
Con Complex
JavaScript has a long litany of warts and gotchas. JavaScript will bite you if you're just a wee bit careless. You have to exercise a great deal of caution and awareness. You either have to know the entire 545-page ES6 spec to avoid them all, or use a linter to help restrict you from using the bad parts (and you still have to be familiar with the language), but beginners don't know these things. (Linters are also prone to time-wasting false positives.) This is a significant cognitive burden on even the experienced programmer (as if coding wasn’t hard enough already), but try learning to program in the first place on top of all of this and you'll understand that JavaScript is a terrible choice for the beginner.
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 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 The constant churn of tooling and language
Trying to keep up=javascript fatigue. You won't have time to learn anything else if this is your first language, and you will probably think all programmers are crazy. Plus web assembly may open the door for better alternatives.
Con Very confusing to read
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 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 Many tutorials, code, and resources, are structured for older ES5 code
Con Asynchronous coding is not easy for beginners
JavaScript can work synchronously but its current use is mainly around asynchronous instructions, and it's surely not a good way to start learning programming.
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 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 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 Numbers that begin with 0 are assumed octal
This is very surprising for beginners. Especially since 00 through 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 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 The language itself is not very appealing to developers.
JS is one of the most dreaded languages as it was designed for the purpose of becoming just an scripting language for a browser. It was never intended to take over as the leading technology in web development, thus the language has been streched past its own capabilities. A beginer should learn something else first, something that is better conceived and refined.
Con Counter-intuitive type conversion
JavaScript is rather inconsistent when dealing with different types. For example, when working with the + operator and two numbers, they will be added, two strings will be concatenated:
3+5; // 8;
"Hello "+"world"; // "Hello world"When using + 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 Has really bad parts you're better off avoiding altogether
But beginners won't know better. And even after you learn, you might have to deal with others' code that uses the bad stuff. JavaScript was originally developed in 10 days. It just wasn't designed that carefully.
Con Language extensions lead to unfamiliar code
Haskell's language extensions, while making the language incredibly flexible for experienced users, makes a lot of code incredibly unfamiliar for beginners. Some pragmas, like NoMonomorphismRestriction, have effects that seem completely transparent in code, leading beginners to wonder why it's there. Others, like ViewPatterns, and particularly TemplateHaskell, create completely new syntax rules that render code incomprehensible to beginners expecting vanilla function application.
Con Difficult learning curve
Haskell lends itself well to powerful abstractions - the result is that even basic, commonly used libraries, while easy to use, are implemened using a vocabularly that requires a lot of backround in abstract mathematics to understand. Even a concept as simple as "combine A and B" is often, both in code and in tutorials, described in terms of confusing and discouraging terms like "monad", "magma", "monoid", "groupoid", and "ring". This also occasionally bears its ugly head in the form of complicated error messages from type inference.
Con Package manager is unstable & lacking features
Cabal (There are other choices but this is the most popular) can not uninstall a package. Also working at a few locations it is difficult to have the same environment for each one be the same.
Con You have to learn more than just FP
Haskell is not only a functional language but also a lazy, and statically typed one. Not only that but it's almost necessary to learn about monads before you can do anything useful.
Con Symbols everywhere
Haskell allows users to define their own infix operators, even with their own precedence. The result is that some code is filled with foreign looking operators that are assumed to be special-case syntax. Even for programmers who know they're just functions, operators that change infix precedence can potentially break expectations of how an expression is evaluated, if not used with care.
Con Obscure ugly notation
0 = 1
Using "=" like this: <code>
-- Using recursion (with pattern matching)
factorial 0 = 1
factorial n = n * factorial (n - 1) </code> Example from https://en.wikipedia.org/wiki/Haskell_(programming_language)
is quite simply annoying aesthetics.
Con Documentation for most packages is short and lacking
A few Haskell packages are well documented but this is the exception, not the rule.
Most of the time a list of function signatures is what passes for documentation.
Con Too academic, hard to find "real world" code examples
Con You need some time to start seeing results
Haskell's static typing, while helpful when building a project, can be positively frustrating for beginners. Quick feedback for errors means delaying the dopamine hit of code actually running. While in some languages, a beginner's first experience may be their code printing "Hello World" and then crashing, in Haskell, similar code would more likely be met with an incomprehensible type error.
Con Lazily evaluated
Haskell's lazy evaluation implies a level of indirection - you're not passing a value, you're passing a thunk. This is often difficult to grasp not just for beginners, but for experienced programmers coming from strictly evaluated languages. This also means that, since for many, strict evaluation is their first instinct, initial expectations of a function's performance and complexity are often broken.
Con Only pure functional programming
Not proper functional programming but a subset of the style called pure functional programming.
Con Curried type signatures obfuscate what were the in and out types originally
