Gradle Dependencies

Su Suriya Ravichandran Updated 18 Nov 2026
11 min read ·Lesson 264 of 306

Gradle dependencies are the libraries your Java project needs, such as Gson for JSON or JUnit for tests. You declare them in build.gradle.kts, and Gradle downloads them, along with the libraries they depend on, and puts each one on the right classpath.

This lesson shows how to add Gradle dependencies, pick the right configuration (implementation, api, runtimeOnly and others), read the dependency tree, understand how Gradle resolves version conflicts, exclude unwanted libraries, use BOMs and constraints, and keep every version in a version catalog. It ends with a student exporter that mirrors the Maven example from Maven Dependencies. If Gradle is new to you, read Gradle in Java first.


Add a Dependency in build.gradle.kts

A dependency is written as "group:name:version", the same coordinates Maven uses. Add it to a configuration, usually implementation.

// build.gradle.kts
plugins {
    application
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("com.google.code.gson:gson:2.13.2")
}

java {
    toolchain { languageVersion = JavaLanguageVersion.of(25) }
}

application {
    mainClass = "com.gocourse.catalog.CourseJson"
}
package com.gocourse.catalog;

import com.google.gson.Gson;

public class CourseJson {

    record Course(String code, String title, int seats) {}

    public static void main(String[] args) {
        Gson gson = new Gson();
        Course course = new Course("JAVA101", "Java Basics", 40);

        String json = gson.toJson(course);                      // object -> JSON
        Course copy = gson.fromJson(json, Course.class);        // JSON -> object

        System.out.println(json);
        System.out.println("Same course after round trip: " + copy.equals(course));
    }
}
./gradlew run -q

Output:

{"code":"JAVA101","title":"Java Basics","seats":40}
Same course after round trip: true

How it works:

  • repositories { mavenCentral() } tells Gradle where to find the library. Without a repository, resolution fails with Cannot resolve external dependency ... because no repositories are defined.
  • Downloaded files are cached in ~/.gradle/caches, so the next build works offline.
  • implementation puts Gson on the compile classpath and the runtime classpath of the main code.

Gradle Dependency Configurations Explained

A configuration decides where a dependency is visible. This table also shows the closest Maven scope.

ConfigurationCompile mainRun mainCompile/run testsMaven scope
implementationYesYesYescompile
api (needs java-library)Yes, and exposed to consumersYesYescompile
compileOnlyYesNoCompile onlyprovided
runtimeOnlyNoYesRun onlyruntime
testImplementationNoNoYestest
testRuntimeOnlyNoNoRun onlytest
annotationProcessorRuns during compile onlyNoNo(compiler plugin path)
dependencies {
    implementation("com.google.code.gson:gson:2.13.2")          // code imports it
    compileOnly("jakarta.servlet:jakarta.servlet-api:6.1.0")    // the server provides it
    runtimeOnly("com.h2database:h2:2.4.240")                    // JDBC driver, loaded at run time

    testImplementation(platform("org.junit:junit-bom:6.1.3"))
    testImplementation("org.junit.jupiter:junit-jupiter")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

Compare the compile and runtime classpaths:

./gradlew dependencies --configuration compileClasspath -q
./gradlew dependencies --configuration runtimeClasspath -q

Output:

compileClasspath - Compile classpath for source set 'main'.
+--- com.google.code.gson:gson:2.13.2
|    \--- com.google.errorprone:error_prone_annotations:2.41.0
\--- jakarta.servlet:jakarta.servlet-api:6.1.0

runtimeClasspath - Runtime classpath of source set 'main'.
+--- com.google.code.gson:gson:2.13.2
|    \--- com.google.errorprone:error_prone_annotations:2.41.0
\--- com.h2database:h2:2.4.240

How it works:

  • The servlet API is only on the compile classpath, so it is never packaged. H2 is only on the runtime classpath, so your code cannot import org.h2... by accident.
  • error_prone_annotations is a transitive dependency: Gson needs it, so Gradle adds it automatically. The indented 0-- line shows which dependency pulled it in.
  • compileClasspath and runtimeClasspath are read-only views built from the configurations above. Use them when you want to see the final result.

Note: Old tutorials use compile and testCompile. These configurations were removed in Gradle 7 and cause a build error today. Use implementation and testImplementation.


api vs implementation in the java-library Plugin

In a multi-project build, a library subproject chooses which of its dependencies its consumers can see. implementation keeps a dependency private; api passes it on.

// core/build.gradle.kts
plugins {
    `java-library`
}

dependencies {
    implementation("com.google.code.gson:gson:2.13.2")
}
// core: a public method that returns a Gson type
package com.gocourse.core;

import com.google.gson.JsonObject;

public class StudentJson {
    public static JsonObject toJson(String name, int marks) {
        JsonObject json = new JsonObject();
        json.addProperty("name", name);
        json.addProperty("marks", marks);
        return json;
    }
}
// app: uses the returned JsonObject
package com.gocourse.app;

import com.gocourse.core.StudentJson;

public class App {
    public static void main(String[] args) {
        System.out.println(StudentJson.toJson("Asha", 92).get("marks"));
    }
}
./gradlew :app:compileJava

Output:

> Task :app:compileJava FAILED
App.java:7: error: cannot access JsonObject
        System.out.println(StudentJson.toJson("Asha", 92).get("marks"));
                                      ^
  class file for com.google.gson.JsonObject not found

Change the core dependency to api:

dependencies {
    api("com.google.code.gson:gson:2.13.2")
}
./gradlew :app:run -q
92

How it works:

  • toJson returns a JsonObject, so Gson is part of core's public API. Anyone calling it needs Gson on their compile classpath.
  • With implementation, Gson is hidden from app at compile time (it is still present at run time). With api, it is passed through.
  • Prefer implementation whenever a library is used only inside method bodies. Hidden dependencies mean fewer recompiles when they change and a smaller, cleaner API.

View the Dependency Tree and Find Why a Library Is Included

Two built-in tasks answer most dependency questions.

CommandShows
./gradlew dependenciesTrees for every configuration
./gradlew dependencies --configuration runtimeClasspathOne configuration only
./gradlew :app:dependenciesOne subproject only
./gradlew dependencyInsight --dependency gson --configuration runtimeClasspathWhy a library has a certain version, and who requested it

In this project, Gson asks for error_prone_annotations 2.41.0, and the build also declares version 2.36.0 directly (the setup used in the next section). Ask Gradle which version won and why:

./gradlew dependencyInsight --dependency error_prone_annotations --configuration runtimeClasspath -q

Output (shortened):

com.google.errorprone:error_prone_annotations:2.41.0
   Selection reasons:
      - By conflict resolution: between versions 2.41.0 and 2.36.0

com.google.errorprone:error_prone_annotations:2.36.0 -> 2.41.0
\--- runtimeClasspath

com.google.errorprone:error_prone_annotations:2.41.0
\--- com.google.code.gson:gson:2.13.2
     \--- runtimeClasspath

How it works:

  • The insight report lists every path that requests the library and the version each path asked for.
  • An arrow such as 2.36.0 -> 2.41.0 means "this path asked for 2.36.0, but 2.41.0 was selected". The next section explains why.
  • In the tree, (*) marks a subtree already shown above, and (c) marks a constraint rather than a real dependency.

How Gradle Resolves Dependency Version Conflicts

When two paths request different versions of the same library, Gradle picks the highest version by default. This differs from Maven, where the nearest declaration wins.

dependencies {
    implementation("com.google.code.gson:gson:2.13.2")                       // wants 2.41.0
    implementation("com.google.errorprone:error_prone_annotations:2.36.0")   // direct, older
}
./gradlew dependencies --configuration runtimeClasspath -q

Output:

runtimeClasspath - Runtime classpath of source set 'main'.
+--- com.google.code.gson:gson:2.13.2
|    \--- com.google.errorprone:error_prone_annotations:2.41.0
\--- com.google.errorprone:error_prone_annotations:2.36.0 -> 2.41.0

If you truly need an exact version, use a strict version:

dependencies {
    implementation("com.google.code.gson:gson:2.13.2")
    implementation("com.google.errorprone:error_prone_annotations") {
        version { strictly("2.36.0") }
    }
}
runtimeClasspath - Runtime classpath of source set 'main'.
+--- com.google.code.gson:gson:2.13.2
|    \--- com.google.errorprone:error_prone_annotations:2.41.0 -> 2.36.0
\--- com.google.errorprone:error_prone_annotations:{strictly 2.36.0} -> 2.36.0

How it works:

  • "Highest wins" is safe for most libraries, because newer versions usually stay backward compatible. You can never accidentally downgrade a library a dependency needs.
  • strictly overrides that rule and forces a downgrade. Use it only when a newer version is known to break your code, and note why in a comment.
  • To fail the build on any conflict instead, add configurations.all { resolutionStrategy.failOnVersionConflict() }.

Exclude a Transitive Dependency in Gradle

Remove a library that another dependency brings in with exclude.

dependencies {
    implementation("com.google.code.gson:gson:2.13.2") {
        exclude(group = "com.google.errorprone", module = "error_prone_annotations")
    }
}
./gradlew dependencies --configuration runtimeClasspath -q

Output:

runtimeClasspath - Runtime classpath of source set 'main'.
\--- com.google.code.gson:gson:2.13.2

How it works:

  • group and module identify the library; no version is needed, since every version is removed.
  • The exclusion applies only to this dependency's path. If another library also brings in the annotations, they come back through that path.
  • Only exclude libraries that are not needed at run time. Excluding a real runtime dependency fails later with ClassNotFoundException.

Manage Versions With Platforms, BOMs and Constraints

A platform (a Maven BOM) recommends versions for a family of libraries, so you can leave the versions out. A constraint recommends a version for one library without adding it.

dependencies {
    // BOM: manages every JUnit module version
    testImplementation(platform("org.junit:junit-bom:6.1.3"))
    testImplementation("org.junit.jupiter:junit-jupiter")            // no version needed
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")    // no version needed

    implementation("com.google.code.gson:gson:2.13.2")

    constraints {
        // if anything brings in error_prone_annotations, use at least 2.41.0
        implementation("com.google.errorprone:error_prone_annotations:2.41.0") {
            because("older versions miss annotations used by our tools")
        }
    }
}
./gradlew dependencies --configuration testRuntimeClasspath -q

Output (shortened):

testRuntimeClasspath - Runtime classpath of source set 'test'.
+--- org.junit:junit-bom:6.1.3
|    +--- org.junit.jupiter:junit-jupiter:6.1.3 (c)
|    \--- org.junit.platform:junit-platform-launcher:6.1.3 (c)
+--- org.junit.jupiter:junit-jupiter -> 6.1.3
|    +--- org.junit.jupiter:junit-jupiter-api:6.1.3
|    \--- org.junit.jupiter:junit-jupiter-engine:6.1.3
+--- com.google.code.gson:gson:2.13.2
|    \--- com.google.errorprone:error_prone_annotations:2.41.0
\--- org.junit.platform:junit-platform-launcher -> 6.1.3

How it works:

  • platform(...) imports the BOM's versions. The (c) lines are constraints from the BOM, and -> 6.1.3 shows the version they supplied.
  • Main dependencies are inherited by the test classpath, which is why Gson appears in testRuntimeClasspath.
  • because(...) stores the reason in the build, and dependencyInsight prints it.

Keep Versions in a Gradle Version Catalog

A version catalog is a TOML file, gradle/libs.versions.toml, that names every library and version in one place. Gradle generates type-safe accessors such as libs.gson for it.

# gradle/libs.versions.toml
[versions]
gson = "2.13.2"
h2 = "2.4.240"
junit = "6.1.3"

[libraries]
gson = { module = "com.google.code.gson:gson", version.ref = "gson" }
h2 = { module = "com.h2database:h2", version.ref = "h2" }
junit-bom = { module = "org.junit:junit-bom", version.ref = "junit" }
junit-jupiter = { module = "org.junit.jupiter:junit-jupiter" }
junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher" }
// build.gradle.kts
dependencies {
    implementation(libs.gson)
    runtimeOnly(libs.h2)

    testImplementation(platform(libs.junit.bom))
    testImplementation(libs.junit.jupiter)
    testRuntimeOnly(libs.junit.platform.launcher)
}
./gradlew dependencies --configuration runtimeClasspath -q

Output:

runtimeClasspath - Runtime classpath of source set 'main'.
+--- com.google.code.gson:gson:2.13.2
|    \--- com.google.errorprone:error_prone_annotations:2.41.0
\--- com.h2database:h2:2.4.240

How it works:

  • Gradle finds gradle/libs.versions.toml automatically; no extra setup is needed.
  • Dashes in names become dots in accessors: junit-platform-launcher is used as libs.junit.platform.launcher.
  • All subprojects share the same catalog, so upgrading Gson in a ten-module build means editing one line. gradle init creates this file for new projects.

Real-World Example: Gradle Dependencies for a Student Exporter

This app reads student results from an in-memory database and prints them as JSON, best marks first. It uses one dependency per configuration and keeps every version in the catalog.

LibraryConfigurationWhy
GsonimplementationThe main code imports com.google.gson
H2runtimeOnlyThe code uses only java.sql; the driver is needed when it runs
JUnittestImplementationOnly the tests use it
# gradle/libs.versions.toml
[versions]
gson = "2.13.2"
h2 = "2.4.240"
junit = "6.1.3"

[libraries]
gson = { module = "com.google.code.gson:gson", version.ref = "gson" }
h2 = { module = "com.h2database:h2", version.ref = "h2" }
junit-bom = { module = "org.junit:junit-bom", version.ref = "junit" }
junit-jupiter = { module = "org.junit.jupiter:junit-jupiter" }
junit-platform-launcher = { module = "org.junit.platform:junit-platform-launcher" }
// settings.gradle.kts
rootProject.name = "student-export"
// build.gradle.kts
plugins {
    application
}

version = "1.0.0"

repositories { mavenCentral() }

java {
    toolchain { languageVersion = JavaLanguageVersion.of(25) }
}

dependencies {
    implementation(libs.gson)
    runtimeOnly(libs.h2)

    testImplementation(platform(libs.junit.bom))
    testImplementation(libs.junit.jupiter)
    testRuntimeOnly(libs.junit.platform.launcher)
}

application {
    mainClass = "com.gocourse.export.App"
}

tasks.test { useJUnitPlatform() }
// src/main/java/com/gocourse/export/Student.java
package com.gocourse.export;

public record Student(String name, String course, int marks) {}
// src/main/java/com/gocourse/export/StudentExporter.java
package com.gocourse.export;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

public class StudentExporter {
    private final Gson gson = new GsonBuilder().setPrettyPrinting().create();

    /** Reads all students, best marks first, and returns them as JSON. */
    public String exportJson(String jdbcUrl) throws SQLException {
        List<Student> students = new ArrayList<>();
        try (Connection connection = DriverManager.getConnection(jdbcUrl);
             Statement statement = connection.createStatement();
             ResultSet resultSet = statement.executeQuery(
                     "SELECT name, course, marks FROM students ORDER BY marks DESC")) {
            while (resultSet.next()) {
                students.add(new Student(
                        resultSet.getString("name"),
                        resultSet.getString("course"),
                        resultSet.getInt("marks")));
            }
        }
        return gson.toJson(students);
    }
}
// src/main/java/com/gocourse/export/App.java
package com.gocourse.export;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class App {
    public static void main(String[] args) throws Exception {
        String jdbcUrl = "jdbc:h2:mem:school;DB_CLOSE_DELAY=-1";

        try (Connection connection = DriverManager.getConnection(jdbcUrl);
             Statement statement = connection.createStatement()) {
            statement.execute("CREATE TABLE students (name VARCHAR(50), course VARCHAR(50), marks INT)");
            statement.execute("INSERT INTO students VALUES ('Ravi', 'Python', 78), ('Asha', 'Java', 92)");
        }

        System.out.println(new StudentExporter().exportJson(jdbcUrl));
    }
}
// src/test/java/com/gocourse/export/StudentExporterTest.java
package com.gocourse.export;

import static org.junit.jupiter.api.Assertions.assertEquals;

import com.google.gson.Gson;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import org.junit.jupiter.api.Test;

class StudentExporterTest {

    @Test
    void exportsStudentsOrderedByMarks() throws Exception {
        String jdbcUrl = "jdbc:h2:mem:export_test;DB_CLOSE_DELAY=-1";
        try (Connection connection = DriverManager.getConnection(jdbcUrl);
             Statement statement = connection.createStatement()) {
            statement.execute("CREATE TABLE students (name VARCHAR(50), course VARCHAR(50), marks INT)");
            statement.execute("INSERT INTO students VALUES ('Meena', 'Go', 55), ('Asha', 'Java', 92)");
        }

        String json = new StudentExporter().exportJson(jdbcUrl);
        Student[] students = new Gson().fromJson(json, Student[].class);

        assertEquals("Asha", students[0].name());     // 92 comes first
        assertEquals(55, students[1].marks());
    }
}

Build, check the classpath and run:

./gradlew build
./gradlew dependencies --configuration runtimeClasspath -q
./gradlew run -q

Output:

BUILD SUCCESSFUL in 6s
7 actionable tasks: 7 executed
runtimeClasspath - Runtime classpath of source set 'main'.
+--- com.google.code.gson:gson:2.13.2
|    \--- com.google.errorprone:error_prone_annotations:2.41.0
\--- com.h2database:h2:2.4.240
[
  {
    "name": "Asha",
    "course": "Java",
    "marks": 92
  },
  {
    "name": "Ravi",
    "course": "Python",
    "marks": 78
  }
]

How it works:

  1. One catalog. Every version lives in libs.versions.toml, and build.gradle.kts only says which library goes into which configuration.
  2. implementation. StudentExporter imports Gson, so Gson must be on the compile classpath. Its transitive annotations come along automatically.
  3. runtimeOnly. No class imports H2. DriverManager finds the driver on the runtime classpath through Java's service loader, so the jdbc:h2: URL works in both the app and the test. Switching databases means changing one catalog entry and the URL.
  4. Test dependencies stay out. JUnit is missing from runtimeClasspath, so it never ends up in the distribution built by the application plugin.
  5. The test checks the ordering. ORDER BY marks DESC puts Asha (92) first, and the test confirms it with its own in-memory database.

To package this app and its two libraries into a single runnable file, continue with Build Executable JAR. For the task side of Gradle, such as custom tasks and multi-project builds, see Gradle Build.

0 Comments

Reviewed before they appear

No comments yet.

Java
Java Introduction Java Features Java Syntax Java Comments Java Statements Java Output Java Variables Java Data Types Java Type Casting Java Operators Java Strings Java Numbers Java Math Java Booleans Java User Input Java Conditions Java If Else Java Switch Java While Loop Java For Loop Java Break Java Continue Java Arrays Java Methods Java Parameters Java Return Values Java Scope Java Recursion Install Java Install JDK Java IDEs Java JDK Java JRE Java JVM Java Compiler Java File Compile Java Run Java JShell Basics Java Packages Java OOP Java Classes Java Objects Class Methods Constructors Constructor Overload this Keyword static Keyword final Keyword Encapsulation Inheritance Polymorphism Abstraction Access Modifiers super Keyword Method Overload Method Override Instanceof Operator Nested Classes Inner Classes Anonymous Classes Enums Records Array Basics Array Length Loop Arrays Multidimensional Arrays Array Copy Array Sorting Array Search ArrayList LinkedList HashSet TreeSet HashMap TreeMap Queue Interface Deque Interface Stack Class Iterator List Interface Set Interface Map Interface Collections Class Comparable Comparator Generics Basics Generic Classes Generic Methods Wildcards String Basics String Length String Methods String Concatenation String Compare String Search String Replace String Split String Format StringBuilder StringBuffer Text Blocks Regular Expressions Number Types Integer Class Float Class Double Class BigInteger BigDecimal Math Class Random Numbers Number Format Date Basics LocalDate LocalTime LocalDateTime ZonedDateTime Date Formatting Date Parsing Period Class Duration Class Java Instant Class Java Exception Basics Java try...catch Java Multiple Catch Blocks Java finally Block Java throw Keyword Java throws Keyword Java Checked Exceptions Java Unchecked Exceptions Java Custom Exceptions Java try-with-resources Java Exception Chaining Java File Basics Java Create Files Java Read Files Java Write Files Java Delete Files Java File Paths Java File Class Java BufferedReader Java BufferedWriter Java FileInputStream Java FileOutputStream Java Object Streams Java Directory Handling Java NIO Basics Java Files API Java Input Java Scanner Class Java Console Input Java PrintStream Java InputStream Java OutputStream Java Reader Class Java Writer Class Java Buffered Streams Java Data Streams Java Generics Introduction Java Generic Types Java Generic Methods Java Bounded Types Java Wildcards Java Type Erasure Java Generic Interfaces Java Generic Collections Java Lambda Basics Java Lambda Syntax Java Functional Interfaces Java Method References Java Stream API Java Stream Creation Java Stream Filter Java Stream Map Java Stream Reduce Java Stream Sort Java Stream Collect Java Collectors Class Java Optional Class Java Parallel Streams Java Threads: Thread Basics Create a Thread in Java Java Thread Class Java Runnable Interface Java Thread States Java Thread Sleep Java Thread Join Java Thread Priority Java Synchronization Java Thread Safety Java Race Conditions Java Deadlocks Java Executor Service Java Thread Pools Java Callable Interface Java Future Interface Java CompletableFuture Java Concurrent Collections Java Atomic Classes Java Virtual Threads Java Networking Basics Java URL Class Java URI Class Java HttpClient Java HTTP Requests Java HTTP Responses Java Socket Basics Java ServerSocket Java DatagramSocket Java WebSocket Basics Java JDBC Basics Java JDBC Setup Java Database Connection Java JDBC Connection Interface Java JDBC Statement Java PreparedStatement Java ResultSet Java JDBC CRUD Operations Java JDBC Transactions Java JDBC Batch Update Java Connection Pooling with HikariCP Java JPA Basics: Entities, EntityManager and JPQL Java Hibernate Basics: SessionFactory, Session and HQL Package in Java: Basics Explained with Examples Create Package in Java: Step-by-Step Guide with Examples Import Package in Java: The import Statement Explained Access Control in Java: Packages, Classes and Members JAR File in Java: Create, Run and Inspect JAR Files Java Modules: Introduction to the Java Module System module-info in Java: Every Module Directive Explained Java Module Path: How --module-path Finds Your Modules Java Classpath: How -cp and CLASSPATH Find Your Classes Java Annotations: Basics of @ Metadata in Java Java Built-in Annotations: @Override, @Deprecated and More Java Custom Annotations: Create Your Own @interface Java Annotation Targets: @Target and ElementType Explained Java Reflection API: Inspect and Use Classes at Runtime Java Class Metadata: Names, Modifiers, Hierarchy and Generic Java Dynamic Objects: Create Objects Dynamically With Reflec Java Dynamic Proxy: Intercept Method Calls With Proxy and In Java Security Java Secure Coding Java Password Hashing Java Input Validation Java Cryptography Basics Java KeyStore Basics Java TLS Basics Java SecureRandom Java JUnit Basics Java JUnit Test Methods JUnit Assertions JUnit Test Fixtures JUnit Parameterized Tests Mockito in Java Java Mock Objects Java Integration Testing Java Code Coverage Maven in Java Create a Maven Project in Java Maven Dependencies Maven Plugins Gradle in Java Gradle Build Gradle Dependencies Build Executable JAR in Java Build WAR File in Java HTTP Basics in Java Java Servlet Basics Servlet Lifecycle in Java HttpServletRequest in Java HttpServletResponse in Java JSP in Java JSTL in JSP REST API in Java JSON in Java Java Web Application Spring Framework Basics Spring Boot Tutorial Spring MVC Spring Data JPA Spring Security Spring Boot REST API Jakarta EE Basics Java Deployment JAR Deployment Java WAR Deployment Run Java as a Service Docker Java: Dockerize a Java Application Java Environment Variables and Configuration Java Logging Basics Java Production Setup Java JVM Options Java JVM Monitoring Java Hello World App Java Calculator App Java Number Guess Game Java Student Manager Java Library System Java Bank App Java Todo App Java File Manager Java Quiz App Java REST API Project Java Chat Server Java Employee Manager Java E-commerce API
Ask about this post
AI Ask about this post

Ask questions about Gradle Dependencies and get answers drawn from it.

Signed-in readers only.