Appendix A — Installing Languages, Quarto, and IDEs

Published

today

A.1 Installing Languages, Quarto and IDEs

The goal is to create the capability on one’s computer to conduct and communicate reproducible data analysis using modern, open-source, and current software tools R, RStudio and Quarto.

Learning Outcomes: After completion, students can create a functioning R or Python environment for literate programming by installing:

Base R
Python
The RStudio Integrated Development Environment (IDE)
The VSCode Integrated Development Environment (IDE)
The Positron Integrated Development Environment (IDE)
Select R “packages” of software

A.2 Install Base R

References:

RStudio IDE Cheat Sheet. (July 2025)
Quarto Guide

R is free open-source software capable of operating on most computers.

To install R, use your browser to go to the Comprehensive R Archive Network (CRAN) site: https://cran.r-project.org/
Choose the appropriate operating system.
- If asked, follow the instructions to “choose your preferred CRAN mirror”.
- Select a site close to your location, e.g., USA Hoobly Classifieds, Pittsburgh, PA, https://cran.mirrors.hoobly.com/
Download the latest version for your computer operating system (OS), e.g. R version 4.5.1 (2025-06-13) – “Great Square Root” (or higher).
- For Macs, download the install file and install as usual for a new application.
- If Windows, choose Base and download the file. For old systems you may need to follow the installation instructions.
You should now be able to find an R application with the logo on your computer.
- We will not use that interface (except for rare troubleshooting).
We will use Posit’s much more user-friendly and capable RStudio Desktop Integrated Development Environment (IDE). It is also free.

A.3 Install the Free RStudio Desktop

Posit’s RStudio Desktop is a free highly capable Integrated Development Environment (IDE) designed to greatly increase the ease and efficiency of programming in R.

Go to the RStudio download site at: https://posit.co/download/rstudio-desktop/
Click on Download RStudio Desktop .... It may auto-detect your type of computer.
- If asked, get the free desktop version (not the pro).
- Your version should be at least Version: 2025.05.1 Build 513 (May 2025) or higher.
Install as usual for your computer.
You should now see an Application for the RStudio IDE on your computer.
Add the RStudio Application to your Mac Dock or Windows Task Bar.

A.4 Accessing Quarto

Quarto is a multi-language capability from Posit for creating many types of documents, web sites, presentations etc.. Quarto has many new features and can handle older R Markdown (.Rmd) files.

See Tutorial: Hello, Quarto! and select the RStudio option.

Recent RStudio versions already include the Command Line Interface (CLI) version of Quarto so it should now be installed on your computer.

If for some reason you need to re-install Quarto, go to Quarto’s Get Started page or install the {quarto} package.

A.4.1 $\LaTeX$

$\LaTeX$ is a high-quality typesetting system designed for the production of technical and scientific documents that is used in many communities.

You will use $\LaTeX$ code to create mathematical formulas as required in the text portions of your files.

Quarto comes with the American Mathematical Society (AMS) version of $\LaTeX$.

For a full $\LaTeX$ install, see TeX Live and follow the instructions for your platform/operating system.

A.4.2 Install the R package for R Markdown

Quarto depends on the R Markdown language for describing how to format the output from your documents so you must install the R {rmarkdown} package.

The {rmarkdown} package is a bundle of software (think of it as an add-in or app) that adds the ability to use the R Markdown language to format your documents.

You can use RStudio to install the {rmarkdown} from CRAN.

Open RStudio by clicking on in your dock or task bar.
It should look something like this (with a newer version now):
Go to the RStudio Packages tab pane, select the Install tab, enter rmarkdown and select Install.
- This will generate the command in the Console pane to install the package.
You can install using the RStudio Console Pane.
The blinking cursor at the bottom left, to the right of the “greater-than” or “right arrow >, is called the prompt.
You can type in R code after the prompt and then hit the enter (return) to execute the code. - If you make a mistake, use the up-arrow key to cycle through previous commands until you get the one you want so you can correct it.
Type install.packages("rmarkdown") to the right of the cursor and then hit enter or return tell RStudio to execute the command.

Important

R is case-sensitive so be careful about spelling.
R is also sensitive about quotes so use the " or ' when required.
If you copy and paste from a document, e.g., a PDF document, into R, the copied code may use “Smart Quotes” which are not the same as the “Straight Quotes” used in R. If there is an error, you may need to edit the file and replace the smart quotes with straight quotes.

A.5 Check the R, RStudio, Quarto Software Installations.

Open RStudio.

You should see the version of R in the console pane.

You can create a new file using the New Files button or the File/New File on the top main menu.

Click on the plus sign and select Quarto document.
RStudio creates a new file with a few lines of default code with the extension .qmd and opens it as a tab in the Source pane.
- The Source pane is where you edit your documents (source code) files.
To convert your .qmd file to the specified output format, click on the Render button and it will start the conversion process.
- You will need to save the file to your computer - you can leave it as untitled.qmd
You should see some code scrolling by in the Background Jobs tab and then a rendered (converted) document should appear in the Viewer tab pane.

If the document appears, then your R, RStudio, Quarto, and RMarkdown are working!

If it does not appear, there should be error messages in the Console or Background Jobs panes and you can try re-installing the software.

A.5.1 Configure RStudio

RStudio is a powerful IDE so there are many options for configuring it to your needs.

Customizing the RStudio IDE

You can adjust your configuration using the Main menu item for Tools\ Global Options....

Suggest considering the following:

A.5.1.1 General: Basic Tab

R Sessions
- If this is the only course or work for which you are using R this semester, change the Default working directory to the directory on your computer you have created for this course. If you have not created a director, now is a good time to do so.
- Check Restore most recently opened project at startup.
Save Workspace
- By default RStudio will automatically save your workspace (a bunch of leftover stuff) when you exit it and restore it when you reopen.
  - This might streamline your work but it is bad for reproducibility as you might unintentionally be using the results from code you ran in a previous session (which you no longer can view and may not remember so you can’t reproduce).
- To change this option.
  - Uncheck Restore .RData into workspace at startup.
  - Change Save workspace to .RData on exit to Never.

A.5.1.2 Code: Editing Tab

Check (turn on) the following if not already on:
- Insert matching parens/quotes
- Use native pipe operator
Un-check (turn off) the following if already on:
- Soft-wrap R Source Files
Under Execution select Ctrl+Enter executes to be Multi-line R Statement

A.5.1.3 Code: Display Tab

Check (turn on) the following if not already on:
- Use Rainbow Parentheses

A.5.1.4 Appearance

Change Font Size to one you prefer. You can always adjust on the fly with CMD + or CMD - (or CTRL on Windows)

A.5.1.5 Pane Layout

You can adjust the panes and Pane tabs to support your coding preferences.
Some people prefer to have the source on the left and the Console on the right
Others prefer to have the Source on the Left and the Console on the bottom.
It is purely a personal choice and has no effect on how the IDE operates.

A.5.1.6 R Markdown

Basic Tab
- Check (turn on) the following if not already on:
- Soft-wrap R Markdown files
Advanced
- Check (turn on) the following if not already on:
- Use rainbow fenced divs
Visual: General
- Check Use visual editor by default for new documents if you like using the visual editor as your default.

Note

You can adjust your configuration at any time although you may need to restart RStudio for the new configuration to take effect.

A.5.2 RStudio Projects

RStudio Projects are a wonderful feature of the RStudio IDE to simplify organizing and working with multiple files in a defined piece of work, e.g., the data and source code files for a homework assignment.

An RStudio Project consists of the chosen project folder (directory) on your computer and all of the folders underneath it in the directory tree structure.

Tip

When you create a Homework folder, turn it into an RStudio project.

When you open an RStudio Project, RStudio will automatically set up your console working directory, your files pane working directory, and your terminal pane prompt to be the folder of the RStudio project.

If you are working with a Git Repository, RStudio Projects should align with the repository and can help you do common Git and GitHub functions using the Git Pane.

You can create new projects or turn an existing directory into a project using RStudio.

See RStudio Projects for more help on creating and using RStudio Projects for more efficient operation with R.

A.5.3 Conclusion

You should now be able to install the software you need to:
- Start an RStudio session by clicking on .
- Use RStudio to create and save a Quarto file to a folder on your computer.
- Use RStudio to render/convert your file to PDF or HTML formatted output document in a folder on your computer.

A.6 Python has Multiple Choices for Installation

Configuring your computer to work with R is fairly straightforward.

Download R from the [Comprehensive R Network (CRAN)])(https://cran.r-project.org/) , the organization which manages the software for “base R”.
Download Posit’s RStudio Desktop. You can use a command line interface for R or use other Integrated Development Environments (IDEs), e.g., VS Code or Jupyter, but RStudio is the IDE of choice for most data scientists working on R-centric solutions.
Install whatever packages you want from CRAN or other sources, e.g., GitHub or Bioconductor. R is designed to minimize conflicts between packages and tells you when there is conflict. It also incorporates methods for handling conflicts.
Open up RStudio and get to work.

Installing Python is a different experience as there are more choices.

Python is a more general purpose software langage than R and is widely used across a spectrum of needs (including data science).
To meet this diverse needs Python offers multiple installation methods and package management systems.
Understanding these options will help you create a stable, efficient environment for your data science work.

A.6.1 Python Installation Options: Standard Python vs Anaconda

Option 1: Standard Python (“Vanilla” Python)

Installed directly from python.org.
Comes withpip, the default package manager.
Requires manual setup of virtual environments (venv or virtualenv) to avoid conflicts between packages.
Lightweight and flexible, allowing full control over package management.

Option 2: Anaconda

The full Anaconda version installs Python and 300 packages commonly used in Data Science work.
Includes conda, an alternative package manager (to pip) that includes capabilities to simplify dependency management across packages.
The graphical installer includes other elements such as Jupyter Labs, a browser-based IDE.
The “Mini-conda” version installs python and a small number of packages to provide a smaller install.

For our class, Anaconda (or mini-conda) is the preferred choice because it simplifies package installation,reduces dependency compatibility issues, and reduces reproducibility or portability issues.

A.6.2 Choosing an IDE for Python: JupyterLab vs. VS Code

As a data scientist or Python developer, selecting the right IDE is crucial for an efficient workflow. Two of the most popular choices are JupyterLab and VS Code, each offering unique strengths. Note: the IDE does not affect what code your write but how you write, debug, and use version control your code.

JupyterLab: Good for Interactive Computing and Notebooks

JupyterLab is an interactive development environment designed for interactive Jupyter Notebooks for quick experimentation, visualization, and documentation, all in one place.

Key Features
- ✅ Native Jupyter Notebook Support: Best for exploratory data analysis and iterative workflows.
- ✅ Quarto Integration: Easily create interactive reports and export to formats like HTML, PDF, and Word.
- ✅ Interactive Development: Run code cell by cell and immediately see outputs.
- ✅ Rich Visualization Support: Works seamlessly with matplotlib, seaborn, plotly, etc.
Advanced Debugging in JupyterLab
- Basic debugging support using xeus-python, allowing variable inspection and breakpoints.
- Limitations: Debugging is less sophisticated than in VS Code.
Git and GitHub with JupyterLab
- 📌 Basic Git Integration – Install the JupyterLab Git extension to manage repositories visually.
- 📌 Manual Workflow – Without the extension, Git must be used via the terminal (git add, git commit, git push).
- 📌 Versioning Notebooks – Jupyter Notebooks store output inside .ipynb files, which makes them difficult to track in Git. Best practice: use nbdime (Jupyter Notebook Diff and Merge tool) to handle differences.
- 📌 Collaborative Work – GitHub handles versioning, but resolving merge conflicts in notebooks can be challenging.

VS Code Integrated Development Environment (ODE): for Hybrid Workflows (Notebooks + Scripts + Debugging)

VS Code is a lightweight yet powerful IDE with support for Python scripting, interactive notebooks, and Quarto. It is widely used for software development, debugging, and data science.

Key Features
- ✅ Supports Both Python Scripts & Jupyter Notebooks – Run .py and .ipynb files within the same environment.
- ✅ Quarto Integration – Edit, preview, and render .qmd documents inside VS Code.
- ✅ Advanced Debugging – Full debugging support with breakpoints, call stacks, and variable inspection.
- ✅ IntelliSense & Code Navigation – Powerful autocompletion and refactoring tools.
- ✅ Integrated Terminal & Git Support – Manage repositories directly within the IDE.
Advanced Debugging in VS Code
- Breakpoints & Step-through Debugging – More advanced than JupyterLab.
- Variable Explorer – Inspect variables while debugging.
- Notebook Debugging – Debug Jupyter notebooks with a similar experience to scripts.
Git and GitHub with VS Code
- 📌 Built-in Git Support – View changes, commit, push, and pull without using the terminal.
- 📌 Better Conflict Resolution – VS Code provides diff tools to compare and merge conflicting changes.
- 📌 Versioning Notebooks – Displays notebook diffs more clearly than GitHub alone.
- 📌 Collaborative Work – GitHub integration makes it easier to collaborate, review code, and manage projects.

A.6.3 Managing Environments and Packages

Both R and Python have multiple standardized repositories of diverse packages and both languages support using “environments” to manage the set of packages (and their versions) being used for a given project.

CRAN has over 22,000 packages for R.
The Python Package Index (pypi.org) is one example of a repository of open source software for the Python programming language.

One can do a lot of work in R without worrying about managing the computing environment other than updating versions of R and the packages on a regular basis.

However, when you want to ensure you are controlling the environment for a project to ensure shared reproducibility over time, you can use the {renv} package.
The renv package helps you create reproducible environments for your R projects.
The {renv} workflow uses a YAML lock.file that is version controlled to allow one to share the environment configuration so other users can create an identical R environment.

Python best practices (and IDEs) are more explicit/insistent about creating “virtual environments” as part of every project. See the Python Packaging User Guide for details about the Python package life cycle.

Virtual environments allow you to install Python packages in an isolated location for a particular project without disrupting the base python install.

When starting a new project, you create an environment for the project.

The environment has its own installation directories (like {renv} for R) and it does not share libraries with other virtual environments.
You then install just the packages you need for that environment.

Your choice of How to install packages depends upon which version of python you installed (Section A.6.1).

A.6.3.1 Standard Python uses `venv` andpip` to manage environments and packages

The venv module creates lightweight “virtual environments”, each with their own independent set of Python packages installed in their site directories.

A virtual environment is created on top of an existing Python installation, known as the virtual environment’s “base” Python.
When used from within a virtual environment, common installation tools such as pip will install Python packages into a virtual environment without needing to be told to do so explicitly.
pip is the default package installer for python

A.6.3.2 Anaconda uses `conda` to manage environments and packages

Anaconda comes with the conda environment and package manager.

Conda environment mangement allows you to use the terminal to:

Create an environment you might call ‘myenv’ with its own version of Python and/or packages with conda create --name <my-env>.
Update your myenv environment with conda env update --file environment.yml --prune.
List the available environments with conda env list.
Remove the my-env environment with conda remove --name myenv --all.
Activate your my-env environment with conda activate myenv so you can install packages and work in it.
- By default, conda activate will deactivate the current environment before activating the new environment and reactivate it when deactivating the new environment.
- By default, the active environment —the one you are currently using— is shown in parentheses () or brackets [] at the beginning of your command prompt: (myenv) $.
Deactivate the current active environment with conda deactivate.
- By default, it will return you to the previous environment.
- A better way to get to the base environment is with just conda activate with no name.
Export and share a YAML environment.yml file describing the environment.
Create an environment from an environment.yml file.

Conda package management allows you to:

Search for packages with conda search scipy.
Install packages such as scipy into your environment myenv with conda install --name myenv scipy.
Update packages or python with conda update packagename.
Remove a package with conda remove packagename.

Note

Use conda to install as many packages as you can but if a package is not available under conda, you can use pip.

See Conda: Using pip in an environment for details.

See Conda Cheatsheet to download a cheatsheet.

A.7 Install VSCode

Go to Download Visual Studio Code and follow the instructions for your operating system and chip set.

A.8 Install and Configure Python

Note

This section covers creating a capability with VSCode, the full anaconda distribution, Quarto, and the ability to use Git and GitHub.

Go to Installing Anaconda Distribution and follow the instructions for your operating system.
Go to Quarto Get Started and follow the instructions to download the Quarto Command Line interface.
Go to Git Downloads and follow the instructions for your operating system.
If you do not have a GitHub account, go to GitHub and sign up for a free account.

Open VSCode

Go to the extensions panel.
Install the Python extension for Visual Studio Code.
Install the Quarto Extension.

See the Quarto Guide for VSCode.

Install the Github Pull Requests and Issues Extension

Check your GitHub configuration with git config --global --list
To if missing or you need to update your name and email, use:
- git config --global user.name "Your Name"
- `git config –global user.email “your-email@example.com”``
If you have already set up Git to Authenticate with GitHub you should be ready.
For more details see Working with GitHub in VS Code

A.8.1 Checking Your Configuration

Go to a terminal window.

Verify Visual Studio Code Installation

Open VS Code and confirm it launches successfully.
Check the version in the terminal with code --version. It should match what you see in the main menu Code About VIsual Studio Code - at least 1.103.0

Go the VSCode extensions pane and ensure the extensions show as installed.
Verify Anaconda Installation

Check the version in the terminal with conda --version.
If it returns a version (e.g., conda 24.11.3), Anaconda is installed.

Check Conda environments work by listing them.

Go to the terminal and enter conda env list.
You should see at least a base environment.

Try creating and activating a test environment:

conda create --name test-env python. Say Y to execute.
conda activate test-env. You prompt should change to show the test-env.
Run which python. You should see the version used in the create command.

Verify Quarto

Run quarto --version. You should get a version as the result.
Run quarto check to verify the installation.

Verify Git with git --version. You should get a version.
Check GitHub authentication with gh auth status.
Verify GitHub Integration with VS Code.

Open VS Code and check that Git is detected:
- Go to the Source Control view (Ctrl+Shift+G or Cmd+Shift+G).
- If Git is installed, you should see options to initialize a repository or clone an existing one.
- If Git is not detected, ensure it is installed and configured correctly.

Activate the base environment with conda activate. The prompt should change to the base.
Remove the test-env environment with conda remove --name test-env --all.

If everything worked you are now ready to go to your projects.

A.9 The Positron IDE

Positron is a free, next-generation IDE built by Posit PBC to support “code-first” Data Science work.

Positron supports both R and Python (and many other languages) through the use of multiple “languages.”interpreters.”
- Unlike RStudio, which is tightly integrated with the R software process, Positron is a completely new architecture that treats R as one of the many possible runtime processes.
It is built on the same non-proprietary open source code (“Code - OSS”)) as Microsoft’s Visual Studio Code (VSCode) so has similar look and feel without the Microsoft proprietary pieces.
As you might expect, it has support for Quarto and built-in support for Python interpreters managed by the R {reticulate} package.
You will have to install the languages you want to use such as R and Python separately as ususal, but Positron allows you to learn one IDE instead of two.

References:

A.10 Install Positron

It’s easy. Go to the Positron Getting Started, download and install.

A.11 Switching to Positron from RStudio?

RStudio is well-known, well-supported and has extensive documentation. If you only work in R, you may not be interested in switching yet until it is more mature and the additional features justify the switch. RStudio is not going away any time soon.

If you split your time between R and Python, especially if you use VSCode for python, You may want to try it so you have one multiple language IDE instead of two.

The following tables provide some more ideas for consideration.

Specific Features of Positron versus RStudio.

Feature / Capability	Positron (New / Improved)	RStudio (Current)	Impact for Users
Data Editor	Spreadsheet-like, interactive editor for R & Python data frames; live editing updates objects in memory.	Basic R data viewer; read-only, no in-place editing.	Faster data cleaning and exploration without round trips or workarounds.
Cross-Language Support	Native multi-language (R, Python, Julia, SQL, etc.) without special packages like `reticulate`.	Primarily R-focused; Python via `reticulate`; no Julia or multi-runtime support.	Seamlessly combine languages in one project; better polyglot workflows.
Notebook-Style Cells	Inline execution cells with outputs embedded directly; supports mixed-language cells.	R Markdown/Quarto chunks; less interactive and less flexible.	More natural exploratory coding; faster iteration with visible results.
Debugging Tools	Visual debugger with breakpoints, step-through, call stack, and variable inspection for multiple languages.	Limited R debugging (via `browser()`); no GUI debugger for Python or Julia.	Easier bug tracking and fixing with intuitive, GUI-driven debugging.
VS Code Extensions	Full access to VS Code marketplace: themes, linters, AI tools, Git integrations, etc.	Only R addins; smaller ecosystem.	Extend IDE functionality far beyond RStudio’s native capabilities.
Multi-Tab / Split Editing	Multiple split views, drag-and-drop tabs, modern file navigation.	Basic tab support; limited split views.	Improved multitasking and context switching for complex projects.
Unified Variable Explorer	Works across languages; filter, sort, inspect large datasets interactively.	Environment pane only for R objects.	Better insight into all project variables; useful for polyglot data science.
Search & Navigation	Fuzzy search for files, symbols, variables across all languages in workspace.	Mostly limited to R files/functions.	Faster code navigation and productivity in multi-language projects.
Git & GitHub Integration	Rich Git UI with branch management, merge tools, GitHub authentication.	Simpler Git integration with fewer visual tools.	Smoother version control and collaboration workflow.
Cross-Platform Consistency	Identical UI and shortcuts on macOS, Windows, Linux.	Mostly consistent but some platform differences.	Same experience on any OS, reducing context switching costs.

Considerations for Switching

Feature / Aspect	RStudio (Current)	Positron (Early Release)	Why Switch Now	Why Wait
Maturity & Stability	Battle-tested, stable, production-ready for R users.	Still in active development; some features incomplete or missing.	Early adopter advantage; help shape the product with feedback.	Mission-critical work may be disrupted by bugs or missing features.
Primary Language Focus	R-centric with limited Python support via reticulate.	Multi-language (R, Python, Julia, SQL, etc.) via LSP and runtime integration.	Ideal if you already work in both R and Python or Julia.	If you work only in R and don’t need other languages, RStudio is more polished for that workflow.
Underlying Technology	C++ & Qt; custom integration with R.	Electron + React; uses VS Code extension system.	Access to VS Code extensions ecosystem and modern editor features.	Electron apps can be heavier on memory/CPU; some users prefer RStudio’s native feel.
Extensibility	R addins (R packages that integrate with the IDE).	Any VS Code extension; broader community plugins.	Instant access to thousands of VS Code extensions (themes, linters, AI tools, etc.).	If you rely heavily on R-specific addins, not all are available yet in Positron.
Interactive Execution Model	One persistent R session; console-centric.	Multiple runtimes; supports notebook-style execution and interactive cells.	More flexible multi-language workflows in a single project.	If you like the traditional single-console R workflow, Positron’s approach may feel unfamiliar.
Language Intelligence	Built-in for R; limited for other languages.	Language Server Protocol (LSP) for R, Python, Julia, etc.	Consistent autocompletion, linting, and doc lookup across languages.	LSP-based R support is newer; may lack some deep RStudio integrations (e.g., special object viewers).
Data Science Focus	Deep R integration: environment pane, data viewer, plot history, knit/Quarto UI.	Broad DS integration: multi-language data viewers, VS Code-style notebooks, Quarto support.	Single environment for all data science languages.	Some specialized RStudio tools (e.g., certain knit/Quarto panels) may be missing or less polished.
Performance	Lightweight compared to Electron apps.	Heavier footprint (Electron) but benefits from modern editor tech.	Gain VS Code-level editing features, multi-tab workspaces.	If your machine is older or resource-limited, RStudio may feel snappier.
Community & Ecosystem	Long-established R community; many tutorials/docs are RStudio-specific.	New community, but benefits from VS Code’s huge ecosystem.	Tap into VS Code’s ecosystem and broader developer tools.	Learning curve if you’re used to RStudio-only resources and shortcuts.
Upgrade Path	Stable and maintained; Positron is not a direct upgrade but a new product.	Continues to evolve rapidly; frequent updates in preview phase.	Opportunity to adopt a tool that will likely replace or complement RStudio in the future.	Waiting ensures more complete feature parity with RStudio before switching.

If you switch to Positron, there will be a learning curve. Review the Guide and consider the following:

Recommended Extensions for RStudio Users Switching to Positron

R Language Support: Extension: REditorSupport.r
- Adds syntax highlighting, code snippets, workspace viewer, and R console integration.
R LSP Client: Extension: REditorSupport.r-lsp
- Provides enhanced code completion, linting, diagnostics, and go-to-definition.
Quarto: Extension: quarto.quarto
- Supports authoring and preview of Quarto documents (.qmd), similar to R Markdown in RStudio.
Python (if applicable): Extension: ms-python.python
- Essential for linting, debugging, and Jupyter support when using Python alongside R.
GitLens — Git supercharged: Extension: eamodio.gitlens
- Advanced Git integration with blame, history, and rich UI beyond default Git support.
Data Viewer / Editor: Extension: RandomFractalsInc.vscode-data-preview
- Interactive data viewer for CSVs and JSON files; complements Positron’s built-in data editor.

Recommended Configuration Adjustments

Bracket Pair Colorizer / Auto-close: Helps with reading and writing nested code blocks.
Markdown Preview Enhanced: Supports advanced markdown rendering, helpful for .md and .Rmd previews.
Code Spell Checker: Catches typos in comments and documentation.
Settings Sync : Syncs your VS Code/Positron settings and extensions across multiple machines.

A sample settings.json file

{
{
  // --- R settings ---
  "r.rterm.mac": "/usr/local/bin/R",               // Adjust this path to your R installation
  "r.rterm.option": ["--no-save", "--no-restore"],
  "r.lsp.debug": false,
  "[r]": {
    "editor.formatOnSave": true,
    "editor.defaultFormatter": "REditorSupport.r-lsp"
  },

  // --- Python support (if applicable) ---
  "[python]": {
    "editor.formatOnSave": true,
    "editor.defaultFormatter": "ms-python.black-formatter"
  },

  // --- Quarto support ---
  "quarto.enableLint": true,
  "quarto.previewTheme": "light",

  // --- Git integration ---
  "git.enableSmartCommit": true,
  "git.autofetch": true,

  // --- Terminal config: use login shell for consistent environment ---
  "terminal.integrated.profiles.osx": {
    "zsh (login)": {
      "path": "/bin/zsh",
      "args": ["-l"]
    }
  },
  "terminal.integrated.defaultProfile.osx": "zsh (login)",

  // --- Data viewer ---
  "dataPreview.defaultSeparator": ",",

  // --- Editor tweaks ---
  "editor.tabSize": 2,
  "editor.wordWrap": "on",
  "editor.minimap.enabled": false,
  "editor.formatOnType": true,

  // --- File explorer ---
  "explorer.openEditors.visible": 0,

  // --- Save behavior ---
  "files.autoSave": "onFocusChange",

  // --- R Workspace viewer (via R extension) ---
  "r.workspaceViewer.enabled": true
}

A.1 Installing Languages, Quarto and IDEs

A.2 Install Base R

A.3 Install the Free RStudio Desktop

A.4 Accessing Quarto

A.4.1 \(\LaTeX\)

A.4.2 Install the R package for R Markdown

A.5 Check the R, RStudio, Quarto Software Installations.

A.5.1 Configure RStudio

A.5.1.1 General: Basic Tab

A.5.1.2 Code: Editing Tab

A.5.1.3 Code: Display Tab

A.5.1.4 Appearance

A.5.1.5 Pane Layout

A.5.1.6 R Markdown

A.5.2 RStudio Projects

A.5.3 Conclusion

A.6 Python has Multiple Choices for Installation

A.6.1 Python Installation Options: Standard Python vs Anaconda

A.6.2 Choosing an IDE for Python: JupyterLab vs. VS Code

A.6.3 Managing Environments and Packages

A.6.3.1 Standard Python uses venv andpip` to manage environments and packages

A.6.3.2 Anaconda uses conda to manage environments and packages

A.7 Install VSCode

A.8 Install and Configure Python

A.8.1 Checking Your Configuration

A.9 The Positron IDE

A.10 Install Positron

A.11 Switching to Positron from RStudio?

A.6.3.1 Standard Python uses `venv` andpip` to manage environments and packages

A.6.3.2 Anaconda uses `conda` to manage environments and packages