update vignette

Author: wlandau-lilly

vignettes/overview.Rmd

@@ -29,10 +29,6 @@ The [help guide](https://books.ropensci.org/targets/help.html) explains how to b
 
 The [debugging chapter](https://books.ropensci.org/targets/debugging.html) describes two alternative built-in systems for troubleshooting errors. The first system uses workspaces, which let you load a target's dependencies into you R session. This way is usually preferred, especially with large pipelines on computing clusters, but it still may require some manual work. The second system launches an interactive debugger while the pipeline is actually running, which may not be feasible in some situations, but can often help you reach the problem more quickly.
 
-## Performance
-
-<https://books.ropensci.org/targets/performance.html> explains how to monitor the progress of a running pipeline and optimize your pipeline for performance.
-
 ## Functions
 
 `targets` expects users to adopt a function-oriented style of programming. User-defined R functions are essential to express the complexities of data generation, analysis, and reporting. The [user manual](https://books.ropensci.org/targets/) has a [whole chapter](https://books.ropensci.org/targets/functions.html) dedicated to user-defined functions for data science, and it explains why they are important and how to use them in `targets`-powered pipelines.
@@ -49,20 +45,23 @@ The [packages chapter](https://books.ropensci.org/targets/packages.html) explain
 
 The [projects chapter](https://books.ropensci.org/targets/projects.html) explains best practices for working with `targets`-powered projects: the recommended file structure, recommended third-party tools, multi-project repositories, and interdependent projects.
 
-## Data: storage and memory
 
-This chapter describes how the targets package stores data, manages memory, allows you to customize the data processing model. When a target finishes running during `tar_make()`, it returns an R object. Those return values, along with descriptive metadata, are saved to persistent storage so your pipeline stays up to date even after you exit R. By default, this persistent storage is a special `_targets/` folder created in your working directory by `tar_make()`. However, you can also interact with files outside the data store and send target data to the cloud.
+## Data and files
+
+The chapter at <https://books.ropensci.org/targets/data.html> describes how the targets package stores data, manages memory, allows you to customize the data processing model. When a target finishes running during `tar_make()`, it returns an R object. Those return values, along with descriptive metadata, are saved to persistent storage so your pipeline stays up to date even after you exit R. By default, this persistent storage is a special `_targets/` folder created in your working directory by `tar_make()`. However, you can also interact with files outside the data store and send target data to the cloud.
 
 ## Literate programming
 
-Literate programming is the practice of mixing code and descriptive writing in order to execute and explain a data analysis simultaneously in the same document. The targets package supports literate programming through tight integration with R Markdown and knitr.
+The chapter at <https://books.ropensci.org/targets/literate-programming.html> covers literate programming: how to render an R Markdown or Quarto report as part of a `targets` pipeline. A report can depend on other targets and take advantage of long computation already completed upstream.
+
+## Distributed computing
 
-There are two kinds of literate programming in targets:
+`targets` is capable of distributing the computation in a pipeline across multiple cores of a laptop or multiple jobs on a computing cluster. The orchestration and scaling mechanisms are automatic, and only high-level configuration is required. Visit <https://books.ropensci.org/targets/crew.html> to learn more. Configuration happens through the `crew` package: <https://wlandau.github.io/crew/>. The appendix at <https://books.ropensci.org/targets/hpc.html> describes how to use `targets` with legacy backends `clustermq` and `future`.
 
-1. Rendering within a target. Here, you define a special kind of target that runs a lightweight R Markdown report which depends on upstream targets.
-2. Target Markdown, an overarching system in which one or more R Markdown files write the `_targets.R` file and encapsulate the pipeline.
+## Performance
+
+<https://books.ropensci.org/targets/performance.html> explains how to monitor the progress of a running pipeline and optimize your pipeline for performance. `targets` has easy-to-configure efficiency settings at the level of `tar_target()` and `tar_option_set()`.
 
-Visit <https://books.ropensci.org/targets/literate-programming.html> to learn more.
 
 ## Dynamic branching
 
@@ -71,11 +70,3 @@ Sometimes, a pipeline contains more targets than a user can comfortably type by
 ## Static branching
 
 [Static branching](https://books.ropensci.org/targets/static.html) is the act of defining a group of targets in bulk before the pipeline starts. Whereas dynamic branching uses last-minute dependency data to define the branches, static branching uses metaprogramming to modify the code of the pipeline up front. Whereas dynamic branching excels at creating a large number of very similar targets, static branching is most useful for smaller number of heterogeneous targets. Some users find it more convenient because they can use `tar_manifest()` and `tar_visnetwork()` to check the correctness of static branching before launching the pipeline. Read more about it in the [static branching chapter](https://books.ropensci.org/targets/static.html).
-
-## High-performance computing
-
-`targets` is capable of distributing the computation in a pipeline across multiple cores of a laptop or multiple nodes of a computing cluster. Not only does it interface with these technologies using packages [`clustermq`](https://github.com/mschubert/clustermq) and [`future`](https://github.com/HenrikBengtsson/future): it automatically deploys ready targets to parallel workers while making sure the other targets wait for their upstream dependencies to finish. Read more about high-performance computing in the [HPC chapter](https://books.ropensci.org/targets/hpc.html).
-
-## What about drake?
-
-The [`drake`](https://github.com/ropensci/drake) package is an older and more established R-focused pipeline toolkit, and it is the predecessor of `targets`. The [`drake` chapter](https://books.ropensci.org/targets/drake.html) of the `targets` manual helps `drake` users understand the role of `targets`, the future direction of `drake`, how to transition to `targets`, and the advantages of `targets` over `drake`.