When people create a new programming language, they do so because they want to keep the good features of old languages and fix the bad ones.<\/p>\n
In this sense, Guido van Rossum created Python in the late 1980s to improve ABC. The latter was too perfect<\/a> for a programming language \u2014 while its rigidity made it easy to teach, it was hard to use in real life.<\/p>\n In contrast, Python is quite pragmatic. You can see this in the Zen of Python<\/em><\/a>, which reflects the intention that the creators have:<\/p>\n Beautiful is better than ugly. Python still kept the good features of ABC: Readability, simplicity, and beginner-friendliness for example. But Python is far more robust and adapted to real life than ABC ever was.<\/p>\n In the same sense, the creators of Julia want to keep the good parts of other languages and ditch the bad ones. But Julia is a lot more ambitious: instead of replacing one language, it wants to beat them all.<\/p>\n This is how Julia\u2019s creators articulate it<\/a>:<\/p>\n We are greedy: we want more. Julia wants to blend all upsides that currently exist, and not trade them off for the downsides in other languages. And even though Julia is a young language, it has already achieved a lot of the goals that the creators set.<\/p>\n Julia can be used for everything from simple machine learning applications to enormous supercomputer simulations. To some extent, Python can do this, too \u2014 but Python somehow grew into the job.<\/p>\n In contrast, Julia was built precisely for this stuff<\/a>. From the bottom up.<\/p>\n Julia\u2019s creators wanted to make a language that is as fast as C \u2014 but what they created is even faster<\/a>. Even though Python has become easier to speed up in recent years, its performance is still a far cry from what Julia can do.<\/p>\n In 2017, Julia even joined the Petaflop Club<\/a> \u2014 the small club of languages who can exceed speeds of one petaflop per second at peak performance. Apart from Julia, only C, C++ and Fortran are in the club right now<\/a>.<\/p>\n With its more than 30 years of age, Python has an enormous and supportive community. There is hardly a Python-related question that you can\u2019t get answered within one Google search.<\/p>\n In contrast, the Julia community is pretty tiny. While this means that you might need to dig a bit further to find an answer, you might link up with the same people again and again. And this can turn into programmer-relationships that are beyond value.<\/p>\n You don\u2019t even need to know a single Julia-command to code in Julia. Not only can you use Python and C to code within Julia, you can even use Julia within Python<\/a>!<\/p>\n Needless to say, this makes it extremely easy to patch up the weaknesses of your Python code. Or to stay productive while you\u2019re still getting to know Julia.<\/p>\n This is one of the strongest points of Python \u2014 its zillion well-maintained libraries. Julia doesn\u2019t have many libraries, and users have complained that they\u2019re not amazingly maintained (yet).<\/p>\n But when you consider that Julia is a very young language with a limited amount of resources, the number of libraries that they already have is pretty impressive. Apart from the fact that Julia\u2019s amount of libraries is growing, it can also interface with libraries from C and Fortran to handle plots, for example.<\/p>\n Python is 100% dynamically typed. This means that the program decides at runtime whether a variable is a float or an integer, for example.<\/p>\n While this is extremely beginner-friendly, it also introduces a whole host of possible bugs. This means that you need to test Python code in all possible scenarios \u2014 which is quite a dumb task that takes a lot of time.<\/p>\n Since the Julia-creators also wanted it to be easy to learn, Julia fully supports dynamical typing. But in contrast to Python, you can introduce static types if you like \u2014 in the way they are present in C or Fortran, for example.<\/p>\n This can save you a ton of time: Instead of finding excuses for not testing your code<\/a>, you can specify the type wherever it makes sense.<\/p>\n\n
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren\u2019t special enough to break the rules.
Although practicality beats purity.
[\u2026]<\/p>\n<\/blockquote>\n\n
We want a language that\u2019s open source, with a liberal license. We want the speed of C with the dynamism of Ruby. We want a language that\u2019s homoiconic, with true macros like Lisp, but with obvious, familiar mathematical notation like Matlab. We want something as usable for general programming as Python, as easy for statistics as R, as natural for string processing as Perl, as powerful for linear algebra as Matlab, as good at gluing programs together as the shell. Something that is dirt simple to learn, yet keeps the most serious hackers happy. We want it interactive and we want it compiled.<\/p>\n<\/blockquote>\nWhat Julia developers are loving<\/h2>\n
Versatility<\/h3>\n
Speed<\/h3>\n
Community<\/h3>\n
Code conversion<\/h3>\n
Libraries<\/h3>\n
Dynamic and static types<\/h3>\n
The data: Invest in things while they\u2019re small<\/h2>\n
![\"The](\"https:\/\/cdn0.tnwcdn.com\/wp-content\/blogs.dir\/1\/files\/2021\/07\/The-number-of-questions-tagged-Julia-left-and-Python-right-on-StackOverflow.jpg\")