Why Deno was created to fix Node.js mistakes - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why does Deno use secure defaults?

Deno was designed with security in mind. What is the main reason Deno requires explicit permission for file, network, or environment access?

A To prevent accidental or malicious access to sensitive resources by default

B To make the code run faster by limiting resource usage

C To force developers to write more complex code

D To ensure compatibility with older Node.js modules

💡 Hint

Think about what could happen if a program could access everything without asking.

Deno requires explicit permissions to protect users from scripts that might harm their system or steal data. This is a security improvement over Node.js, which allows full access by default.

❓ component_behavior

intermediate

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

Deno uses URLs for module imports instead of Node.js's package.json and node_modules system. What is a direct effect of this difference?

A Modules are bundled into a single file automatically

B Modules must be installed globally before use

C Modules require a special configuration file like package.json

D Modules can be imported directly from the web without a package manager

💡 Hint

Think about how you get code from the internet in Deno.

Deno allows importing modules directly via URLs, simplifying dependency management and avoiding the need for a centralized package manager like npm.

📝 Syntax

advanced

What error does this Deno code produce?

Consider this Deno script run without any permissions:

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

What error will this code produce when run with deno run script.ts?

A ReferenceError: Deno is not defined

B PermissionDenied: run again with --allow-read

C SyntaxError: Unexpected await outside async function

D FileNotFoundError: secret.txt does not exist

💡 Hint

Deno restricts file access by default.

Deno requires explicit permission flags to access files. Without --allow-read, it throws a PermissionDenied error.

🔧 Debug

advanced

Why does this Node.js code cause a security risk that Deno avoids?

Node.js code:

const fs = require('fs');
const secret = fs.readFileSync('/etc/passwd', 'utf8');
console.log(secret);

Why is this a security risk in Node.js but not in Deno by default?

A Node.js runs code in a sandbox, Deno runs with full system access

B Node.js allows file system access without restrictions, Deno requires explicit permission

C Node.js blocks reading system files, Deno allows it

D Node.js encrypts files automatically, Deno does not

💡 Hint

Think about default access permissions in both runtimes.

Node.js scripts can read any file by default, which can expose sensitive data. Deno blocks such access unless permissions are granted.

❓ lifecycle

expert

How does Deno's built-in tooling improve developer experience compared to Node.js?

Deno includes built-in tools like a formatter, linter, test runner, and bundler. What is a key advantage of this design over Node.js's approach?

A Developers do not need to install and configure multiple separate tools

B Deno automatically updates all dependencies without user input

C Deno compiles code to native machine code for faster execution

D Deno requires a special IDE to use these tools

💡 Hint

Think about how many tools you install separately in Node.js projects.

Deno bundles common developer tools, reducing setup time and complexity compared to Node.js where you install many packages separately.

Practice

1. Why was Deno created as an improvement over Node.js?

easy

A. To make Node.js run faster without changes

B. To add support for older JavaScript versions

C. To fix security issues and simplify development

D. To remove TypeScript support completely

Solution

1. Step 1: Understand Node.js limitations

   Node.js had security risks and complex setup issues that developers faced.

2. Step 2: Identify Deno's goals

   Deno was designed to improve security and simplify the developer experience by default.

3. Final Answer:

   To fix security issues and simplify development -> Option C

4. Quick Check:

   Security and simplicity [OK]

Hint: Focus on security and simplicity as main goals [OK]

Common Mistakes:

• Thinking Deno removes TypeScript support
• Assuming Deno only speeds up Node.js
• Believing Deno targets older JavaScript versions

2. Which of the following is the correct way to run a TypeScript file in Deno?

easy

A. deno run myfile.ts

B. node myfile.ts

C. deno compile myfile.js

D. node run myfile.js

Solution

1. Step 1: Recall Deno's command for running scripts

   Deno runs TypeScript files directly using the command deno run filename.ts.

2. Step 2: Check other options

   Node.js cannot run TypeScript files without compilation. deno compile myfile.js is for compiling, not running.

3. Final Answer:

   deno run myfile.ts -> Option A

4. Quick Check:

   Deno runs TS files with 'deno run' [OK]

Hint: Remember: Deno runs TS files directly with 'deno run' [OK]

Common Mistakes:

• Using Node.js commands for TypeScript files
• Confusing compile and run commands
• Trying to run JavaScript files with Deno compile

3. What will be the output of this Deno script?

console.log(Deno.args.length);

when run with deno run script.ts one two?

medium

A. 0

B. undefined

C. 1

D. 2

Solution

1. Step 1: Understand Deno.args

   Deno.args is an array of command-line arguments passed after the script name.

2. Step 2: Count the arguments passed

   Running deno run script.ts one two passes two arguments: 'one' and 'two'.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Arguments count = 2 [OK]

Hint: Count arguments after script name in command line [OK]

Common Mistakes:

• Counting script name as argument
• Assuming no arguments passed
• Confusing Deno.args with process.argv

4. Identify the error in this Deno script:

import { serve } from "https://deno.land/std/http/server.ts";

serve(() => new Response("Hello"));

medium

A. serve function requires a port number argument

B. Missing permission flag to allow network access

C. Incorrect import URL for Deno standard library

D. Response constructor is not valid in Deno

Solution

1. Step 1: Check Deno's security model

   Deno requires explicit permission flags for network access when running scripts.

2. Step 2: Analyze the script's network usage

   The script uses serve to start a server, which needs network permission.

3. Final Answer:

   Missing permission flag to allow network access -> Option B

4. Quick Check:

   Network access needs permission flag [OK]

Hint: Remember to add --allow-net for network scripts [OK]

Common Mistakes:

• Assuming serve needs a port argument
• Thinking import URL is incorrect
• Believing Response is invalid in Deno

5. How does Deno improve security compared to Node.js when running scripts?

hard

A. By requiring explicit permission flags for file, network, and environment access

B. By disabling all network access permanently

C. By automatically sandboxing scripts without user control

D. By running scripts only in a browser environment

Solution

1. Step 1: Understand Node.js security model

   Node.js allows scripts to access files, network, and environment without restrictions by default.

2. Step 2: Identify Deno's security approach

   Deno requires users to explicitly grant permissions like --allow-net or --allow-read to scripts.

3. Final Answer:

   By requiring explicit permission flags for file, network, and environment access -> Option A

4. Quick Check:

   Explicit permission flags [OK]

Hint: Deno needs explicit permission flags for sensitive access [OK]

Common Mistakes:

• Thinking Deno disables network permanently
• Believing Deno auto-sandboxes without user input
• Assuming Deno runs scripts only in browsers