Languages and frameworks – Byteboard

Languages

CodeCollab supports the most in-demand programming language including:

Java

JavaScript

Kotlin

Python3

Ruby

Rust

TypeScript

Frameworks & Libraries

CodeCollab provides a flexible environment that allows for installing third-party libraries and frameworks in all major programming languages. See detailed instructions below for how to install libraries for each language; libraries and frameworks are installed at the individual interview level.

The NuGet package manager is installed by default in the CodeCollab environment. Here is an example of the terminal command you’d run to add the Newtonsoft.Json package:

dotnet add package Newtonsoft.Json

After adding the package, you can use it in your C# code by adding a using statement at the top of your C# files:

using Newtonsoft.Json;

First, enable dependency tracking for your code by initializing a go.mod file. Run the following command in the terminal from the ~/interview/golang directory:

go mod init example/hello

Next, add an import statement for the 3rd party package you’d like to use. For example:

package main

import "fmt"

import "rsc.io/quote"

func main() {
    fmt.Println(quote.Go())
}

Finally run this command in the terminal to install the dependencies:

go mod tidy

Java

The build tool Gradle is pre-installed in the CodeCollab environment. You can initialize a Gradle environment by running the following command in the terminal:

gradle init

When prompted, select 2:application as the project type and select Java as the implementation language. You can choose Groovy or Kotlin for the DSL language. For all other questions you can just press Enter to use the default values.

Next, add a dependencies section to your build.gradle.kts file in the app directory. Finally, run the following command to download the dependencies:

./gradlew --refresh-dependencies

JavaScript

The npm package manager is pre-installed in the CodeCollab environment, so you can install any package by running npm install in the same directory as the package.json file. For example, you would add the dpdm package by running the following in the terminal:

npm install dpdm

Kotlin

The build tool Gradle is pre-installed in the CodeCollab environment. You can initialize a Gradle environment by running the following command in the terminal:

gradle init

When prompted, select 1:basic as the project type. You can choose Groovy or Kotlin for the DSL language. For all other questions you can just press Enter to use the default values.

Next, add a dependencies section to your build.gradle.kts file in the `. Here's an example of how to add the kotlinx-coroutines-core library:


 plugins {
    kotlin("jvm") version "1.5.0"
}

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib"))
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0")
}

tasks {
    compileKotlin {
        kotlinOptions.jvmTarget = "1.8"
    }
    compileTestKotlin {
        kotlinOptions.jvmTarget = "1.8"
    }
}

Finally, run the following command to download the dependencies:

./gradlew --refresh-dependencies

PHP

CodeCollab supports the Composer package manager for installing 3rd party libraries in PHP.

You can install a package by running a terminal command like the following (this example installs Guzzle):

composer require guzzlehttp/guzzle

After installing a package with Composer, you can use the require function in PHP to include the Composer autoloader, which automatically loads the classes from the installed packages when you use them.

require 'vendor/autoload.php';

$client = new \GuzzleHttp\Client();

Python3

Initialize a new virtual environment by running the following command in the terminal:

 python3 -m venv venv

Next, activate the virtual environment and you’ll be all set to install packages in it:

source venv/bin/activate
pip3 install requests

Ruby

Here is an example terminal command you would run to install a ruby gem:

sudo gem install pry

You can confirm the gem has been installed by running irb to start an interactive ruby shell and then running a require command and confirming it prints =>true

require "pry"

Rust

To import Rust packages, add them to the dependencies section of your Cargo.toml file like this:

[dependencies]
serde = "1.0"

Next, run cargo build in the terminal to download and compile the package and its dependencies.

TypeScript

npm install dpdm

C++

We do not currently support 3rd party package installation in C++.

Language Server Extensions

The CodeCollab editor has language server extensions installed by default for our most popular programming languages. These extensions provide improved syntax highlighting, autocompletion, jump to definition, error checking, and code refactoring support.

Please do not disable any of these extensions as it can cause the collaborative editing session to be disrupted. CodeCollab has extended language support for the following languages:

Java

JavaScript

Kotlin

Python

Ruby

Rust

TypeScript

Debugger

📣

Please note that the debugging side bar tab is only visible to the candidate, but both the candidate and interviewer will be able to see any relevant output in the shared terminal.

The CodeCollab editor features a debug tab in the left-hand side bar. General instructions for using the debugger can be found here.

If you’d like to add multiple configurations for debugging, you can press the Add Configuration button in the .vscode/launch.json file.

During a debug session you can interact with the debugger in the Debug Console in the bottom of the editor window.

The CodeCollab debugger should work out of the box for the following programming languages:

Python

Open a Python file you’d like to debug in the editor.

From the Debug view in the left-hand side bar press Run and Debug or create a launch.json file and choose the Python Debugger option.

TypeScript & JavaScript

Open a TypeScript or JavaScript file you’d like to debug in the editor.

From the Debug view in the left-hand side bar press Run and Debug or create a launch.json file and choose the Node.js option.

Open a Go file you’d like to debug in the editor.

From the Debug view in the left-hand side bar press Run and Debug. You should not need to create a custom launch configuration in order to debug your Go code.

Java

Open a Java file you’d like to debug in the editor.

From the Debug view in the left-hand side bar press Run and Debug. You should not need to create a custom launch configuration in order to debug your Java code.

Multiple-Language Interview

For a Blank CodeCollab Interview, interviewers are required to select a programming language at the start of each CodeCollab interview; however, Byteboard’s collaborative code editor allows for flexibility in conducting interviews in any supported language (and file structure) that works for your team.

For each stand-alone interview question, we recommend the following file structure:

Select the New Folder icon and name according to the question (example: Question1, Question 2).

Create the following relevant files within the new folder

README

File containing the interview question for the candidate’s reference.

solution

File where the candidate can write their solution code. Note that interview participants (interviewers and candidates) can create as many files as you’d like.

tests

Optional file containing test cases

Note, the interviewer or candidate would need to input the appropriate command in the shared terminal to run (and if needed compile) the candidate’s code. For example, if you created a file named solution you could run the code with the following commands:

Programming Language	Sample command to run (and compile) code
Python	`python3 solution.py`
JavaScript	`node ./solution.py`
Java	`javac *.java java solution`
C#	`dotnet run`
Go	`GO111MODULE=auto go run solution.go`
Kotlin	`kotlinc *.kt -include-runtime -d solution.jar kotlin -classpath solution.jar solutionKt`
Php	`php solution.php`
Ruby	`ruby solution.rb`
Rust	`cargo run`
Typescript	`npm run start`