Why Deno's runtime features go beyond Node.js - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

What unique security feature does Deno provide compared to Node.js?

Deno introduces a security model that is not present by default in Node.js. What is this feature?

A Deno disables all network access permanently to prevent data leaks.

B Deno automatically encrypts all files on disk without user configuration.

C Deno runs scripts with strict permission controls, requiring explicit flags for file, network, and environment access.

D Deno requires a password to run any script, unlike Node.js.

💡 Hint

Think about how Deno controls what a script can do before it runs.

Deno's security model requires developers to explicitly grant permissions for file system, network, and environment access using command-line flags. This is unlike Node.js, which runs scripts with full access by default.

❓ component_behavior

intermediate

How does Deno handle module imports differently from Node.js?

Consider how Deno and Node.js resolve and load modules. What is a key difference in Deno's approach?

A Deno uses URL-based imports directly, allowing remote modules without a package manager.

B Deno requires all modules to be installed via npm before importing.

C Deno only supports CommonJS modules, not ES modules.

D Deno bundles all modules into a single file before running.

💡 Hint

Think about how you can import code from the internet in Deno.

Deno supports importing modules directly from URLs, such as from a CDN or GitHub, without needing a package manager like npm. Node.js typically requires installing packages first.

❓ lifecycle

advanced

What is a key difference in how Deno handles script execution lifecycle compared to Node.js?

Deno includes a built-in feature that affects how scripts start and stop. Which of the following describes this feature?

A Deno does not support asynchronous code execution.

B Deno requires manual garbage collection calls to free memory.

C Deno scripts must always be compiled before running, unlike Node.js.

D Deno has a built-in test runner and formatter integrated into the runtime.

💡 Hint

Think about tools that help with code quality and testing included in Deno.

Deno comes with built-in tools like a test runner and code formatter, which are part of the runtime environment. Node.js requires separate packages for these features.

📝 Syntax

advanced

Which Deno command correctly runs a script with network and file read permissions?

You want to run a Deno script named app.ts that needs to read files and access the network. Which command is correct?

A deno run --allow-net --allow-read app.ts

B deno run --read --net app.ts

C deno run --allow-all app.ts

D deno run app.ts --allow-net --allow-read

💡 Hint

Permission flags come before the script name in the command.

In Deno, permission flags like --allow-net and --allow-read must be placed before the script name when running a script. Option A shows the correct syntax.

🔧 Debug

expert

Why does this Deno script fail to read a file without errors in Node.js?

Given this Deno script: import { readTextFile } from "https://deno.land/std/fs/mod.ts"; const content = await readTextFile("./data.txt"); console.log(content); When run with 'deno run app.ts', it throws a permission error. Why does this happen and how is it different from Node.js?

Deno

import { readTextFile } from "https://deno.land/std/fs/mod.ts";

const content = await readTextFile("./data.txt");
console.log(content);

A Deno does not support reading local files at all, unlike Node.js.

B Deno requires explicit --allow-read permission to access files, unlike Node.js which allows file access by default.

C The import URL is invalid in Deno, causing the script to fail.

D Deno scripts cannot use await at the top level, causing a syntax error.

💡 Hint

Consider Deno's security model and how it differs from Node.js defaults.

Deno enforces security by requiring explicit permission flags like --allow-read to access the file system. Node.js scripts have full file system access by default, so they don't throw this error.

Practice

1. Which of the following is a key security feature that Deno provides by default compared to Node.js?

easy

A. Deno automatically runs all scripts with full system access.

B. Deno requires explicit permission to access files, network, or environment.

C. Deno disables all network access permanently.

D. Deno uses a firewall to block unauthorized connections.

Solution

1. Step 1: Understand Deno's permission model

   Deno requires you to explicitly grant permissions for file, network, or environment access to improve security.

2. Step 2: Compare with Node.js default behavior

   Node.js scripts run with full access by default, unlike Deno's explicit permission system.

3. Final Answer:

   Deno requires explicit permission to access files, network, or environment. -> Option B

4. Quick Check:

   Explicit permissions = Deno security [OK]

Hint: Remember: Deno asks permission before access [OK]

Common Mistakes:

• Thinking Deno runs scripts with full access by default
• Confusing Deno's permission system with firewall rules
• Assuming network access is always blocked

2. Which syntax correctly runs a Deno script with network access permission?

easy

A. deno run --net-allow script.ts

B. deno run --enable-network script.ts

C. deno run --allow-net script.ts

D. deno run --network script.ts

Solution

1. Step 1: Recall Deno permission flags

   Deno uses flags like --allow-net to grant network access explicitly.

2. Step 2: Identify correct flag syntax

   The correct flag is exactly --allow-net; other options are invalid.

3. Final Answer:

   deno run --allow-net script.ts -> Option C

4. Quick Check:

   Correct flag is --allow-net [OK]

Hint: Use --allow-net to enable network access [OK]

Common Mistakes:

• Using incorrect flag names like --net-allow
• Omitting the --allow-net flag when network access is needed
• Confusing permission flags with environment variables

3. What will be the output of this Deno script run with deno run script.ts if the script tries to read a file without permissions?

const data = await Deno.readTextFile("secret.txt");
console.log(data);

medium

A. PermissionDenied: read access to "secret.txt" is not allowed

B. SyntaxError: await used outside async function

C. FileNotFoundError: secret.txt does not exist

D. Contents of secret.txt printed to console

Solution

1. Step 1: Understand Deno's default permissions

   Deno denies file read access unless --allow-read is given.

2. Step 2: Predict error when reading file without permission

   Trying to read a file without permission causes a PermissionDenied error.

3. Final Answer:

   PermissionDenied: read access to "secret.txt" is not allowed -> Option A

4. Quick Check:

   Missing --allow-read causes PermissionDenied [OK]

Hint: No --allow-read means file read fails [OK]

Common Mistakes:

• Assuming file reads succeed without permission
• Confusing file not found with permission error
• Ignoring that await is valid in top-level for Deno

4. Identify the error in this Deno command and fix it:
deno run --allow-net --allow-read script.ts
Script still fails to access environment variables.

medium

A. No fix needed; environment variables are always accessible

B. Remove --allow-net flag to fix environment access

C. Use --allow-env instead of --allow-read

D. Add --allow-env flag to grant environment access

Solution

1. Step 1: Check permissions granted by command

   The command grants network and read permissions but not environment access.

2. Step 2: Identify missing permission for environment variables

   Accessing environment variables requires --allow-env flag.

3. Final Answer:

   Add --allow-env flag to grant environment access -> Option D

4. Quick Check:

   Missing --allow-env blocks env access [OK]

Hint: Add --allow-env to access environment variables [OK]

Common Mistakes:

• Assuming --allow-read covers environment access
• Removing unrelated flags instead of adding missing ones
• Believing environment variables are accessible without permission

5. You want to run a Deno script that uses TypeScript, formats code, lints, and accesses the network securely. Which combination of commands and features best uses Deno's runtime advantages?

hard

A. Use deno run --allow-net script.ts, then run deno fmt and deno lint commands

B. Use deno run --allow-net script.ts and rely on Node.js tools for formatting and linting

C. Run with deno run --allow-net script.ts, then manually install formatter and linter

D. Run script with deno run script.ts without permissions and use external tools for formatting

Solution

1. Step 1: Recognize Deno's built-in tools

   Deno includes built-in formatter (deno fmt) and linter (deno lint) without extra installs.

2. Step 2: Combine permissions and tools properly

   Run script with --allow-net for network, then use deno fmt and deno lint commands for formatting and linting.

3. Final Answer:

   Use deno run --allow-net script.ts, then run deno fmt and deno lint commands -> Option A

4. Quick Check:

   Deno built-in tools + explicit permissions = best practice [OK]

Hint: Use deno fmt and lint with permissions for best workflow [OK]

Common Mistakes:

• Assuming formatter and linter need separate installs
• Running without permissions and expecting network access
• Using Node.js tools instead of Deno's built-in ones