1.1 Welcome to the Julian World
When you consider the vast sea of programming languages, learning yet one more can feel like an overwhelming task. Learning new programming schemes and constructs requires time, patience, and dedicated efforts, so there should be really strong reasons to invest in such a time-consuming activity. Julia is a programming language that provides such reasons. Since there are so many established programming languages, including Python, C, C++, Java, R, and MATLAB, you need to be really motivated to invest time in learning this new language, Julia. By the end of this chapter, I hope that you will see there are more than enough reasons to dive into Julian world.
Julia is touted to be the one programming language that meets all needs because it removes the requirement of knowing multiple languages. Most programming languages were designed to meet the needs at the time of their creation. For example, C was designed to be an efficient procedural programming language. C++ was developed to add object-oriented programming features to the already efficient and popular C language. Java also added new features to the area of objects. MATLAB was invented to ease the burden of coding efforts required to define a mathematical problem. Python grew with a similar philosophy, but ventured into areas where MATLAB was inefficient. Since the two languages were similar in structure, a lot of MATLAB coders shifted to Python without much effort. It was open source and modular as well, which added to the ease of using others code. However, one of the main problems with this kind of development in computer science was that each programming language was only good in specific areas. As a result, users needed multiple programming languages for different tasks and then they needed to tweak them as required to make a needed software. Some programming languages like C and C++ were created for speed, while others were designed for efficient computation in their domain. The emergence of data science tasks required a language that not only was fast but that also had a feature to remove the need for multiple languages to complete a computational job.
Julia fits these new requirements almost perfectly. The web site http://julialang . org/ states the following:
Julia provides the functionality, ease-of-use and intuitive syntax of R, Python, MATLAB, SAS or Stata combined with the speed, capacity and performance of C, C++ or Java [].
Being open source in nature, Julia attracted a good number of developers to write modules that are now used for most work. Julia is one of the the fastest modern open source languages for data science, machine learning, and scientific computing.
With Julias impressive set of facilities, you should now have enough reasons to explore the langauge. It is one of the newest programming languages that can be used for almost any type of computational tasks at present and, hopefully, in the future as well. In addition, many high-tech companies seek Julian coders.
If you have some experience with the Python programming language, you know that it became popular for a variety of reasons. It has an extremely simple learning curve. With open source architecture, millions of developers have poured in thousands of packages to perform various tasks. These packages are easy to use. You only have to import them using a simple command. Python can also work on a variety of platforms. It is object-oriented, which makes it one of the best-suited, high-level languages for simulation and computation in general. It can also run parts of code written in other programming languages. With these characteristics, it has become the most popular language among coders at the time of writing. But, it has one big problem: it is slow. Consequently, developers have found themselves in a fix when they need to write time-efficient code. Many times, they choose to write time-inefficient parts in faster languages like C or C++. This process makes the overall experience very enriching but cumbersome. The primary motivation to create Julia mainly arose from this issue.
Julias creators themselves remark [] on these issues:
We want a language thats open source, with a liberal license. We want the speed of C with the dynamism of Ruby. We want a language thats 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. (Did we mention it should be as fast as C?)
The introduction of LLVM (Low Level Virtual Machine ) enabled [] this ideology. It became possible to design a language from the the onset that satisfies most requirements and, hence, eliminates the two-language approach. The LLVM-based JIT (just-in-time) compiler allows Julia to approach and often match the performance of C/C++ . (Explaining this concept in detail is beyond the scope of this book and irrelevant for a beginner.)
1.2 JIT Compiler
All programming instructions end up as machine code that is run on hardware (hence, machine code is hardware-specific). Thus, faster code simply means efficient machine code. Machine code can be done by hand, but it is a tedious job. Assembly language (lower level language) is a symbolic representation of machine code and can be fed by hand to a hardware device, but it suffers from two major roadblocks:
It is not easy to read and write.
It is hardware-specific.
These two problems are overcome by higher-level language. Currently, a variety of higher-level languages exists. FORTRAN, C, C++, and so on, are compiler-based languages where writing and reading code is easier than assembly language; they convert to machine code quite efficiently. However, users are forced to provide a lot of information about how the code should execute and what data types are used. With ample information given to the compiler, the compiler builds machine code AOT (ahead-of- time ). On the other hand, interpreted languages like Python generate machine code on the fly, that is, during program execution. Instead of a compiler, these languages use an interpreter that interprets each line of code to be ultimately converted into machine code. This allows a flexible and interactive environment that is loved by all. Programmers can even delegate defining data types and defining memory allocation tasks to the interpreter. But these facilities come at a cost since interpreted languages need time to create proper machine code.
JIT compilation brings together the best of both the AOT and interpreter worlds. The primary difference is that functions for specific tasks are compiled as requested. In some instances, the programmer supplies all the information to the compiler for efficient conversion to machine code. When some pieces of information are missing, the compiler tries to infer missing information based on its usage.
However, in some cases, JIT isnt the most optimum approach and fails miserably. This happens when type inference fails or the compiler has insufficient information to optimize effectively.
With these ideas in mind, the creators of Julia set upon an interesting journey that provided the world with one of the most promising programming languages. Learning about the history of its development can be very inspiring. The next section will describe how people from various backgrounds came together to collaborate and make Julia.
