Book Overview & Buying
Table Of Contents
Feedback & Rating

Learning Julia

By : Anshul Joshi, Lakhanpal

3 (2)

Buy this Book

Learning Julia

3 (2)

By: Anshul Joshi, Lakhanpal

Buy this Book

Overview of this book

Julia is a highly appropriate language for scientific computing, but it comes with all the required capabilities of a general-purpose language. It allows us to achieve C/Fortran-like performance while maintaining the concise syntax of a scripting language such as Python. It is perfect for building high-performance and concurrent applications. From the basics of its syntax to learning built-in object types, this book covers it all. This book shows you how to write effective functions, reduce code redundancies, and improve code reuse. It will be helpful for new programmers who are starting out with Julia to explore its wide and ever-growing package ecosystem and also for experienced developers/statisticians/data scientists who want to add Julia to their skill-set. The book presents the fundamentals of programming in Julia and in-depth informative examples, using a step-by-step approach. You will be taken through concepts and examples such as doing simple mathematical operations, creating loops, metaprogramming, functions, collections, multiple dispatch, and so on. By the end of the book, you will be able to apply your skills in Julia to create and explore applications of any domain.

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Free Chapter

Understanding Julia's Ecosystem

What makes Julia unique?

Installing Julia

Julia's importance in data science

Using REPL

Using Jupyter Notebook

What is Juno?

Package management

A brief about multiple dispatch

Understanding LLVM and JIT

Summary

References

Programming Concepts with Julia

Revisiting programming paradigms

Starting with Julia REPL

Variables in Julia

Integers, bits, bytes, and bools

Floating point numbers in Julia

Logical and arithmetic operations in Julia

Understanding arrays, matrices, and multidimensional arrays

Understanding DataFrames

Summary

Functions in Julia

Creating functions

Function arguments

Anonymous functions

Multiple dispatch

Recursion

Built-in functions

Summary

Understanding Types and Dispatch

Julia's type system

Type annotations

More on types

The subtypes and supertypes

User-defined and composite data types

Inner constructors

Modules and interfaces

Module file paths

Multiple dispatch explained

Summary

Working with Control Flow

Conditional and repeated evaluation

Exception handling

Tasks in Julia

Summary

Interoperability and Metaprogramming

Interacting with operating systems

Calling C and Python!

Expressions and macros

Built-in macros

Type introspection and reflection capabilities

Summary

Numerical and Scientific Computation with Julia

Working with data

Linear algebra and differential calculus

Statistics

Optimization

Summary

Data Visualization and Graphics

Basic plots

Vega

Gadfly

Summary

Connecting with Databases

How to connect with databases?

Relational databases

NoSQL databases

Introduction to REST

Summary

Julia’s Internals

Under the hood

Performance enhancements

Standard library

LLVM and JIT explained

Parallel computing

TCP sockets and servers

Creating packages

Summary

Customer Reviews

3 (2)

5 star

50%

4 star

3 star

2 star

1 star

50%

Module file paths

In general, when you write a file path using SomeSampleModule, Julia looks for that package in the main (it acts as Julia's top-level module):

julia> using SomeSampleModule
ERROR: ArgumentError: Module SomeSampleModule not found in current path.
Run `Pkg.add("SomeSampleModule")` to install the SomeSampleModule package.
 in require(::Symbol) at ./loading.jl:365
 in require(::Symbol) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?

If not shown as in the preceding error, then it may try to look internally for a package installed from an outside source, typically calling the require function (SomeSampleModule).

Conversely, let's suppose you are working on a big project that has many modules in it. Now, a situation may come up wherein you are required to call one module's function into some other module...