Scripted vs declarative comparison in Jenkins - Practice Questions

Challenge - 5 Problems

🧠 Conceptual

intermediate

Difference in Pipeline Syntax Style

Which statement correctly describes the main difference between scripted and declarative Jenkins pipelines?

A Declarative pipelines cannot include parallel stages, but scripted pipelines can.

B Declarative pipelines require writing Groovy code for all logic, whereas scripted pipelines use YAML files for configuration.

C Scripted pipelines are only for building Java projects, while declarative pipelines support all languages.

D Scripted pipelines use a Groovy-based imperative programming style, while declarative pipelines use a simpler, predefined syntax focused on stages and steps.

💡 Hint

Think about how each pipeline style expresses the build process: one is more like writing code, the other more like describing steps.

Scripted pipelines are written in Groovy and allow full programming control (imperative style). Declarative pipelines use a simpler, structured syntax focused on stages and steps, making them easier to read and write.

💻 Command Output

intermediate

Output of Declarative Pipeline with Parallel Stages

Given this declarative Jenkins pipeline snippet, what will be the output in the Jenkins console log?

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        echo 'Building...'
      }
    }
    stage('Test') {
      parallel {
        stage('Unit Tests') {
          steps {
            echo 'Running unit tests'
          }
        }
        stage('Integration Tests') {
          steps {
            echo 'Running integration tests'
          }
        }
      }
    }
  }
}

A

Building...
Running unit tests
Running integration tests

B

Building...
Running unit tests

C

Running unit tests
Running integration tests
Building...

D

Building...
Running integration tests

💡 Hint

Remember that parallel stages run at the same time, but their output appears sequentially in the log.

The pipeline first runs the 'Build' stage printing 'Building...'. Then the 'Test' stage runs two parallel stages, each printing their respective messages. All three messages appear in the log.

❓ Configuration

advanced

Correct Scripted Pipeline Syntax for Loop

Which scripted Jenkins pipeline snippet correctly loops over a list of environments and echoes each one?

A

def envs = ['dev', 'qa', 'prod']
for (e in envs) {
  echo "Deploying to ${e}"
}

B

def envs = ['dev', 'qa', 'prod']
envs.each() {
  echo 'Deploying to ' + it
}

C

def envs = ['dev', 'qa', 'prod']
for (int i=0; i<envs.size(); i++) {
  echo "Deploying to ${envs[i]}"
}

D

def envs = ['dev', 'qa', 'prod']
for e in envs {
  echo "Deploying to ${e}"
}

💡 Hint

Check Groovy syntax for loops and list indexing carefully.

Option A uses a valid Groovy for-in loop. Option A has a syntax error with the each() call missing a closure parameter. Option A uses Python-like syntax which is invalid in Groovy. Option A has an off-by-one error in the loop condition causing an index out of bounds.

❓ Troubleshoot

advanced

Troubleshooting Declarative Pipeline Syntax Error

Why does this declarative pipeline snippet cause a syntax error?

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        echo 'Building...'
      }
    }
    stage('Test') {
      steps {
        parallel {
          unit: {
            echo 'Unit tests'
          },
          integration: {
            echo 'Integration tests'
          }
        }
      }
    }
  }
}

A The 'parallel' block is incorrectly placed inside 'steps'; it should be directly inside 'stages'.

B The syntax for parallel stages requires using 'stage' blocks inside 'parallel', not just labels with closures.

C The parallel stages must be defined as separate 'stage' blocks, not inside 'steps'.

D The 'parallel' block keys (unit, integration) must be strings in quotes.

💡 Hint

Check the correct way to define parallel stages in declarative pipelines.

In declarative pipelines, parallel stages must be defined as nested 'stage' blocks inside the 'parallel' block. Using labels with closures directly inside 'steps' is invalid syntax.

✅ Best Practice

expert

Choosing Pipeline Style for Complex Logic

You need to implement a Jenkins pipeline with complex conditional logic, loops, and dynamic stage creation. Which pipeline style is best suited for this task and why?

A Declarative pipeline, because it is simpler and always preferred regardless of complexity.

B Declarative pipeline, because it has built-in support for complex loops and dynamic stages.

C Scripted pipeline, because it allows full Groovy programming capabilities for complex logic and dynamic behavior.

D Scripted pipeline, because it uses YAML syntax which is easier for complex logic.

💡 Hint

Consider which pipeline style supports full programming features like loops and dynamic stage creation.

Scripted pipelines use Groovy code, allowing complex programming constructs such as loops, conditionals, and dynamic stage creation. Declarative pipelines have a simpler syntax but limited support for such dynamic behavior.