Python vs Haskell

Python's popularity and beginner friendliness has led to a wealth of tutorials and example code on the internet. This means that when beginners have questions, they're very likely to be able to find an answer on their own just by searching. This is an advantage over some languages that are not as popular or covered as in-depth by its users.

Python has an active and helpful community, such as the comp.lang.python Google Groups, StackOverflow, reddit, etc.

On top of the wealth of tutorials and documentation, and the fact that it ships with a sizeable standard library, Python also ships with both an IDE (Integrated Development Environment: A graphical environment for editing running and debugging your code); as well as a text-based live interpreter. Both help users to get started trying out code immediately, and give users immediate feedback that aids learning.

Python ships with a large standard library, including modules for everything from writing graphical applications, running servers, and doing unit testing. This means that beginners won't need to spend time searching for tools and libraries just to get started on their projects.

Python can be used across virtually all domains: scientific, network, games, graphics, animation, web development, machine learning, and data science.

Python's syntax is very clear and readable, making it excellent for beginners. The lack of extra characters like semicolons and curly braces reduces distractions, letting beginners focus on the meaning of the code. Significant whitespace also means that all code is properly and consistently indented.

The language also uses natural english words such as 'and' and 'or', meaning that beginners need to learn fewer obscure symbols. On top of this, Python's dynamic type system means that code isn't cluttered with type information, which would further distract beginners from what the code is doing.

Installs and works on every major operating systems if not already installed by default (Linux, macOS).

Python is commonly used in data science and has many libraries for scientific computing, such as numpy, pandas, matplotlib, etc.

The Python community has put a lot of work into creating excellent documentation filled with plain english describing functionality. Contrast this with other languages, such as Java, where documentation often contains a dry enumeration of the API.

As a random example, consider GUI toolkit documentation - the tkinter documentation reads almost like a blog article, answering questions such as 'How do I...', whereas Java's Swing documentation contains dry descriptions that effectively reiterate the implementation code. On top of this, most functions contain 'Doc Strings', which mean that documentation is often immediately available, without even the need to search the internet.

When learning Computer Science concepts such as algorithms and data structures, many texts use pseudo-code. Having a language such as Python whose syntax is very similar to pseudo-code is an obvious advantage that makes learning easier.

It's very simple for understanding how programming works. If you don't like programming in Python, you probably won't like programming. It is a good way to find out with little investment. If you like, it is a great language. I wouldn't look for a language that has everything you eventually need to know in programming, such as static typing, in my first language. It should be easy to learn. You can pick up the hard stuff later if you tackle C or C++ or assembler. It will make learning them much easier. If you start with them, you might quit programming due to the difficulty of learning.

Python's popularity also means that it's commonly in use in production at many companies - it's even one of the primary languages in use at Google. Furthermore, as a concise scripting language, it's very commonly used for smaller tasks, as an alternative to shell scripts.

Python was also designed to make it easy to interface with other languages such as C, and so it is often used as 'glue code' between components written in other languages.

There are outstanding projects being actively developed in Python. Projects such as the following to name a random four:

• Django: a high-level Python Web framework that encourages rapid development and clean, pragmatic design.
• iPython: a rich architecture for interactive computing with shells, a notebook and which is embeddable as well as wrapping and able to wrap libraries written in other languages.
• Mercurial: a free, distributed source control management tool. It efficiently handles projects of any size and offers an easy and intuitive interface.
• PyPy: a fast, compliant alternative implementation of the Python language (2.7.3 and 3.2.3) with several advantages and distinct features including a Just-in-Time compiler for speed, reduced memory use, sandboxing, micro-threads for massive concurrency, ...

When you move on from being a learner you can still stay with Python for those advanced tasks.

Python supports three 'styles' of programming:

• Procedural programming.
• Object orientated programming.
• Functional programming.

All three styles can be seamlessly interchanged and can be learnt in harmony in Python rather than being forced into one point of view, which is helpful for easing confusion over the debate amongst programmers over which programming paradigm is best, as developers will get the chance to try all of them.

Python's built-in support and syntax for common collections such as lists, dictionaries, and sets, as well as supporting features like list comprehensions, foreach loops, map, filter, and others, makes their use much easier to get into for beginners. Python's support for Object Orient Programming, but with dynamic typing, also makes the topic of Data Structures much more accessible, as it takes the focus off of more tedious aspects, such as type casting and explicitly defined interfaces.

Python's convention of only hiding methods through prefacing them with underscores further takes the focus off of details such as Access Modifiers common in languages such as Java and C++, allowing beginners to focus on the core concepts, without much worry for language specific implementation details.

One of the Guiding Principles of Python is that there should be only one obvious way to do things. This is helpful for beginners because it means that there is likely a best answer for questions about how things should be done.

It is very easy to learn and it has community support and many categories available.

Mobile versions are available but can be difficult to find. Examples for android are pydroid and qpython

Python is not limited to just be cross platform. It goes far beyond all high level languages since it can run on top of several other frameworks & architectures :
Examples of interpreters:

• Standard (PC Win/Lin/Mac, ARM, Raspberry, Smartphones): CPython usually, but some more specialized for smartphones: Kyvi, QPython, ...
• Web Browser JS : Brython, PyJS,
• .Net : IronPython
• Java: Jython
• Microcontrollers with WiFi like ESP8266 or ESP32: MicroPython
• Can be statically compiled (instead of interpreted) with Cython. (Do not mix up with cPython)

With python, you're sure your code can run (almost) everywhere, from 2€ computers to the most expensives.

So, for instance, with Jython you can access the Java libraries with Python language.

Python's syntax supports optional type annotations for use with a third-party static type checker, which can catch a certain class of bugs at compile time. This also makes it easier for beginners to gradually transition to statically typed languages instead of wrestling with the compiler from the start.

It is somewhere between C and Java.

According to Quartz, Python programming skills on average earn $100,000 per year. Closely followed by Java, C++, JavaScript, C, and R with $90,000 per year and above.

(If you can get over whitespace formatting)

Do something visually interesting in minutes by using the turtle standard library package.

Turtle graphics is a popular way for introducing programming to kids. It was part of the original Logo programming language developed by Wally Feurzig and Seymour Papert in 1966.

Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an import turtle, give it the command turtle.forward(15), and it moves (on-screen!) 15 pixels in the direction it is facing, drawing a line as it moves. Give it the command turtle.right(25), and it rotates in-place 25 degrees clockwise.

Turtle can draw intricate shapes using programs that repeat simple moves.

Example Turtle Star Drawing

from turtle import *
color('red', 'yellow')
begin_fill()
while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break
end_fill()
done()

Want to start game development? No problem! Using pygame open-source library you can fast begin creating games without worrying about pointers or undefined behaviors which they exists in C/C++.

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.

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.

All Haskell implementations are completely free and open source.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Makes categorical higher order abstractions easy to use and natural to the language.