Python vs CoffeeScript

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++.

With CoffeeScript, there's never really a question of what is going on. If you're worried that something went wrong in the compilation process, the output is very human readable and mostly 1 to 1 with the CoffeeScript code, making debugging easier as the code that is being executed by the interpreter can be double checked.

CoffeeScript is the most popular of the compile to Javascript languages, so long term support is much less of a worry than with others.

It also means there are many plugins and tools for integrating it into many different build systems, giving it it nearly universal support.

Javascript is a very verbose language so CoffeeScript's goal is to lighten it to make it less tedious.

Various design choices are built around making CoffeeScript more terse with things like optional parenthesis in function calls, cleaner function declarations, no curly braces, and significant white space. Because Javascript can get pretty deeply nested at times, having a lightweight syntax helps with readability.

The result is a language with a minimalistic syntax with lots of syntax sugar.

The golden rule of CoffeeScript is: "It's just JavaScript". The code compiles one-to-one into the equivalent JS, and there is no interpretation at runtime. You can use any existing JavaScript library seamlessly from CoffeeScript (and vice-versa). The compiled output is readable and pretty-printed, passes through JavaScript Lint without warnings, will work in every JavaScript runtime, and tends to run as fast or faster than the equivalent handwritten JavaScript.

CoffeeScript adds syntax that is not only more terse than javascript, smoothing over the rough edges, but also enforces a more human readable syntax to the point where a non-programmer can understand some logic.

Many programmers that are not use to coffeescripts syntax will find it foreign if they don't read the single page API, but generally it is quick to understand and although self documenting code is a myth coffeescript is definitely very close.

if hungry then eat food for food in fridge when food isnt poison and it isnt bedtime

Seems a lot more concise and comprehensible to many programmers and most others than the alternative syntax:

var food, i, len;

if (hungry) {
  for (i = 0, len = fridge.length; i < len; i++) {
    food = fridge[i];
    if (food !== poison && it !== bedtime) {
      eat(food);
    }
  }
}

Passing functions as callbacks is central to how Javascript is written, but the default syntax for functions is very verbose and hard to read. Various CoffeeScript syntax decisions help with ease of writing and reading functions.

The most obvious change is that the function keyword is changed from function to ->. Writing out the word function is very clunky especially when you need to use multiple nested functions.

One of the more opinionated choices of CoffeeScript is the use of significant whitespace, and optional parens around function arguments. While this can be used poorly, it can also be used to great effect with nested functions. For example, a function that takes an object that defines anonymous functions will end in a mess of parens and curly braces:

asyncAction({
  success: function(data){ /* handle data */ },
  error: function(error){ /* handle errors */ }
});

In CoffeeScript you could rewrite this as:

asyncAction
  success: (data) -> /* handle data */
  fail: (error) -> /* handle errors */

Other helpful features are automatic returning of the last statement to make short anonymous functions easier so (a, b) -> a+b would replace function (a, b) { return a+b; }, as well as binding functions to the current context object with =>.

Because Javascript functions can take variable amounts of parameters, it is helpful to be able to use splats to extract an array of arguments in a function.

For example, if you have a function like: (a, b, rest...) ->any amount of parameters sent to the function after a, b will be stored in an array in the variable rest. You can also put splats at the start or middle of the arguments list, such as (a, middle..., b) ->.

When calling a function you can use a splat to apply an array as arguments as well.

Even for loops and if statements. For example, to get mapped array, you don't have to use any Array methods, just the language features:
food = ( stuff for stuff in fridge when stuff.isEatable() )

CoffeeScript was created by a Ruby programmer and a number of syntax features are modelled on Ruby equivalents, so will be familiar to Ruby programmers. For example, implicit returns, i.e. the last variable of each function is implicitly returned, so "return" keyword need not be present.

Skip the documentation build, just write documentation with literate CoffeeScript.

CoffeeScript has a literate mode which let's you use markdown (used by almost everything, such as reddit, github, stack exchange, etc) with code indented how you would normally in markdown and simply enables you to run the code.

This enables you to quickly write FORMATTED, custom documentation that's easily displayed with no build step for the documentation.

With source maps, you can get the proper location of where an error occurred directly in precompiled code, making it easier to debug without the tedious step of translating the compiled code back to the original code in your head.

Having indention-based code blocks is particularly helpful in JavaScript because of its functional callback based nature. In JavaScript you find yourself writing functions within object and passing functions to functions. You can find statements ending with a confusing melange of braces like )}})}). With significant whitespace, most of the needs for braces go away.

Easy to read and easy to work with structures like list.