What this book covers

Chapter 1: The Julia Environment is intended as a gentle introduction to Julia which covers the steps needed to get a working distribution up and running and the steps needed to acquire packages and run Julia in the REPL, code editors (in particular) VS-Code and the Jupyter and Pluto IDEs, continuing then by illustrating these with some simple examples.

Chapter 2: Developing in Julia is an overview of some of Julia’s basic syntax, discussing how to work with simple numeric and character variables either as scalars or in array aggregates, along with briefly introducing the concept of data frames, which will be met often in the remainder of the book.

Chapter 3: The Julia Type System describes first the use of further features such as the specification of parametric and optional parameters as arguments to functions and then continues by introducing the idea of abstract and concrete data types as a precursor to working with and defining more complex composite data structures. It concludes by considering unions and aliases in Julia and higher dimensional arrays.

Chapter 4: The Three M’s covers the topics of three aspects of Julia which may be a little more unfamiliar to users of a different programming language, namely the concept (and use of) multiple dispatch, the macro system, and Julia’s approach to modularity, which is somewhat different to conventional object-oriented systems.

Chapter 5: Interoperability is a little different as it is concerned with Julia working together with other languages either directly with C, Python, and R (via the shared libraries or APIs) or indirectly by invoking the aid of the operating system, setting up pipelines and redirecting basic input and output.

Chapter 6: Working with Data is the first of the themed chapters, concerned primarily with handling textural and binary data files, and structured datasets, and meeting again in much more detail Julia’s sophisticated structures, i.e., data frames and tables. The chapter concludes by applying some simple statistical analysis to some of the datasets referenced.

Chapter 7: Scientific Programming may have originally been viewed as the jewel in Julia’s crown, the raison d’etre of its purpose. The development of the language encompassed many other aspects but recently its focus on machine learning and system simulations may be heralding a move back in this direction. It covers a wide variety of topics including linear algebra, signal processing, solution of differential equations, optimization, and stochastics, albeit briefly.

Chapter 8: Visualization provides a little light relief turning to the production of graphics and other forms of imagery. Originally Julia was criticized, unfairly, as being deficient in this area but now has an embarrassment of riches. The chapter covers simple (raster) video displays and packages for creating vector graphics & hardcopy output such as PDFs and then now to the comprehensive Plots API. It also touches on the powerful image processing packages and concludes with an overview of some Julia mega graphic frameworks.

Chapter 9: Database Access, as might be inferred from the name, deals with Julia’s methods for interaction with databases. The division between relational (SQL-style) databases and others, often lumped together and NoSQL is described and various examples of each are explored, both disk-based and in-memory types. It continues by describing the use of REST-style web database APIS and finishes with a discussion of the use of the Queryverse and its interaction with VegaLite graphics.

Chapter 10: Networks and Multi-tasking focuses on the methods in Julia for multitasking and working with distributed systems. It introduces the concept of sockets and creates networked services that can be used when working with the web. Then the methods by which parallel processes can be defined and run in Julia are presented, finally, it concludes with a discussion of analyzing distributed datasets.

Chapter 11: Julia’s Back Pages are a little different dealing with topics that should be understood to progress from causal user to serious developer. It covers running scripts without the REPL (or an equivalent IDE) and then onto the major topic of creating Julia packages, by means of techniques such as code profiling and use of the debugger. Finally poses the question of where next for Julia, however, does not attempt to answer it!