Architect – Documentation

Documentation: Defining R Snippets

Mon, 01 Jan 0001 00:00:00 +0000

R Snippets are chunks of R code that you can assign to a keyboard shortcut. Architect ships with some default, simple snippets, but you can define customized snippets to perform far more complex tasks.

Access the snippets menu by typing ‘R Code Snippets’ into the Quick Search bar (Ctrl + 3), or navigate to it via the menus by selecting Window > Preferences > StatET > Run/Debug > R Code Snippets.

The above snippet allows you to switch the working directory of your active console at the push of a button. But to do so, we must first associate a key binding to the command. If you click the Keys button at the bottom of the R Code Snippets window, you’ll reach a menu for customizing keyboard shortcuts.

Find the desired snippet, then assign your command. Above, we assigned the command Ctrl + r, Ctrl + w to the change working directory snippet. This allows us to click on a folder in our Project Explorer, enter the chosen command, and our active console will change its working directory to that folder.

Documentation: Debugging

Mon, 01 Jan 0001 00:00:00 +0000

Architect has an advanced tool for visual debugging. In this exercise, we’ll use the following code to demonstrate the debugging functionality:

myFun <- function(x){
  y <- x + 2
  z <- y - 3
  myOtherFun(z)
}

myOtherFun <- function(x) {
  m <- matrix(diag(x), ncol = 2)
  colnames(m) <- c("A", "B")
  return(m)
}

data(cars)

 # myFun(6)

Launch via debugger icon

The visual debugger can only be used within an R session launched by the Debugger icon () in the top toolbar. Click on the icon and select the R version you’d like to use.

Set a breakpoint

Visual debugging works with the concept of breakpoints. By setting a breakpoint, you instruct Architect to pause the evaluation of code at a given line. This allows you to quickly get under the hood of complex chunks of code and inspect the values of variables.

To set a breakpoint, double click in the “gutter” on the line where you’d like evaluation to be paused.

You can set multiple breakpoints in the same script.

Now, when we run code, evaluation will be paused when either breakpoint is reached.

Source the script

The last preparatory step is to source the script you intend to debug. Source the script by typing Ctrl+r, Ctrl+s. Our breakpoints will update visually with a check mark to show we are ready to debug:

Run code

With our breakpoints set, we run the code by calling:

myFun(6)

When a breakpoint is reached, the debug perspective launches automatically.

Note that you can toggle to your previous perspective with the toggler in the top-right corner ().

Inside of the debugging view, we have access to debug-specific commands:

(F5): execute the current line and move to the next line. If the current line contains a function call, the debugger will step inside of that function.
(F6): execute the current line of code and move to the next, without stepping into any called functions
(F7): steps out of the currently executed function and returns to that function’s caller
(F8): resume code evaluation until the next breakpoint

Conditional Breakpoints

Suppose we would like a breakpoint to trigger only if a certain condition is met. In a trivial example, say we have a loop that will run 10 times, but we only want the breakpoint to trigger on the ninth iteration.

We can set such a condition in the breakpoint window.

Debugging Installed Packages

If you’ve installed a package in Architect via R CMD INSTALL, you can debug it by placing a breakpoint within a function and calling that function.

Documentation: Installation

Mon, 01 Jan 0001 00:00:00 +0000

The latest versions of Architect are available on our downloads page. Architect is available for Windows, Mac and Linux.

Windows

Stable release

On the download site, click on the “Architect for 64-bit Windows” link. Your download will start automatically.

Once the download is complete, click on the .exe file to start installation.

If asked “Do you want to allow the following program from an unknown publisher to make changes to this computer?”, click Yes.

The Architect Setup Wizard will then launch.

Click Next. On the following screen, choose the folder where you would like to install Architect.

Click Install, and installation will proceed automatically. Once installation has concluded, click Finish to close the installer.

Snapshot release

Snapshot releases for Windows are made available on our Nexus repository. The installation procedure is identical as for the stable release.

Mac

Stable release

On the download site, click on the Architect for Mac OS X link. Your download will start automatically.

Once the download is complete, click on the .pkg file to start installation.

Control-click the Architect app icon, then choose Open from the shortcut menu.

If a popup with “architect 1.0.0.pkg” cannot be opened because it is from an unidentified developer.", then just click ok and try opening the .pkg file again.

After a couple tries the next popup will appear “macOS cannot verify the developer of architect 1.0.0.pkg. Are you sure you want to open it?”. When this popup appears just click “Open”.

After clicking “Open” just follow the installation wizard until the message “The installation was successful” appears.

During the actual installation step you might be asked to provide you password or to you use the “Touch ID” (if available) to finish the “Architect” installation.

After the installation has successfully finished, close the wizard and the “Architect” application will be available in you “Applications” folder.

Snapshot release

Snapshot releases for Mac are made available on our Nexus repository. The installation procedure is identical as for the stable release.

Linux

Installation from repositories

The easiest way to install Architect on Ubuntu is to use our package repository. Follow the instructions for your version of Ubuntu.

Bionic (Ubuntu 18.04)

Stable release

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/bionic/ bionic main'
sudo apt install architect

Snapshot release

Note: this repository provides development versions of Architect, use with care.

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/bionic-snapshot/ bionic main'
sudo apt install architect

Focal (Ubuntu 20.04)

Stable release

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/focal/ focal main'
sudo apt install architect

Snapshot release

Note: this repository provides development versions of Architect, use with care.

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/focal-snapshot/ focal main'
sudo apt install architect

Jammy (Ubuntu 22.04)

Stable release

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/jammy/ jammy main'
sudo apt install architect

Snapshot release

Note: this repository provides development versions of Architect, use with care.

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/jammy-snapshot/ jammy main'
sudo apt install architect

Manual installation

Alternatively, .deb and .rpm package files are available for Architect on our downloads page.

Ubuntu

Download the .deb file, then type in the terminal:

dpkg -i XXX.deb

where ‘XXX.deb’ is the name of the downloaded .deb file.

You can also double-click the .deb file to open Ubuntu Software Center. Click Install and enter your password if prompted:

CentOS

Download the .rpm file, then type in the terminal:

rpm -i XXX.rpm

where ‘XXX.rpm’ is the name of the downloaded .rpm file.

Documentation: Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Architect Server allows you to launch and connect to R sessions that are running on a remote server, straight from Architect. Once connected to a remote R session, users have seamless access to all the Architect’s local features, such as integrated data visualization tools and streamlined code evaluation.

Documentation: Git Repositories

Mon, 01 Jan 0001 00:00:00 +0000

You can link a directory to a git repository through the “Git Repository” window. Access this window by quick searching ‘git repository’, or through the main menus via Window > Show View > Other > Git > Git Repositories.

This window gives controls for adding, cloning and creating git repositories.

: add an existing local Git repository
: clone a Git repository
: create a new local Git repository

Once you have a local folder associated with a git repository, create a project in that folder, as demonstrated in the Your First Project section.

Git actions can then be performed by right-clicking a project and accessing the Team menu. All Git repository interactions are powered by the Eclipse EGit plugin. Click here for a comprehensive EGit user guide.

Documentation: Installation

Mon, 01 Jan 0001 00:00:00 +0000

Installation from repositories

The easiest way to install Architect Server on Ubuntu is to use our package repository. Follow the instructions for your version of Ubuntu.

Bionic (Ubuntu 18.04)

Stable release

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/bionic/ bionic main'
sudo apt install architect-server

Snapshot release

Note: this repository provides development versions of Architect, use with care.

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/bionic-snapshot/ bionic main'
sudo apt install architect-server

Focal (Ubuntu 20.04)

Stable release

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/focal/ focal main'
sudo apt install architect-server

Snapshot release

Note: this repository provides development versions of Architect, use with care.

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/focal-snapshot/ focal main'
sudo apt install architect-server

Jammy (Ubuntu 22.04)

Stable release

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/jammy/ jammy main'
sudo apt install architect-server

Snapshot release

Note: this repository provides development versions of Architect, use with care.

sudo apt update
sudo apt install gpg apt-transport-https ca-certificates wget software-properties-common
wget -qO - https://getarchitect.io/repo-key.gpg | sudo apt-key add -
sudo add-apt-repository 'deb [arch=amd64] https://apt.getarchitect.io/jammy-snapshot/ jammy main'
sudo apt install architect-server

Manual installation

Alternatively, .deb and .rpm package files are available for Architect Server on our downloads page.

Ubuntu

Download the .deb file, then type in the terminal:

dpkg -i XXX.deb

where ‘XXX.deb’ is the name of the downloaded .deb file.

CentOS

Download the .rpm file, then type in the terminal:

rpm -i XXX.rpm

where ‘XXX.rpm’ is the name of the downloaded .rpm file.

Documentation: Your First Project

Mon, 01 Jan 0001 00:00:00 +0000

Your first look at Architect is a fairly blank canvas.

For the uninitiated, this can seem a little disorienting. We’ll walk you through the steps of getting your first project up and running.

Using Project Explorer to Create a Project

The Project Explorer is the directory of all your defined Architect projects. Projects are home to various files, and most commonly will contain things like folders, R scripts and data files.

To create a new project, simply right-click inside the Project Explorer and select New > Project. This may also be done via the main menu with File > New > Project.

Architect can be used to develop projects in various programming languages. To create an R project, use the settings below.

By default, a new project will be created inside of your workspace (in Windows, this is a directory like C:/Users/Username/.architect/workspace). It’s easy, however, to override this default and link to existing directories on your computer.

Projects in Other Directories

To create a project that points to an existing directory, uncheck the Use default location box and click Browse to navigate to the desired folder. This is particularly useful for projects based on a git repository.

For now, we’ll use the default location, name our first project and click Finish.

Scripts and the Console

We’ll now populate our first project. Create an R script in a given folder by right-clicking the folder and selecting New > R Script File. You may also paste files from your clipboard.

Launching a Console in a Directory

R code is run in a view called the Console. An R console launches automatically when you open Architect.

We cover the functionaly of these many buttons in a later section, but for now we direct our attention to the top-right corner. The console lists our current working directory as ‘C:\Program Files\Architect_0.9.1’, but you’ll likely want your code to be evaluated elsewhere. Although you can change the working directory with a setwd() call, often it’s easiest to select a folder from the Project Explorer and launch a fresh R Console from there.

To do so, simply click on the desired folder, then click the green ‘play’ button in the top toolbar.

This launches a fresh console in the selected directory.

Running Code in the Console

With a console open in our ‘myFirstProject’ directory, we’re ready to run a basic script.

head(cars)

dir.create("data")
?write.csv
write.csv(file = "./data/carsData.csv", cars)

plot(cars$speed, cars$dist)

There are several ways to run code within Architect. Most commonly, users use customizable keyboard shortcuts. By default, the command Ctrl+R, Ctrl+R will fun a selection of code in the console. A list of commonly used default keyboard shortcuts are given in the Architect Reference Card. To customize these inputs, please refer to the section Customizing Keyboard Shortcuts.

Alternatively, it is possible to simply copy and paste a selection of R code directly into the console. Highlighting and right-clicking code in a script also presents options for evaluating code.

After running the above section of code, your Architect session will look something like this:

We’ll notice that as certain lines of code were evaluated, Architect automatically opened relevant views. The above code prompted the opening of the R Help and R Graphics views. This is very useful, but we immediately see some issues. The R Help view is quite small, our graph isn’t properly scaled to the window, and at the moment, we don’t even need the Outline view.

In the next section, we’ll cover how to fully customize your Architect layout, and save presets so you can easily switch between your configurations (especially useful when switching from a single monitor to dual monitor setup).

Documentation: Configuration

Mon, 01 Jan 0001 00:00:00 +0000

Architect server installs a configuration file under /etc/architect-server/architect-server.properties.

There is currently a single property that can be set in the file, namely the port of the RMI registry that is used by architect-server:

port=1099

The default value is: port=1099. If you edit this value, please restart architect-server using

sudo service architect-server restart

for the change to have effect.

Documentation: Installing Different Versions of R

Mon, 01 Jan 0001 00:00:00 +0000

Architect ships with an embedded, recent version of R. To configure another version for use within Architect, use the following steps:

Install the desired version of R.
Open the newly installed version of R and install packages rj and rj.gd.

install.packages(c("rj", "rj.gd"), repos="https://download.walware.de/rj-4.0")

In Architect, select from the main menu Run > Run Configurations, and navigate to the R Console section. From there, click the button New launch configuration.
Click on the Configure... button in the R Config tab.

Click Add... to add the new R installation.

Name your installation (e.g. R 3.4.0), then in the Location (R_HOME) field, navigate to the installed R folder.

Click the button titled Detect Default Properties/Settings (see above). Then click OK. Your R environments should now look something like this:

Click Apply.
On the Run Configurations screen, R Config tab, choose the new configuration (e.g. R 3.4.0) for the Selected Configuration field, and click Apply.

In order to make your configuration selectable from the Run and Debug dropdown menus, check the checkboxes of the Display in favorites menu section of the Common tab, as seen below.

You may now run the new R configuration by selecting it via the triangle next to the button in the top menu.

Documentation: The Interface

Mon, 01 Jan 0001 00:00:00 +0000

Customizing View and Saving Perspectives

Customizing Architect’s interface is easy. This section presents several ways to configure the layout to your liking.

Dragging Borders

Windows within Architect can be resized by clicking on the grey borders between views and dragging them to the desired location.

Rearranging Views

To split or merge different views, click, drag and drop! An existing window can be further split horizontally or vertically.

Popping Out Views

Views can also be popped out of Architect entirely. This is particularly useful when customizing for a dual-monitor setup.

Minimizing and Maximizing

Groups of views can be minimized and maximized with single clicks. Below, we minimize the Object Browser and R Help views. A side pane for these minimized views is then created on the left-hand side.

Saving and Switching Perspectives

Once you’ve customized the layout to your liking, you can save your layout as a ‘Perspective’. In this way, you can quickly switch between your custom perspectives, depending on the type of work you’re doing or how many monitors you have on hand.

Project Explorer

The number of projects you have can grow quite large, and Architect provides tools to help you manage the chaos.

Linking Scripts and Project Explorer

To help avoid excessive scrolling through the Project Explorer, or confusion over similarly named files, Architect allows you to link your scripts with the Project Explorer.

By toggling the button in the Project Explorer view, open scripts will show their corresponding folder in the Project Explorer when clicked on. Notice how the script highlighted in the Project Explorer changes as we click on different scripts in the script window.

This feature helps keep your different ‘DESCRIPTION’ and ‘server.R’ files sorted when developing multiple R Packages or Shiny applications.

Defining and Selecting Working Sets

As the number of projects grows larger, it may not be desirable to have all of your projects displayed at once. Working Sets are subsets of projects that you can define and switch between.

In our hypothetical example, we have four projects, and want to define two of them as school projects. If we assign them to a working set, we will see only those two projects while hiding the others.

Here we add the ’epidemiology’ and ‘regressionAnalysis’ projects to the ‘school’ working set. When we select this working set, only these projects are displayed in the Project Explorer.

To see all projects again, click the carrot in the Project Explorer view and choose Deselect Working Set.

Console

The Console is your window for processing all R commands. Previously we discussed different methods of evaluating code in the console. In this section, we’ll take a closer look at some of the console view functionalities.

Restarting, Cancelling, Terminating

There is a toolbar at the top of the console. The leftmost buttons are for used to interact with a current running console.

: restart console in the current working directory
: cancel the currently running task. Click this to manually end an in-progress command. Your console will display the text <processing> in the top right corner if a task is running, and <idle> otherwise. Note that you may need to increase the width of your console to see this text (see below).

: terminate the current R console. Effectively, this button just calls the R command ‘q()’.
: remove a terminated console. After you’ve terminated a console, it will remain open. Clicking this button removes the terminated console entirely.
: remove all terminated consoles.

Managing Multiple Consoles

Architect allows you to have multiple instances of the console running in parallel. To start an additional console, simply click the button on the top Architect toolbar. Once you have multiple consoles running, the console switcher will become illuminated. There are two buttons here:

: cycle through all open consoles, one at a time
: opens a drop-down menu with all open consoles. This is particularly useful when you have a large number of consoles open.

R Graphics View

Architect comes with an embedded R Graphics viewer. The first time you make a graph in the default device, the R Graphics viewer should open automatically. But if you’ve closed it for some reason, it can be reopened via Window > Show View > Other > StatET > R Graphics.

Sometimes when making a graph, you’ll find that the produced graph isn’t properly scaled to the R Graphics device. To rescale, click the button, and the plot will resize to the current window’s dimensions.

Alternatively, you can use a non-embedded graphics device which does not need to be frequently rescaled. For instructions on configuration, see the section Non-Embedded R Graphics View.

Object Browser

One of Architect’s unique features is a view called the Object Browser. Think of it as a visual representation of an ls() call.

The object browser allows you to inspect defined objects in your current R session. This view lets you preview the structure of complex objects, and track changes to the elements of your R session on the fly. Right clicking on an object brings up additional options, like printing the object to the R Console or taking a closer look with Architect’s data viewer. See the Object Browser in action below:

Documentation: Building, Testing and Installing R Packages

Mon, 01 Jan 0001 00:00:00 +0000

Architect ships with a suite of tools to support R package development. If you’re new to developing R packages, Hilary Parker posted a very useful blog on how to write an R package from scratch.

This section assumes you have the structure of an R package more or less in place already. In the top toolbar, clicking the triangle of the External Tools button () opens a list of default tools for R packages (as well as some tools for generating various document types). To customize these, see the section External Tool Configuration.

Once the package is in place, select a tool to check, build or install it.

Package Projects

When creating a new project, you have the option to create an ‘R Package Project’ instead of ‘R Project’. This is largely the same as creating an ‘R Project’, but it allows you to use R code snippets that refer directly to your package.

There is a default snippet for adding roxygen documentation to an R package. For instructions on defining additional snippets or assigning them to hotkeys, see the Defining R Snippets section.

Generate Roxygen Documentation

Packaged functions require proper documentation. This can be done automatically in Architect. Under the Source menu, select Generate Element Comment (Roxygen), and structured documentation will be generated for a selected function. The parameters are pulled automatically from your function code.

One can further customize the default code that is generated by Quick Searching the Code Generation preferences menu. Additionally, you can assign the roxygen documentation to a hotkey.

Documentation: Client Configuration

Mon, 01 Jan 0001 00:00:00 +0000

Basic Configuration

Inside Architect, type Ctrl + 3 to pull up the Quick Search menu, then search for Run Configurations. Click on R Remote Console in the left menu, then click the ’new configuration' button () to define a new run configuration.

Then, fill in the address of your server and your credentials. A sample completed configuration looks as follows.

The Address field is composed of the host name (my.hostname.com) and the remote session name (remote-session-name1 in the example). A remote session name is an arbitrary name to identify the session. It allows one to define multiple different ‘R Remote Console’ configurations for different sessions on the same server (same host name). These names will also be displayed on top of the consoles which allows to distinguish between the different sessions and to easily switch back and forth from one session to another.

We recommend checking the Tunnel connections to R engine through SSH box, which secures the connection and does not require opening an extra port on the firewall. Note that Architect Server assumes that users have credentials to access the remote server over SSH.

Once configured, launch the newly created configuration choosing it via the configuration selector black arrow ().

In the above screenshot, we’ve named this configuration ‘my_generic_connection’. Naming a remote session allows users to have multiple uniquely named remote configurations defined. Above, the sessions ‘my_generic_connection’ and ‘my_generic_connection2’ could be run concurrently.

We can go one step further and label a configuration as a ‘favorite’ in the Common tab.

This places the selected configuration in a favorites list at the top of the run configurations dropdown menu ().

Remote R Help

Browsing an R help directory on a remote server is possible via the Remote Systems Explorer (RSE) eclipse plugin.

Install the RSE plugin from the eclipse marketplace: Help > Eclipse Marketplace…
Open the Remote Systems view : Window > Show View > Other… then under Remote Systems select Remote Systems.
Create a new connection by clicking the ’new connection’ button () and use the dialog to configure the remote endpoint. If the remote server is a *nix based system, we suggest to select use ssh only.
Next, configure a remote R environment for your remote R console.

follow steps 1-5 on installing different versions of R
on step 5, instead use the dropdown next to the Add… button to select Add Remote.
configure the remote in the following way:

where HOST should correspond to the host in the RSE connection

Launch your remote R console. After the index has finished updating ([INFO] Updating the R environment index started), restart the remote R console. The remote help view should now be working.

Documentation: Generating Reports

Mon, 01 Jan 0001 00:00:00 +0000

Architect ships with built-in functionality for creating and editing LaTeX, Sweave and Rmarkdown documents. In this section, we discuss how to use the basic functionality, but for instructions on how to configure your external tools, please refer to the Advanced section.

To create a Sweave, textile or Rmarkdown file, right click on a project and select New >. This will open a selection of available file types.

Rmarkdown Documents

Once you’ve created an Rmarkdown file, Architect will look something like this:

You’ll notice that syntax highlighting works automatically, and the Outline view gives a clear overview of our document’s structure.

In order to generate an html report based on a .Rmd file, open an R console in that file’s directory, then run the following code:

# install.packages("rmarkdown")
library(rmarkdown)
render("fileName.Rmd")

Sweave Documents

Like with Rmarkdown, Architect natively supports Sweave document development with syntax highlighting and Outline functionality.

Additionally, Architect offers specialized content assist when a Sweave document is open in the editor. As an example, type ‘<’, and Architect will give options for automatically creating a new code chunk.

In order to generate a .pdf file from a Sweave document, click on the .Rnw file in the Project Explorer and then select sweave-pdf from the External Tools () dropdown menu in the top toolbar. If your file is properly written, this will create various files (.tex, .log, etc.) as well as a .pdf render of your report.

Customizing Sweave Configuration

You can define your own Sweave configuration in the Sweave Document Processing (LaTeX + R) section of the External Tool Configuration window.

Click the New launch configuration button () in the top-left corner to define a new configuration.

Documentation: External Tool Configuration

Mon, 01 Jan 0001 00:00:00 +0000

To modify the existing External Tools, or add new ones, use the External Tool Configuration Window. This is particularly useful after you’ve installed a new version of R, to make sure tools such as R CMD INSTALL are run with the intended R version.

Switching a Configuration’s R Version

If you’ve installed a new version of R, you can edit your external tool configurations to work on the new R version. Navigate to the External Tools Configuration window, select the desired configuration, and change the selected configuration in the R Config tab.

Document Processing

Architect ships with built-in functionality for processing LaTeX, Sweave and knitr documents. These can be run via the External Tools dropdown menu, and further customized and modified in the External Tools Configurations window.

Documentation: Tips and Tricks

Mon, 01 Jan 0001 00:00:00 +0000

Customizing Keyboard Shortcuts

All keyboard shortcuts can be rebound in Architect. To do so, select Window > Preferences > General > Keys, then select and rebind the desired command.

Content Assist

One of the most useful features in Architect is the intelligent content assist tool. Suppose we wanted to convert a string to a date. We would assume such a command had the words “as” and “date” in the name, but is it ‘as.date’, ‘asDate’, ‘as_date’…

Google no more. In Architect, whenever you’re stuck, type Ctrl + Space and a list of context-sensitive suggestions will pop up.

Above, we type in ‘asDate’, then Ctrl + Space, and content assist gives us the rest. It works for variable names and function parameter names too!

Quick Search

If you’re not sure where something is (or just want to get to it quickly), use the Quick Search tool. Type Ctrl + 3 and a search window will pop up. From there, type something like ‘font’ or ‘git’, and you’ll be presented with a list of relevant options.

Finding Function Definitions

As your workspace and projects become more complex, it can be difficult to find where various functions are defined. By selecting clicking on a function call with Ctrl + Left Click (or, alternatively, F3), Architect will jump directly to that function’s definition.

Renaming all instances of a variable

To quickly rename all instances of a variable, put your text cursor on the variable and type Ctrl + 1. Then type the new name, press Enter, and all other instances of that variable will be updated.

Note that these replacements are intelligently context sensitive. Instances of a variable inside of a function will not be affected when you rename a variable with the same name outside of the function.

Proper indentation of script

When programming, Architect will do its best to automatically properly indent your code, but sometimes things still get out of line. To make sure your entire script is properly indented, highlight all of the text with Ctrl + a, then type Ctrl + i.

R Package Manager

Architect ships with a dedicated tool for managing R packages. To access it, click on the white arrow () inside of the Console and select Open Package Manager.

Repositories Tab

The Repositories tab allows you to configure which repositories will have their packages listed in the Packages tab of the R Package Manager.

Note that the list of repositories can be edited or added to by clicking the preferences link in the screenshot above.

Packages Tab

The Packages tab gives you an overview of the R Packages in your environment, and allows you to install new ones or update existing packages. In the previous section, we added Bioconductor to our list of repositories, which allows us to now search for and install Bioconductor packages (e.g. Biobase) from this menu.

Clicking on a package will also provide information about a package’s dependencies and reverse dependencies.

Options Tab

Lastly, the Options tab allows you to select whether you’d like package from the ‘Suggests’ field to also be installed during installation.

Documentation: Non-Embedded R Graphics View

Mon, 01 Jan 0001 00:00:00 +0000

To use a non-embedded R Graphics view, select from the main menu Run > Run Configurations.

Then select your R Console from the list on the left, navigate to the R Console tab and scroll to the bottom. Uncheck the box titled Set R Graphics view by StatET as default graphic device for new plots in R.

Documentation: Eclipse Plugins

Mon, 01 Jan 0001 00:00:00 +0000

Eclipse Marketplace

Since Architect is embedded in the Eclipse environment, additional Eclipse plugins can be installed directly in Architect via the Eclipse Marketplace.

From the Eclipse Marketplace menu, one can search for available plugins. Here, as an example, we look for a Python editor, and find PyDev, a popular Python IDE for Eclipse.

Click Install, and you’ll be presented with a selection of features available for installation.

To select all, click Confirm. Next, you’ll be prompted to accept the licenses associated with the downloaded software. Click Finish to initiate the installation.

Note that software may take some time to install. To hide the installation progress, click the Run in Background button on the installation window. Note that Architect may be restarted after installation in order to use the new software.

Software from Other Sources

Software add-ons from other sources may also be added via Help > Install New Software.

Architect ships with a number of predefined sites with software additions available to download. Other sources may be configured via the Add button.

Documentation: Using Architect Behind a Proxy Server

Mon, 01 Jan 0001 00:00:00 +0000

You can configure Architect to run an R Console behind a proxy server. Type Ctrl + 3 to access the Quick Search, then search for Network Connections. Use this window to configure your proxy settings.

Next, we’ll configure an R Environment to use these defined proxy settings. Quick Search for the R Environments preferences menu, then click the checkbox titled Use Eclipse preferences for Network Connections for the desired R Environment.

Documentation: Searching R Help Files

Mon, 01 Jan 0001 00:00:00 +0000

Architect allows you to search the help files from all installed R packages. To open the R Help search view, type Ctrl + h, then click on the R Help tab.

This is useful for finding packages and functions related to a given topic or keyword. For example, we may be interested in finding help pages that relate to ‘geom’. A quick search shows that 11 of our installed packages contain help pages related to this query.

By clicking on a package, we can see all pages from that package related to our search query. Clicking on a page opens the corresponding R Help page.

Help pages for base R packages are indexed the first time you run Architect. For other packages, help pages are automatically index upon package installation. Indexing displays the following messages in the Console.

Additional Search Features

You can specify the scope of your search via the Search in field. Selecting Complete Document may be needed for many queries. In our previous example, searching for “geom” in only selected fields yielded only three packages (and only two ggplot2 pages!).

Although not often utilized by package developers, searches can be done for predefined keywords such as “htest” (hypothesis test). The terms are available by clicking the Select… button.

Finally, if you have installed other versions of R, you can pick the R installation to search via the Selected Configuration dropdown menu.

Documentation: Refactoring R Code

Mon, 01 Jan 0001 00:00:00 +0000

Architect contains easy-to-use tools to quickly make alterations to your code. Below, we display how to use these functionalities.

Extracting Local Variables

Suppose we have some expressions that are reused throughout our code. In the example below, we have repeated instances of the expression:

profit > 0 & revenue > 50000

To clean up our code, we may be interested in assigning this expression to a variable, and replacing all instances of said expression by our new variable. We can do this by highlighting the specified code and selecting ‘Source > Extract Local Variable…’. The extraction is shown below.

Renaming Variables in a Selected Region

In the Tips and Tricks Section, we showed how to rename all instances of a variable in an entire document. However, often one wishes to rename a variable in just a specific section of the code.

We can do this by selecting a given section of code and selecting Source > Rename in Selected Region…. This opens a window the displays all variables within the selected region. Navigate to a variable and type another name in the New Name column to rename that variable in the highlighted region.

Converting Code into a Function

In Architect, a chunk of code can be transformed into a function with the click of a button. Simply highlight the desired code and select Source > Extract R Function…. Architect will automatically detect the function’s necessary input parameters, at which point you can specify their order in the function call. The code is wrapped into a function, and a function call is given underneath the definition.

In the example below, we wrap some code for a residual plot into a ‘plotResiduals’ function that takes ‘x’ and ‘y’ as inputs.