Index
A
- advanced documentation tips / Advanced documentation tips
- algorithm seeding / Algorithm seeding
- anomaly detection / Unsupervised machine learning
- areas
- identifying, with most businesses / Finding the areas with the most businesses
- ARIMA models / Closing thoughts
- Article model
- setting up / Setting up our Article module
- retrieval method, adding / Adding the persistence and retrieval methods
- persistence method, adding / Adding the persistence and retrieval methods
- code, updating / Putting it all together
- article types
- using / Using article types
- inner constructors / Inner constructors
- artificial neural networks (ANN) / Closing thoughts
- association-based recommendations / Beginning with association-based recommendations
- Atom
- download link / Juno (Atom)
- Attobot / Unleashing Julia's army of bots
- autocorrelation / Autocorrelation
- autoregressive integrated moving average (ARIMA) / Closing thoughts
B
- basic movie recommender
- building, content-based algorithm used / Understanding content-based recommender systems
- basic web crawler
- writing / Writing a basic web crawler – take one
- project setup / Setting up our project
- Julia program, writing / Writing a Julia program
- implementing / Carrying on with the crawler's implementation
- BatchGeo
- reference / Using BatchGeo to quickly build maps of our data
- maps, building of data / Using BatchGeo to quickly build maps of our data
- benchmarking tools / Benchmarking tools
- benchmarks, Julia
- reference / Good performance
- BenchmarkTools
- reference / Benchmarking tools
- bivariate correlation / Understanding user-item CF
- Book-Crossing Dataset
- reference / Understanding our data
C
- Cascading Style Sheets (CSS) / HTML selectors
- centroid / The k-means algorithm
- Chocolately
- reference / Using Chocolatey
- Julia, installing on Windows / Using Chocolatey
- clustering / Unsupervised machine learning, Clustering, Unsupervised machine learning with clustering
- clustering validation / Clustering validation
- clusters
- visualizing, on map / Visualizing our clusters on the map
- selecting, for k-means / Choosing the optimal number of clusters for k-means (and other algorithms)
- code
- benchmarking / Benchmarking our code
- code organization, Six Degrees of Wikipedia game
- about / Organizing our code
- modules, using / Using modules to tame our code
- modules, defining / Defining modules
- modules, setting up / Setting up our modules
- modules, referencing / Referencing modules
- modules, nesting / Nesting modules
- collaborative filtering
- about / Learning about collaborative filtering
- user-item collaborative filtering / Understanding user-item CF
- item-item collaborative filtering / Item-item CF
- comments / Comments
- composite type / Defining our own types
- conditional evaluation / Conditional evaluation of if, elseif, and else statements
- constants
- about / Constants
- significance / Why are constants important?
- content-based algorithm
- used, for building basic movie recommender / Understanding content-based recommender systems
- content-based recommender systems / Understanding content-based recommender systems
- CSS selectors
- reference / Learning about CSS and JavaScript selectors
- cyclicity / Cyclicity
D
- data
- preparing / Preparing our data
- data analysis, San Francisco businesses / Data analysis of the San Francisco business
- data harvesting
- through web scraping / Data harvesting through web scraping
- data wrangling
- with query / Data wrangling with query
- date accessors
- working with / Working with date and time accessors
- date adjustments / Date adjustments
- date ranges
- defining / Defining the date ranges
- dates
- working with / Working with dates and times
- constructing / Constructing dates and times
- converting / Constructing dates and times
- strings, parsing into / Parsing strings into dates and times
- formatting / Formatting dates
- querying / Querying dates
- rounding of / Rounding of dates
- Dates API
- reference / Querying dates
- date strings
- parsing / Parsing date strings
- defensive coding / Coding defensively
- dictionaries
- about / Dictionaries
- constructing / Constructing dictionaries
- ordered dictionaries / Ordered dictionaries
- working with / Working with dictionaries
- Docker / Docker
- docset / Advanced documentation tips
- docstring / Documenting functions
- documentation
- generating / Generating the documentation
- Document Object Model (DOM) / Manipulating the response body
E
- elseif statement / Conditional evaluation of if, elseif, and else statements
- else statement / Conditional evaluation of if, elseif, and else statements
- Emacs
- reference / Other options
- errors
- handling / Handling errors like a pro
- exceptions, throwing on / Throwing exceptions on errors
- Eurostat data
- about / A quick look at our data
- processing / Data processing
- exceptions
- throwing, on errors / Throwing exceptions on errors
- rethrowing / Rethrowing exceptions
- expressions
- in metaprogramming / Learning about symbols and expressions in metaprogramming
- extract, transform, load (ETL) / Data analysis and preparation
F
- finally clause / The finally clause
- FiveThirtyEight
- reference / Understanding our data
- functions
- about / Learning about functions
- multiple values, returning / Returning multiple values
- documenting / Documenting functions
G
- generic Linux binaries, Julia
- reference / Linux and FreeBSD
- GitHub API
- interacting with / Interacting with the GitHub API
- authenticating with / Authenticating with the GitHub API
- GitHub issues
- reporting / Reporting GitHub issues
- Gumbo
- HTML, parsing / Parsing HTML with Gumbo
H
- higher-order functions / Using blocks
- Homebrew
- homoiconic / Metaprogramming in Julia
- HTML
- parsing, with Gumbo / Parsing HTML with Gumbo
- HTML attributes / Learning about the HTML attributes
- HTML documents / Understanding HTML documents
- HTML selectors / HTML selectors
- HTTP headers
- about / Learning about HTTP headers
- reference / Learning about HTTP headers
- HTTP message body / The HTTP message body
- HTTP methods
- about / Learning about HTTP methods
- reference / Learning about HTTP methods
- HTTP package
- requests, making with / Making requests with the HTTP package
- HTTP requests
- making / Making HTTP requests
- HTTP response
- DOM representation, building of page / Building a DOM representation of the page
- HTTP responses
- handling / Handling HTTP responses
- about / Understanding HTTP responses
- status code / The status code
- headers / The headers
- message body / The message body
- pairs / Learning about pairs
- using / Using the HTTP response
- response body, manipulating / Manipulating the response body
- HTTP Secure (HTTPS) / Understanding HTTPS
- HTTP status codes
- 1XX - Informational / HTTP status codes
- 2XX - Success / HTTP status codes
- 3XX - Redirection / HTTP status codes
- 4XX - Client Error / HTTP status codes
- 5XX - Server Error / HTTP status codes
- hybrid / Learning about hybrid recommender systems
- Hybrid recommender systems
- Hypertext Markup Language (HTML) / Understanding HTML documents
- Hypertext Transfer Protocol (HTTP) / Making HTTP requests
I
- IDE
- selecting / Choosing an IDE
- Juno (Atom) / Juno (Atom)
- Visual Studio Code / Visual Studio Code
- IJulia (JuliaBox) / IJulia (JuliaBox)
- julia-vim / Other options
- IJulia (JuliaBox)
- reference / IJulia (JuliaBox)
- IJulia Jupyter notebooks
- reference / JuliaBox
- inner constructor / Inner constructors
- integers / Integers
- internet
- accessing, from Julia / Accessing the internet from Julia
- IssueReporter.jl package / The IssueReporter.jl package
- item-based filtering / Comparing the memory-based versus model-based recommenders
- item-item collaborative filtering / Item-item CF
J
- JavaScript selectors / Learning about CSS and JavaScript selectors
- Julia
- need for / Why Julia?
- performance / Good performance
- installing / Installing Julia
- installing, on Windows / Windows
- installing, on macOS / macOS
- internet, accessing from / Accessing the internet from Julia
- type system / Learning about Julia's type system
- web stack / Learning about Julia's web stack
- time series data / Time series data in Julia
- julia-vim
- reference / Other options
- JuliaBox
- reference / JuliaBox
- Julia container, Docker store
- reference / Docker
- julian mode / Interacting with the REPL
- Julia packages
- creating / Creating a new Julia package
- generating / Generating packages
- Project.toml file / The Project.toml file
- src folder / The src folder and the main module
- main module / The src folder and the main module
- using / Using our new package
- requisites / Defining the requirements for our package
- JuliaPro
- about / JuliaPro
- download link / JuliaPro
- reference / Juno (Atom)
- Julia registry / Peeking into Julia's registry
- Julia REPL
- about / The Julia REPL
- interacting with / Interacting with the REPL
- ans variable / The ans variable
- prompt pasting / Prompt pasting
- tab completion / Tab completion
- exiting / Exiting the REPL
- Juno
- reference / Juno (Atom)
- just-in-time (JIT) compiler / Good performance
K
- k-means algorithm / The k-means algorithm
- Kaggle
- reference / Understanding our data
- keyword arguments / Keyword arguments
L
- landing page
- preparing / Preparing the landing page
- Language Integrated Query (LINQ) / Data wrangling with query
- last-in-first-out (LIFO) / Connecting to the database
- link
- structure / Understanding the structure of a link
- Lisp / Metaprogramming in Julia
- listwise deletion / Handling missing data
- locales
- defining / Defining other locales
M
- Machine Learning (ML) models / Understanding our data
- machine learning-based recommendations
- about / Machine learning-based recommendations
- recommendations, creating / Making recommendations with Recommendation
- training data, setting up / Setting up the training data
- recommender, building / Building and training the recommender
- recommender, training / Building and training the recommender
- creating / Making recommendations
- testing / Testing the recommendations
- macOS
- Julia, installing on / macOS
- macros / Macros, Closing words about macros
- market basket analysis / Beginning with association-based recommendations
- Matrix Factorization (MF) / Training our data models, Matrix Factorization
- memory-based recommenders
- versus model-based recommenders / Comparing the memory-based versus model-based recommenders
- metaprogramming
- methods
- Miniconda / IJulia (JuliaBox)
- Missings package
- reference / Understanding user-item CF
- missing values
- handling / Handling missing data
- handling, via deletion / Handling missing data
- handling, via imputation / Handling missing data
- reference / Handling missing data
- ML algorithms
- reference / Training our data models
- model-based approach
- probability / Learning about the model-based approach
- enhanced memory-based / Learning about the model-based approach
- linear algebra / Learning about the model-based approach
- model-based recommenders
- about / Learning about the model-based approach
- data, preprocessing / Understanding our data
- data / A first look at the data
- dataset, loading / Loading the data
- missing data, handling / Handling missing data
- data analysis / Data analysis and preparation
- data preparation / Data analysis and preparation
- data models, training / Training our data models
- dataset, scaling down / Scaling down our dataset
- testing data, versus training data / Training versus testing data
- modules, Six Degrees of Wikipedia game
- using / Using modules to tame our code
- defining / Defining modules
- productive REPL sessions / Productive REPL sessions with Julia
- setting up / Setting up our modules
- LOAD_PATH, setting up / Setting up the LOAD_PATH
- loading / Loading modules with using
- loading, with import function / Loading modules with import
- loading, with include / Loading modules with include
- nesting / Nesting modules
- multiple dispatch / Methods
- mutable composite types / Mutable composite types
- MySQL
- reference / Working with relational databases
- adding / Adding MySQL support
- connecting to / Connecting to the database
- MySQL Docker image
- reference / Working with relational databases
N
- new game
- starting / Starting a new game
- difficulty settings, extracting from page URL / Extracting the difficulty settings from the page URL
- session, starting / Starting a new game session
- Wikipedia article, rendering from chain / Rendering the first Wikipedia article from the chain
- in-article navigation, setting up / Setting up in-article navigation
- information, displaying / Displaying information about the game session
- non-standard string literals / Regular expressions
- numbers
O
- object-oriented programming (OOP) / Learning about Julia's type system
- official Windows installer
- Julia, installing on Windows / Official Windows installer
- download link / Official Windows installer
- OhMyREPL / OhMyREPL, One more step
- operator precedence / Beware of operator precedence
- optional arguments / Optional arguments
- ordered dictionaries / Ordered dictionaries
P
- package
- documenting / Documenting our package
- package registration
- about / Registering our package
- repository setup / Setting up the repository
- packages
- adding / Adding a package
- custom package installation / Custom package installation
- status, checking / Checking the package status
- using / Using packages
- updating / Updating packages
- pinning / Pinning packages
- removing / Removing packages
- registered, versus unregistered / Registered versus unregistered
- package system / The package system
- pairs / Learning about pairs
- Pearson's r correlation / Understanding user-item CF
- performance, Julia
- concise syntax / Concise, readable, and intuitive syntax
- readable syntax / Concise, readable, and intuitive syntax
- intuitive syntax / Concise, readable, and intuitive syntax
- powerful/productive dynamic type system /
- designed for parallelism / Designed for parallelism and distributed computation
- designed for distributed computation / Designed for parallelism and distributed computation
- efficient intercommunication, with other languages / Efficient intercommunication with other languages
- powerful REPL / Powerful REPL and shell-like capabilities
- shell-like capabilities / Powerful REPL and shell-like capabilities
- performance testing
- about / Performance testing
- benchmarking tools / Benchmarking tools
- type stability / Type stability is key
- period arithmetic / Period types and period arithmetic
- period types / Period types and period arithmetic
- personalized recommendations
- about / Understanding personalized recommendations
- explicit ratings / Explicit and implicit ratings
- implicit ratings / Explicit and implicit ratings
- pipe operator / The pipe operator
- PlotlyJS
- reference / Visualizing our clusters on the map
- Plots package / A quick look at our data with Plots and PyPlot
- primitive type / Defining our own types
- Probabilistic Latent Semantic Analysis (PLSA) / Learning about the model-based approach
- Probabilistic Latent Semantic Indexing (PLSI) / Learning about the model-based approach
- prompt pasting / Prompt pasting
- pyplot function / A quick look at our data with Plots and PyPlot
Q
- Query.jl, basics
- quoting / Quoting expressions
R
- raw string literals / Raw string literals
- read-eval-print loop (REPL) / Why Julia?, Constructing dates and times
- recommender
- building / Building and training the recommender
- training / Building and training the recommender
- Matrix Factorization (MF) / Matrix Factorization
- recommender systems
- about / Understanding recommender systems
- classifying / Classifying recommender systems
- non-personalized / Learning about non-personalized, stereotyped, and personalized recommendations
- stereotyped / Learning about non-personalized, stereotyped, and personalized recommendations
- personalized / Learning about non-personalized, stereotyped, and personalized recommendations, Understanding personalized recommendations
- content-based / Understanding content-based recommender systems
- association-based / Beginning with association-based recommendations
- regular expressions
- about / Regular expressions
- reference / Regular expressions
- relational databases
- working with / Working with relational databases
- MySQL support, adding / Adding MySQL support
- Article model, setting up / Setting up our Article module
- REPL hooks / REPL hooks
- REPL modes
- about / Additional REPL modes
- help mode / Accessing the documentation with the help mode
- shell mode / Shell mode
- search modes / Search modes
- REPL scope
- cleaning / Cleaning the REPL scope
- requests
- making, with HTTP package / Making requests with the HTTP package
- handling / Handling any other requests
- return keyword / The return keyword
- Revise
- reference / Revise
- about / One more step
- rounding
- reference / Rounding of dates
- routes / Beginning with a simple example – Hello World
S
- San Francisco businesses
- data analysis / Data analysis of the San Francisco business
- schema migrations
- reference / Setting up our Article module
- scikit-learn library
- reference / Machine learning-based recommendations
- ScikitLearn.jl package
- reference / Machine learning-based recommendations
- seasonality / Seasonality
- Selenium
- reference / Accessing the internet from Julia
- short-circuit evaluation / Short-circuit evaluation
- Silhouettes / Clustering validation
- singular value decomposition (SVD) / Learning about the model-based approach
- Six Degrees of Wikipedia game
- gameplay / Six Degrees of Wikipedia, the gameplay
- technical requisites / Some additional requirements
- code, organizing / Organizing our code
- architecture, setting up / Setting up our game's architecture
- code, checking / Checking our code
- image, including / Finishing touches
- gameplay, testing / One more thing
- game plan / The game plan
- web UI, developing / Developing the game's web UI
- smoothing / Extracting the trend
- solution page
- displaying / Showing the solution
- startup.jl file / The startup.jl file
- stationarity / Time series stationarity
- Stochastic Gradient Descent (SGD) / Matrix Factorization
- strings
- about / Strings
- triple quoted strings / Triple-quoted strings
- concatenating / Concatenating strings
- interpolating / Interpolating strings, Interpolating strings
- manipulating / Manipulating strings
- parsing, into times / Parsing strings into dates and times
- parsing, into dates / Parsing strings into dates and times
- Sublime Text
- reference / Other options
- symbols
- in metaprogramming / Learning about symbols and expressions in metaprogramming
T
- ternary operator / The ternary operator
- test driven Julia development / Beginning with test-driven Julia development
- time accessors
- working with / Working with date and time accessors
- TimeArray objects
- indexing / Indexing the TimeArray objects
- querying / Querying TimeArray objects
- when() method / The when() method
- from() method / The from() method
- to() method / The to() method
- findall() method / The findall() and findwhen() methods
- findwhen() method / The findall() and findwhen() methods
- merge() method / merge()
- vcat() method / The vcat() method
- collapse() method / The collapse() method
- map() method / The map() method
- TimeArray type / The TimeArray type
- times
- working with / Working with dates and times
- constructing / Constructing dates and times
- converting / Constructing dates and times
- strings, parsing into / Parsing strings into dates and times
- time series
- differencing / Differencing a time series
- time series components
- about / Understanding time series components
- trend / Trend
- seasonality / Seasonality
- random noise (error) / Random noise
- cyclicity / Cyclicity
- time series data
- in Julia / Time series data in Julia
- time series decomposition
- about / Time series decomposition
- additive approach / Explaining data – an additive approach or multiplicative approach?
- multiplicative approach / Explaining data – an additive approach or multiplicative approach?
- trend, extracting / Extracting the trend
- seasonality, computing / Computing the seasonality
- time series forecasting
- about / Time series forecasting
- Naïve / Naïve
- simple average / Simple average
- moving average / Moving average
- linear regression / Linear regression
- time series objects
- manipulating / Manipulating time series objects
- TimeSeries operators
- arithmetic operators / TimeSeries operators
- comparison operators / TimeSeries operators
- logic operators / TimeSeries operators
- time series stationarity
- about / Time series stationarity
- differencing / Differencing a time series
- autocorrelation / Autocorrelation
- time zone-aware date ranges / Time zone-aware date ranges
- time zones
- support, adding for / Adding support for time zones
- converting / Converting time zones
- Tom's Obvious, Minimal Language (TOML) / Working with TOML files
- TOML files
- working with / Working with TOML files
- trend / Trend
- Triple exponential smoothing / Closing thoughts
- triple quoted strings / Triple-quoted strings
- try...catch statements / The try...catch statements
- type system, Julia
- about / Learning about Julia's type system
- primitive type / Defining our own types
- custom type, defining / Defining our own types
- composite type / Defining our own types
- reference / Defining our own types
- constructing / Constructing types
- mutable composite types / Mutable composite types
- hierarchy / Type hierarchy and inheritance
- inheritance / Type hierarchy and inheritance
- type unions / Type unions
U
- Unicode / Unicode and UTF-8
- Uniform Resource Identifiers (URIs) / Understanding the structure of a link
- Uniform Resource Locators (URLs) / Understanding the structure of a link
- unsupervised machine learning
- about / Unsupervised machine learning
- clustering / Unsupervised machine learning, Clustering
- anomaly detection / Unsupervised machine learning
- unsupervised machine learning, with clustering
- k-means algorithm / The k-means algorithm
- areas, finding with most businesses / Finding the areas with the most businesses
- model, training / Training our model
- results, interpreting / Interpreting the results
- findings, refining / Refining our findings
- user-item collaborative filtering / Understanding user-item CF
- UTF-8 / Unicode and UTF-8
V
- variables
- defining / Defining variables
- Visual Studio Code
- reference / Visual Studio Code
W
- web
- working / How the web works – a crash course
- web addresses / Understanding the structure of a link
- web crawlers / Data harvesting through web scraping
- web scraping / Data harvesting through web scraping
- web stack
- about / Learning about Julia's web stack
- Hello World example / Beginning with a simple example – Hello World
- web UI
- developing / Developing the game's web UI
- routes, defining / Defining our routes
- landing page / Defining our routes
- new game page / Defining our routes
- Wiki article page / Defining our routes
- back page / Defining our routes
- solution page / Defining our routes
- landing page, preparing / Preparing the landing page
- WebApp.jl file / Wrapping it up
- Wikipedia article page
- displaying / Displaying a Wikipedia article page
- navigating back / Navigating back up the article chain
- Wikipedia crawler
- building / Building our Wikipedia crawler - take two
- blocks, using / Using blocks
- gameplay, implementing / Implementing the gameplay
- Windows
- Julia, installing on / Windows
- Windows Subsystem for Linux
- Julia, installing on Windows / Windows Subsystem for Linux
Z
- ZonedDateTime period arithmetic / ZonedDateTime period arithmetic