This Learning Path is your step-by-step guide to learn the high-level and high-performance Julia language and build simple-to-advanced applications with it using modern tools. Through multiple projects and examples, you'll learn work with powerful open-source libraries for data wrangling, analysis, and visualization and build full-featured ...

• Cover
• Title Page
• Copyright and Credits
• About Packt
• Contributors
• Table of Contents
• Preface
• Chapter 1: Installing the Julia Platform
  • Installing Julia
    • Windows OS
    • OS X
    • Linux OS
    • Building from source
    • JuliaPro
  • Working with Julia's REPL
  • Startup options and Julia scripts
  • Packages
    • Adding a new package
  • Installing and working with IJulia
  • Installing Juno
  • Installing julia-vscode
  • Installing Sublime-IJulia
  • Other editors and IDEs
  • How Julia works
  • Summary
• Chapter 2: Variables, Types, and Operations
  • Variables, naming conventions, and comments
  • Types
  • Integers
  • Floating point numbers
  • Elementary mathematical functions and operations
  • Rational and complex numbers
  • Characters
  • Strings
    • Formatting numbers and strings
  • Regular expressions
  • Ranges and arrays
    • Other ways to create arrays
    • Some common functions for arrays
  • Dates and times
  • Scope and constants
  • Summary
• Chapter 3: Functions
  • Defining functions
  • Optional and keyword arguments
  • Anonymous functions
  • First-class functions and closures
  • functions
  • Broadcasting
  • Map, filter, and list comprehensions
  • Generic functions and multiple dispatch
  • Summary
• Chapter 4: Control Flow
  • Conditional evaluation
  • Repeated evaluation
    • for loops
    • while loops
    • The break statement
    • The continue statement
  • Exception handling
  • Scope revisited
  • Tasks
  • Summary
• Chapter 5: Collection Types
  • Matrices
  • Tuples
  • Dictionaries
    • Keys and values – looping
  • Sets
  • An example project – word frequency
  • Summary
• Chapter 6: More on Types, Methods, and Modules
  • Type annotations
    • Type conversions and promotions
  • The type hierarchy – subtypes and supertypes
  • Concrete and abstract types
  • User-defined and composite types
    • When are two values or objects equal or identical?
    • A multiple-dispatch example
  • Types and collections – inner constructors
  • Type unions
  • Parametric types and methods
  • Standard modules and paths
  • Summary
• Chapter 7: Metaprogramming in Julia
  • Expressions and symbols
  • Evaluation and interpolation
  • Defining macros
  • Built-in macros
    • Testing
    • Debugging
    • Benchmarking
    • Starting a task
  • Reflection capabilities
  • Summary
• Chapter 8: I/O, Networking, and Parallel Computing
  • Basic input and output
  • Working with files
    • Reading and writing CSV files
  • Using DataFrames
    • Other file formats
  • Working with TCP sockets and servers
  • Interacting with databases
  • Parallel operations and computing
    • Creating processes
    • Using low-level communications
    • Parallel loops and maps
  • Summary
• Chapter 9: Running External Programs
  • Running shell commands
    • Interpolation
    • Pipelining
  • Calling C and Fortran
  • Calling Python
  • Performance tips
    • Tools to use
  • Summary
• Chapter 10: The Standard Library and Packages
  • Digging deeper into the standard library
  • Julia's package manager
    • Installing and updating packages
  • Graphics in Julia
  • Using Plots on data
  • Summary
• Chapter 11: Creating Our First Julia App
  • Technical requirements
  • Defining variables
    • Constants
    • Why are constants important?
  • Comments
  • Strings
    • Triple-quoted strings
    • Concatenating strings
    • Interpolating strings
    • Manipulating strings
    • Unicode and UTF-8
  • Regular expressions
  • Raw string literals
  • Numbers
    • Integers
    • Overflow behavior
    • Floating-point numbers
    • Rational numbers
    • Numerical operators
    • Vectorized dot operators
    • There's more to it
  • Tuples
    • Named tuples
  • Ranges
  • Arrays
    • Iteration
    • Mutating arrays
    • Comprehensions
    • Generators
  • Exploratory data analysis with Julia
    • The Iris flower dataset
    • Using the RDatasets package
  • Using simple statistics to better understand our data
    • Visualizing the Iris flowers data
  • Loading and saving our data
    • Saving and loading using tabular file formats
    • Working with Feather files
    • Saving and loading with MongoDB
  • Summary
• Chapter 12: Setting Up the Wiki Game
  • Technical requirements
  • Data harvesting through web scraping
    • How the web works – a crash course
    • Making HTTP requests
      • Learning about HTTP methods
      • Understanding HTTPS
  • Understanding HTML documents
    • HTML selectors
      • Learning about the HTML attributes
    • Learning about CSS and JavaScript selectors
    • Understanding the structure of a link
  • Accessing the internet from Julia
    • Making requests with the HTTP package
  • Handling HTTP responses
    • HTTP status codes
    • Learning about HTTP headers
    • The HTTP message body
  • Understanding HTTP responses
    • The status code
      • The headers
      • The message body
      • Learning about pairs
  • Dictionaries
    • Constructing dictionaries
      • Ordered dictionaries
      • Working with dictionaries
  • Using the HTTP response
    • Manipulating the response body
    • Building a DOM representation of the page
    • Parsing HTML with Gumbo
  • Coding defensively
    • The pipe operator
  • Handling errors like a pro
    • The try...catch statements
    • The finally clause
    • Throwing exceptions on errors
    • Rethrowing exceptions
  • Learning about functions
    • The return keyword
    • Returning multiple values
      • Optional arguments
      • Keyword arguments
    • Documenting functions
  • Writing a basic web crawler – take one
    • Setting up our project
    • Writing a Julia program
    • Conditional evaluation of if, elseif, and else statements
    • The ternary operator
    • Short-circuit evaluation
      • Beware of operator precedence
  • Carrying on with the crawler's implementation
  • Summary
• Chapter 13: Building the Wiki Game Web Crawler
  • Technical requirements
  • Six Degrees of Wikipedia, the gameplay
    • Some additional requirements
  • Organizing our code
    • Using modules to tame our code
    • Defining modules
      • Productive REPL sessions with Julia
    • Setting up our modules
    • Referencing modules
      • Setting up the LOAD_PATH
      • Loading modules with using
      • Loading modules with import
      • Loading modules with include
    • Nesting modules
  • Setting up our game's architecture
    • Checking our code
  • Building our Wikipedia crawler - take two
    • Using blocks
  • Implementing the gameplay
  • Finishing touches
    • One more thing
  • Learning about Julia's type system
    • Defining our own types
    • Constructing types
    • Mutable composite types
    • Type hierarchy and inheritance
    • Type unions
  • Using article types
    • Inner constructors
  • Methods
  • Working with relational databases
    • Adding MySQL support
      • Connecting to the database
    • Setting up our Article module
      • Adding the persistence and retrieval methods
      • Putting it all together
  • Summary
• Chapter 14: Adding a Web UI for the Wiki Game
  • Technical requirements
  • The game plan
  • Learning about Julia's web stack
    • Beginning with a simple example – Hello World
  • Developing the game's web UI
    • Defining our routes
    • Preparing the landing page
  • Starting a new game
    • Extracting the difficulty settings from the page URL
    • Starting a new game session
    • Rendering the first Wikipedia article from the chain
    • Setting up in-article navigation
    • Displaying information about the game session
  • Displaying a Wikipedia article page
    • Navigating back up the article chain
  • Showing the solution
  • Handling any other requests
  • Wrapping it up
  • Summary
• Chapter 15: Implementing Recommender Systems with Julia
  • Technical requirements
  • Understanding recommender systems
  • Classifying recommender systems
    • Learning about non-personalized, stereotyped, and personalized recommendations
      • Understanding personalized recommendations
        • Explicit and implicit ratings
      • Understanding content-based recommender systems
      • Beginning with association-based recommendations
      • Learning about collaborative filtering
        • Understanding user-item CF
        • Item-item CF
  • Summary
• Chapter 16: Machine Learning for Recommender Systems
  • Technical requirements
  • Comparing the memory-based versus model-based recommenders
    • Learning about the model-based approach
    • Understanding our data
      • A first look at the data
      • Loading the data
      • Handling missing data
    • Data analysis and preparation
      • Training our data models
      • Scaling down our dataset
      • Training versus testing data
  • Machine learning-based recommendations
    • Making recommendations with Recommendation
      • Setting up the training data
      • Building and training the recommender
        • Matrix Factorization
      • Making recommendations
  • Testing the recommendations
  • Learning about hybrid recommender systems
  • Summary
• Other Books You May Enjoy
• Index