4.0 Build Tools & Package Managers

Question 1

4.0 Build Tools & Package Managers

What configuration language does Gradle use?

Answer 1

Groovy

Question 2

4.0 Build Tools & Package Managers

What configuration language does Maven use?

Answer 2

XML

Question 3

4.0 Build Tools & Package Managers

Where in the app directory structure does Gradle generate the JAR?

Answer 3

~/java-app/build/libs/

May look something like java-app-1.0-SNAPSHOT.jar

Question 4

4.0 Build Tools & Package Managers

Where in the app directory structure does Maven generate the JAR?

Answer 4

~/java-maven-app/target/maven-status/

May look something like java-manen-app-1.1.0-SNAPSHOT.jar

Question 5

4.0 Build Tools & Package Managers

What is an artifact?

Answer 5

A single packaged file containing application code and all its dependencies.

Artifacts are essential for deployment across different environments.

Question 6

4.0 Build Tools & Package Managers

What does building the code mean?

Answer 6

Compiling, compressing, and packaging many files into a single artifact.

This process prepares the application for deployment.

Question 7

4.0 Build Tools & Package Managers

What is an artifact repository?

Answer 7

A storage system for artifacts, used for backups and redeployments (e.g., Nexus, JFrog Artifactory).

It helps manage versioned artifacts efficiently.

Question 8

4.0 Build Tools & Package Managers

Why do we need artifacts?

Answer 8

To deploy applications to different environments (dev, test, prod) as a consistent, versioned file.

Artifacts ensure that the same version of the application is used across environments.

Question 9

4.0 Build Tools & Package Managers

What do Java artifacts typically look like?

Answer 9

• JAR files
• WAR files

These formats are used for packaging Java applications.

Question 10

4.0 Build Tools & Package Managers

What do JavaScript artifacts typically look like?

Answer 10

• Zip files
• Tar files

JavaScript does not have a special artifact type like Java.

Question 11

4.0 Build Tools & Package Managers

What are the Java build tools?

Answer 11

• Maven
• Gradle

These tools help automate the build process in Java projects.

Question 12

4.0 Build Tools & Package Managers

What is the JavaScript package manager?

Answer 12

npm (and yarn)

These tools manage JavaScript libraries and dependencies.

Question 13

4.0 Build Tools & Package Managers

Where do Java developers find dependencies?

Answer 13

Maven Central Repository

This repository hosts a wide range of Java libraries.

Question 14

4.0 Build Tools & Package Managers

What file stores Maven project dependencies?

Answer 14

pom.xml

This file defines the project structure and dependencies for Maven.

Question 15

4.0 Build Tools & Package Managers

What file stores Gradle project dependencies?

Answer 15

build.gradle

This file is used to configure Gradle builds.

Question 16

4.0 Build Tools & Package Managers

What happens when you add a dependency to Maven/Gradle?

Answer 16

The dependency is downloaded to the local repository.

This allows for offline builds and faster access to dependencies.

Question 17

4.0 Build Tools & Package Managers

Where does Gradle put the built artifact?

Answer 17

In the build folder.

This is the default output directory for Gradle builds.

Question 18

4.0 Build Tools & Package Managers

Where does Maven put the built artifact?

Answer 18

In the target folder.

This is the standard output directory for Maven builds.

Question 19

4.0 Build Tools & Package Managers

How do you run a Java application locally?

Answer 19

java -jar <name-of-jar>

This command executes the JAR file containing the application.

Question 20

4.0 Build Tools & Package Managers

How do you run a Java application on a server?

Answer 20

Copy the JAR to the server → run java -jar.

This process is common for deploying Java applications.

Question 21

4.0 Build Tools & Package Managers

Does JavaScript use build tools?

Answer 21

JS primarily uses package managers (npm, yarn) instead of build tools.

This reflects the different needs of JavaScript applications.

Question 22

4.0 Build Tools & Package Managers

Where are JS dependencies defined?

Answer 22

package.json

This file lists all dependencies and scripts for a JavaScript project.

Question 23

4.0 Build Tools & Package Managers

What commands does npm provide?

Answer 23

• npm install
• npm start
• npm stop
• npm test
• npm publish

These commands facilitate various tasks in JavaScript development.

Question 24

4.0 Build Tools & Package Managers

What does a JS artifact (zip/tar) contain?

Answer 24

Application code without dependencies.

This is important for deploying JavaScript applications.

Question 25

# 4.0 Build Tools & Package Managers How do you deploy a **JavaScript app** to a server?

Answer 25

1. Copy zip/tar 2. Unpack 3. Install dependencies 4. Run the app ## Footnote This process ensures that the application runs correctly on the server.

Question 26

# 4.0 Build Tools & Package Managers What tools package **frontend JavaScript code**?

Answer 26

Bundlers/build tools like **webpack**. ## Footnote These tools help optimize and prepare code for production.

Question 27

# 4.0 Build Tools & Package Managers Why does **frontend JS code** need transpiling?

Answer 27

Browsers don’t support the latest JS features or JSX. ## Footnote Transpiling ensures compatibility across different browsers.

Question 28

# 4.0 Build Tools & Package Managers What does **webpack** do?

Answer 28

Transpiles, minifies, bundles, and compresses frontend code. ## Footnote This process improves performance and reduces load times.

Question 29

# 4.0 Build Tools & Package Managers How do you package full **frontend code** for deployment?

Answer 29

Bundle with webpack → package into a WAR or static assets folder. ## Footnote This prepares the application for deployment on a server.

Question 30

# 4.0 Build Tools & Package Managers What are **build or package tools** for other languages?

Answer 30

* Python: pip * C/C++: conan * C#: NuGet * Golang: dep * Ruby: RubyGems ## Footnote These tools serve similar purposes across different programming languages.

Question 31

# 4.0 Build Tools & Package Managers What common patterns exist across all **build tools**?

Answer 31

* Dependency file * Dependency repository * CLI tool * Commands to test, start, build, publish ## Footnote These patterns help standardize the build process.

Question 32

# 4.0 Build Tools & Package Managers Why publish **artifacts** to a repository?

Answer 32

To store and download them for deployment on other servers. ## Footnote This practice ensures that artifacts are accessible when needed.

Question 33

# 4.0 Build Tools & Package Managers Why are **artifacts** less commonly used today?

Answer 33

Docker images replaced many artifact types. ## Footnote This shift reflects changes in deployment practices.

Question 34

# 4.0 Build Tools & Package Managers How does **Docker** change the build process?

Answer 34

* Only one artifact type: Docker image * No need to install Java/npm on servers * Build and run everything inside the image ## Footnote Docker simplifies deployment by encapsulating everything needed to run an application.

Question 35

# 4.0 Build Tools & Package Managers Is **building** still required when using Docker?

Answer 35

Yes — the app must be built before the Docker image is created. ## Footnote This step is crucial for ensuring the application functions correctly.

Question 36

# 4.0 Build Tools & Package Managers Why should **DevOps engineers** know build tools?

Answer 36

To configure CI/CD pipelines, run tests, build artifacts/images, and deploy apps. ## Footnote Understanding build tools is essential for effective DevOps practices.

Question 37

# 4.0 Build Tools & Package Managers What steps are typically automated in **CI/CD**?

Answer 37

* Install dependencies * Run tests * Build/bundle app * Publish artifact or build Docker image * Push to repository ## Footnote Automation improves efficiency and reduces errors in the deployment process.

Question 38

# 4.0 Build Tools & Package Managers Examples of **build automation commands**?

Answer 38

* `npm install`, `npm test`, `npm run build`, `npm publish` * `mvn test`, `mvn install`, `mvn package` * `docker build`, `docker push` ## Footnote These commands facilitate various tasks in the build and deployment process.

Question 39

# 4.0 Build Tools & Package Managers What causes the **Maven error**: *“Could not resolve dependencies”*?

Answer 39

* Incorrect version * Missing repository * Offline mode enabled * Corporate proxy blocking Maven Central ## Footnote These issues prevent Maven from locating and downloading required dependencies.

Question 40

# 4.0 Build Tools & Package Managers How do you **clear Maven's local dependency cache**?

Answer 40

* Delete `~/.m2/repository` * Run `mvn dependency:purge-local-repository` ## Footnote Clearing the cache can resolve issues with corrupted or outdated dependencies.

Question 41

# 4.0 Build Tools & Package Managers What **Gradle command** re-downloads missing/corrupted dependencies?

Answer 41

`gradle --refresh-dependencies` ## Footnote This command forces Gradle to check for updated dependencies and download them again.

Question 42

# 4.0 Build Tools & Package Managers Why does Maven produce *“Invalid target release: XX”*?

Answer 42

The installed JDK doesn't match `maven-compiler-plugin` settings ## Footnote Ensuring the correct JDK version is crucial for successful builds.

Question 43

# 4.0 Build Tools & Package Managers What problem causes: *“JAVA_HOME is not set and no 'java' command could be found”*?

Answer 43

Java not installed or environment variables misconfigured ## Footnote Properly setting JAVA_HOME is essential for Java applications to run.

Question 44

# 4.0 Build Tools & Package Managers What causes **Gradle's** *“PermGen space / OutOfMemoryError”*?

Answer 44

* Large dependency graph * Heavy annotation processing ## Footnote Adjusting `GRADLE_OPTS` can help manage memory usage.

Question 45

# 4.0 Build Tools & Package Managers What issue causes *“command not found: mvn / gradle”*?

Answer 45

PATH is missing Maven/Gradle bin folder after installation ## Footnote Ensuring the PATH variable is correctly set is necessary for command-line access.

Question 46

# 4.0 Build Tools & Package Managers What causes: *“module not found”* after an npm install?

Answer 46

* `node_modules` folder missing * Version mismatch ## Footnote Running `rm -rf node_modules && npm install` can resolve this issue.

Question 47

# 4.0 Build Tools & Package Managers How do you fix **npm EACCES permission errors** on Linux?

Answer 47

Don’t use `sudo npm install -g`; instead configure npm prefix in your home directory ## Footnote This prevents permission issues when installing global packages.

Question 48

# 4.0 Build Tools & Package Managers Why does an npm build fail with *“Out of memory”*?

Answer 48

Minifiers or bundlers exceed Node's default memory ## Footnote Fix this by using `node --max_old_space_size=4096` to allocate more memory.

Question 49

# 4.0 Build Tools & Package Managers What causes *“package-lock.json conflicts”* in Git?

Answer 49

Multiple developers using different npm versions ## Footnote Standardizing Node/npm versions can prevent these conflicts.

Question 50

# 4.0 Build Tools & Package Managers How do you verify exactly which **dependency version** was installed?

Answer 50

Run `npm ls ` ## Footnote This command lists the installed version of a specific package.

Question 51

# 4.0 Build Tools & Package Managers Why do Node apps fail after deployment?

Answer 51

Dependencies not installed on the server ## Footnote Remember: artifacts **do not contain dependencies**; they must be installed separately.

Question 52

# 4.0 Build Tools & Package Managers Why is **Docker** used instead of JAR/WAR/zip artifacts in modern DevOps?

Answer 52

Docker packages the app *and its runtime environment* ## Footnote This avoids dependency mismatches and simplifies deployment.

Question 53

# 4.0 Build Tools & Package Managers What causes Docker builds to fail with *“file not found”* for artifacts?

Answer 53

Build steps run **outside** Docker, but Dockerfile expects them inside ## Footnote Performing the build inside the Dockerfile resolves this issue.

Question 54

# 4.0 Build Tools & Package Managers What causes *“node: not found”* or *“java: not found”* during Docker builds?

Answer 54

Base image missing required runtime ## Footnote Use appropriate images like `node:20-alpine` or `eclipse-temurin:17`.

Question 55

# 4.0 Build Tools & Package Managers Why must Docker builds use **.dockerignore**?

Answer 55

To avoid sending large files like `node_modules` to the Docker daemon ## Footnote This drastically speeds up builds by reducing context size.

Question 56

# 4.0 Build Tools & Package Managers Why do **multi-stage Docker builds** improve CI/CD performance?

Answer 56

They reduce final image size and remove build-time tools from production images ## Footnote This leads to more efficient deployments.

Question 57

# 4.0 Build Tools & Package Managers Why might a CI job fail with *“command not found: mvn/npm/gradle”*?

Answer 57

Wrong CI executor image ## Footnote Use images like `maven:3.9-eclipse-temurin-17`, `gradle:8-jdk17`, or `node:20-alpine`.

Question 58

# 4.0 Build Tools & Package Managers What causes **flaky CI builds**?

Answer 58

* Race conditions * Non-deterministic tests * Network issues fetching dependencies * Cached dependency corruption ## Footnote These factors can lead to inconsistent build results.

Question 59

# 4.0 Build Tools & Package Managers Why do pipelines run slower over time?

Answer 59

CI cache grows too large or contains stale artifacts ## Footnote Clearing or optimizing caching strategy can improve performance.

Question 60

# 4.0 Build Tools & Package Managers What's the safest caching strategy for **node builds**?

Answer 60

Cache **only `~/.npm`**, not `node_modules` ## Footnote This prevents unnecessary bloat in the cache.

Question 61

# 4.0 Build Tools & Package Managers Why do Java builds fail in CI but work locally?

Answer 61

Local machine has cached dependencies, but CI requires explicitly listed repositories ## Footnote Ensuring all dependencies are defined in the build configuration is crucial.

Question 62

# 4.0 Build Tools & Package Managers Why should developers **pin exact dependency versions**?

Answer 62

Unpinned versions lead to unpredictable builds and “works on my machine” issues ## Footnote Pinning versions ensures consistent environments across different setups.

Question 63

# 4.0 Build Tools & Package Managers What is the difference between dependency **version pinning** and **version ranges**?

Answer 63

* Pinning → reproducible builds * Ranges → risk of unexpected breaking changes ## Footnote Understanding this difference is key to managing dependencies effectively.

Question 64

# 4.0 Build Tools & Package Managers What does a **lock file** ensure (package-lock.json / npm-shrinkwrap / gradle.lockfile)?

Answer 64

Guarantees identical dependency versions across machines and CI pipelines ## Footnote This is essential for maintaining consistency in builds.

Question 65

# 4.0 Build Tools & Package Managers Why do dev and prod use different **dependency sets**?

Answer 65

Dev includes test/build tools; prod installs only runtime dependencies ## Footnote This reduces the attack surface in production environments.

Question 66

# 4.0 Build Tools & Package Managers Why shouldn’t developers commit built artifacts (JAR/WAR/zip) to Git?

Answer 66

* Causes repo bloat * Breaks Git diffs * CI should produce artifacts, not dev machines ## Footnote This practice helps maintain a clean and efficient repository.

Question 67

# 4.0 Build Tools & Package Managers Why must DevOps engineers understand **build tools**?

Answer 67

They configure pipelines that must install, test, package, and deploy the application ## Footnote Knowledge of build tools is essential for effective DevOps practices.

Question 68

# 4.0 Build Tools & Package Managers What is the **DevOps golden rule** about build environments?

Answer 68

Builds must be **repeatable, immutable, and performed in CI**, never on personal laptops ## Footnote This ensures consistency and reliability in the build process.