6e. Illustration - Johnny, the YouTuber

Introduction

Through a practical example, this section will demonstrate the convenience of the following features:

1. Boolean indexing for working with subsets of the data

2. organizing code around functions

3. pipes to enhance code readability

4. use of views to modify subsets of the data

Some General Information

We begin by examining the per-view payments made by YouTube. We first show that Johnny's payments range from $2 to $6. Moreover, using the countmaps function from the StatsBase package, we conclude that Johnny has eight videos reaching the maximum payment of $6.

range_payrates  = unique(payrates) |> sort

5-element Vector{Int64}:
 2
 3
 4
 5
 6

using StatsBase
occurrences_payrates = countmap(payrates) |> sort

OrderedDict{Int64, Int64} with 5 entries:
  2 => 5
  3 => 6
  4 => 8
  5 => 5
  6 => 6

We can also provide some insights into Johnny's most profitable videos. By applying the sort function, we can isolate his top 3 highest-earning videos. Moreover, we can apply the sortperm function to identify their indices, allowing us to extract the payment per view and total visits associated with each video.

top_earnings    = sort(earnings, rev=true)[1:3]

3-element Vector{Float64}:
 7757.81
  693.813
  672.802

indices         = sortperm(earnings, rev=true)[1:3]

sorted_payrates = payrates[indices]

3-element Vector{Int64}:
 6
 6
 6

indices         = sortperm(earnings, rev=true)[1:3]

sorted_visits   = visits[indices]

3-element Vector{Float64}:
 1292.97
  115.636
  112.134

Functions to Represent Tasks

The approach employed so far allows for a quick exploration of Johnny's viral videos. However, it lacks the structure needed for a systematic analysis across different subsets of the data. To address this limitation, we can capture the characterization of videos through a function.

Recall that a well-designed function should embody a single clearly defined task. In our case, the goal is to subset data and extract key statistics, including the number of videos, visits, and revenue generated. Furthermore, the function should remain independent of any specific application, so it can be reused to analyze different groups of videos without rewriting code each time.

The function below implements this task taking three arguments: the raw data (visits and payrates) and a condition that defines the subset of data (condition). By keeping the condition generic, the function is flexible enough to target any subset of videos. The example also showcases the convenience of pipes to compute intermediate temporary steps.

#
function stats_subset(visits, payrates, condition)
    nrvideos = sum(condition)
    audience = sum(visits[condition])
    
    earnings = visits .* payrates
    revenue  = sum(earnings[condition])
    
    return (; nrvideos, audience, revenue)
end

using Pipe
function stats_subset(visits, payrates, condition)
    nrvideos = sum(condition)
    audience = sum(visits[condition])
    
    
    revenue  = @pipe (visits .* payrates) |> x -> sum(x[condition])
    
    return (; nrvideos, audience, revenue)
end

using Pipe
function stats_subset(visits, payrates, condition)
    nrvideos = sum(condition)
    audience = sum(visits[condition])
    
    
    revenue  = @pipe (visits .* payrates) |> sum(_[condition])
    
    return (; nrvideos, audience, revenue)
end

Below, we demonstrate the reusability of the function by characterizing various subsets of data.

viral_threshold  = 100
is_viral         = (visits .≥ viral_threshold)
viral            = stats_subset(visits, payrates, is_viral)

(nrvideos = 4, audience = 1625.05, revenue = 9750.3)

viral_threshold  = 100
is_notviral      = .!(is_viral)      # '!' is negating a boolean value and we broadcast it
notviral         = stats_subset(visits, payrates, is_notviral)

(nrvideos = 26, audience = 1497.02, revenue = 5687.67)

days_to_consider = (1, 10, 25)      # subset of days to be characterized
is_day           = in.(eachindex(visits), Ref(days_to_consider))
specific_days    = stats_subset(visits, payrates, is_day)

(nrvideos = 3, audience = 182.939, revenue = 1030.33)

Broadcasting Over a List of Functions

A function like stats_subset is useful for computing a fixed set of summary statistics. However, since the choice of statistics is hard‑coded into the function’s definition, the output can't be changed without rewriting the code. This rigidity makes the function less reusable across different analytical contexts.

A more flexible approach consists of specifying which statistics to compute at the time of use. Julia makes this possible because functions are first-class objects, entailing that functions behave just like any other variable. This feature lets us define a list of statistical functions, eventually applying them element-wise to the variables we want to characterize.

Below, we apply this methodology to characterize the variable visits.

list_functions = [sum, median, mean, maximum, minimum]

stats_visits   = [fun(visits) for fun in list_functions]

5-element Vector{Float64}:
 3447.08
   64.8765
  114.903
 1551.56
   28.2954

The same methodology can also be employed for characterizing multiple variables at once. In fact, broadcasting makes this straightforward to implement. For instance, below we simultaneously characterize visits and earnings.

list_functions = [sum, median, mean, maximum, minimum]

stats_various  = [fun.([visits, payrates]) for fun in list_functions]

5-element Vector{Vector{Float64}}:
 [3447.08, 121.0]
 [64.8765, 4.0]
 [114.903, 4.03333]
 [1551.56, 6.0]
 [28.2954, 2.0]

One major limitation of the current method is its inability to reflect each statistic's name. To address this, we can collect all statistics in a named tuple, enabling the access of each through its name. For instance, given a named tuple stats_visits, it'll become possible to retrieve the average value of visits by stats_visits.mean or stats_visits[:mean].

To assign names to the statistics within the named tuple, we'll use the Symbol type. This translates strings into identifiers that can act as keys of a named tuple, enabling programmatic access to each statistic.

vector_of_tuples = [(Symbol(fun), fun(visits)) for fun in list_functions]
stats_visits     = NamedTuple(vector_of_tuples)

(sum = 3447.08, median = 64.8765, mean = 114.903, maximum = 1551.56, minimum = 28.2954)

114.903

64.8765