update readme

Author: EmilHvitfeldt

.gitignore

@@ -1,2 +1,5 @@
 .Rproj.user
 docs
+
+/.quarto/
+**/*.quarto_ipynb

README.Rmd

@@ -35,60 +35,74 @@ pak::pak("emilhvitfeldt/debrief")
 
 First, create a profvis profile of some code:
 
-```{r example, eval = FALSE}
+```{r example}
 library(profvis)
 library(debrief)
 
-# Profile some code
+# Define some functions to profile
+process_data <- function(n) {
+  raw <- generate_data(n)
+  cleaned <- clean_data(raw)
+  summarize_data(cleaned)
+}
+
+generate_data <- function(n) {
+  x <- rnorm(n)
+  y <- runif(n)
+
+  data.frame(x = x, y = y, z = x * y)
+}
+
+clean_data <- function(df) {
+  df <- df[complete.cases(df), ]
+  df$x_scaled <- scale(df$x)
+  df$category <- cut(df$y, breaks = 5)
+  df
+}
+
+summarize_data <- function(df) {
+  list(
+    means = colMeans(df[, c("x", "y", "z")]),
+    sds = apply(df[, c("x", "y", "z")], 2, sd),
+    counts = table(df$category),
+    text = paste(round(df$x, 2), collapse = ", ")
+  )
+}
+
+# Profile the data pipeline
 p <- profvis({
- x <- rep(1, 1e6)
- y <- cumsum(x)
- z <- paste(1:1000, collapse = ", ")
+  results <- lapply(1:5, function(i) process_data(1e5))
 })
 ```
 
 ### Quick Summary
 
 Get a comprehensive overview with `pv_summary()`:
 
-```{r summary, eval = FALSE}
+```{r summary}
 pv_summary(p)
-#> ======================================================================
-#> PROFILING SUMMARY
-#> ======================================================================
-#>
-#> Total time: 120 ms (12 samples @ 10 ms interval)
-#> Source references: available
-#>
-#> --- TOP FUNCTIONS BY SELF-TIME ---
-#>    40 ms ( 33.3%)  paste
-#>    30 ms ( 25.0%)  cumsum
-#>    20 ms ( 16.7%)  rep
-#> ...
 ```
 
 ### Time Analysis
 
 Analyze where time is spent:
 
-```{r time, eval = FALSE}
+```{r time}
 # Self-time: time spent directly in each function
 pv_self_time(p)
 
 # Total time: time spent in function + all its callees
 pv_total_time(p)
 
 # Filter to significant functions only
-pv_self_time(p, min_pct = 5)           # >= 5% of time
-pv_self_time(p, n = 10, min_time_ms = 50)
-# Top 10 functions with >= 50ms
+pv_self_time(p, min_pct = 5) # >= 5% of time
 ```
 
 ### Hot Spots
 
 Find the hottest lines and call paths:
 
-```{r hotspots, eval = FALSE}
+```{r hotspots}
 # Hot source lines with context
 pv_print_hot_lines(p, n = 5, context = 3)
 
@@ -100,42 +114,30 @@ pv_print_hot_paths(p, n = 10)
 
 Deep dive into a specific function:
 
-```{r focus, eval = FALSE}
-pv_focus(p, "paste")
-#> ======================================================================
-#> FOCUS: paste
-#> ======================================================================
-#>
-#> --- Time Analysis ---
-#>   Total time:      40 ms ( 33.3%)  - time on call stack
-#>   Self time:       40 ms ( 33.3%)  - time at top of stack
-#>   Child time:       0 ms (  0.0%)  - time in callees
-#>
-#> --- Called By ---
-#>     12 calls (100.0%)  (top-level)
-#> ...
+```{r focus}
+pv_focus(p, "clean_data")
 ```
 
 ### Call Relationships
 
 Understand who calls what:
 
-```{r calls, eval = FALSE}
+```{r calls}
 # Who calls this function?
-pv_callers(p, "cumsum")
+pv_callers(p, "clean_data")
 
 # What does this function call?
-pv_callees(p, "my_function")
+pv_callees(p, "process_data")
 
 # Full caller/callee analysis
-pv_print_callers_callees(p, "target_func")
+pv_print_callers_callees(p, "summarize_data")
 ```
 
 ### Memory Analysis
 
 Track memory allocations:
 
-```{r memory, eval = FALSE}
+```{r memory}
 # Memory by function
 pv_print_memory(p, n = 10, by = "function")
 
@@ -147,102 +149,75 @@ pv_print_memory(p, n = 10, by = "line")
 
 Visualize the call tree:
 
-```{r flame, eval = FALSE}
+```{r flame}
 pv_flame(p, width = 70, min_pct = 2)
-#> ======================================================================
-#> FLAME GRAPH (text)
-#> ======================================================================
-#>
-#> Total time: 120 ms | Width: 70 chars | Min: 2%
-#>
-#> [======================================================================] (root) 100%
-#>   [=======================] paste (33.3%)
-#>   [=================] cumsum (25.0%)
-#>   [===========] rep (16.7%)
 ```
 
 ### Compare Profiles
 
 Measure optimization impact:
 
-```{r compare, eval = FALSE}
-# Before optimization
-p1 <- profvis(slow_function())
+```{r compare}
+# Approach 1: Growing vectors in a loop (slow)
+p_slow <- profvis({
+  result <- c()
+  for (i in 1:20000) {
+    result <- c(result, sqrt(i) * log(i))
+  }
+})
 
-# After optimization
-p2 <- profvis(fast_function())
+# Approach 2: Vectorized with memory allocation
+p_fast <- profvis({
+  x <- rnorm(5e6)
+  y <- cumsum(x)
+  z <- paste(head(round(x, 2), 50000), collapse = ", ")
+})
 
 # Compare two profiles
-pv_print_compare(p1, p2)
-#> ======================================================================
-#> PROFILE COMPARISON
-#> ======================================================================
-#>
-#> --- Overall ---
-#> IMPROVED: 500 ms -> 120 ms (4.2x faster, saved 380 ms)
-#>
-#> --- Biggest Changes ---
-#> Function                          Before      After       Diff   Change
-#> ------------------------------------------------------------------------
-#> slow_helper                          300         50       -250    -83%
-#> ...
-
-# Compare multiple optimization approaches
+pv_print_compare(p_slow, p_fast)
+
+# Approach 3: Data frame operations
+p_dataframe <- profvis({
+  df <- data.frame(
+    a = rnorm(1e6),
+    b = runif(1e6),
+    c = sample(letters, 1e6, replace = TRUE)
+  )
+  df$d <- df$a * df$b
+  result <- aggregate(d ~ c, data = df, FUN = mean)
+})
+
+# Compare all three approaches
 pv_print_compare_many(
-  baseline = p1,
-  vectorized = p2,
-  parallel = p3
+  growing_vector = p_slow,
+  vectorized = p_fast,
+  dataframe_ops = p_dataframe
 )
-#> ======================================================================
-#> MULTI-PROFILE COMPARISON
-#> ======================================================================
-#>
-#> Rank  Profile                      Time (ms)  Samples  vs Fastest
-#> --------------------------------------------------------------
-#>   1*  parallel                          85       9     fastest
-#>   2   vectorized                       120      12        1.41x
-#>   3   baseline                         500      50        5.88x
 ```
 
 ### Diagnostics
 
 Detect GC pressure and get optimization suggestions:
 
-```{r diagnostics, eval = FALSE}
+```{r diagnostics}
 # Detect GC pressure (indicates memory allocation issues)
 pv_print_gc_pressure(p)
-#> [!!!] GC consuming 35.0% of time (350 ms)
-#> High garbage collection overhead. Look for growing vectors,
-#> repeated data frame operations, or unnecessary copies.
 
 # Get actionable optimization suggestions
 pv_print_suggestions(p)
-#> === Priority 1 ===
-#>
-#> [hot line] R/analysis.R:42
-#>     Line 'result <- rbind(result, row)' consumes 25% of time.
-#>     Potential impact: 250 ms (25%)
 ```
 
 ### Export for AI Agents
 
 Export structured data for programmatic access:
 
-```{r export, eval = FALSE}
-# Export as JSON for AI agents or external tools
-json <- pv_to_json(p)
-
-# Include system info for reproducibility
-json <- pv_to_json(p, system_info = TRUE)
-
+```{r export}
 # Export as R list for programmatic access
 results <- pv_to_list(p)
-results$self_time      # Data frame of functions by self-time
-results$hot_lines      # Data frame of hot source lines
-results$suggestions    # Optimization suggestions
+names(results)
 
-# Export only specific analyses
-pv_to_json(p, include = c("self_time", "hot_lines", "gc_pressure"))
+# Data frame of functions by self-time
+results$self_time
 ```
 
 ## Available Functions