Gallery
Share
Explore

Final Exam Study Notes s24 CSD 3103

⁠
Final Exam Study Notes s24 CSD 3103
⁠
⁠

Final Exam Study and Preparation Discussion Topics:

⁠
https://www.dropbox.com/scl/fi/vtd5yzvboc502whz1uhrl/JavaScript_Enterprise_Application_Modeling_Final_Exam_Study_Book.pdf?rlkey=7eogotmtdidqrwyp1a64qax96&dl=0
⁠
⁠


Final Exam Topics:

⁠
https://coda.io/@peter-sigurdson/mastering-the-browsers-inner-workings-a-hands-on-lab-guide-to-th
⁠
⁠
⁠
https://coda.io/@peter-sigurdson/node-js-chromium-v8-console-object-model-and-browser-object-mode
⁠
⁠
⁠
https://coda.io/@peter-sigurdson/lab-the-applications-of-http-post-and-get-methods
⁠
⁠

megaphone

Redo all of the Labs:

⁠
https://coda.io/@peter-sigurdson/s24-csd3101-lab-1
⁠
⁠
⁠
https://coda.io/d/_dfyNXARTg0L/The-JavaScript-Calculator_suBRW?searchClick=3b133665-e72b-40b5-a42b-216ea419d778_fyNXARTg0L
⁠
⁠
⁠
https://coda.io/d/_d8TcMoOmhRV/Selectors-in-the-HTML-DOM-and-how-JavaScript-APIs-use-them_sun-P?searchClick=47aa2d7e-0ad5-4cc5-8d32-93314d26a24b_8TcMoOmhRV
⁠
⁠
⁠
https://coda.io/d/_dviqMq4Xge4/Mastering-JavaScript-Functions-A-Comprehensive-Lab-Workbook-for-_suWaY?searchClick=7ba41b62-1419-409c-aaa1-437c6c11d928_viqMq4Xge4
⁠
⁠

⁠
https://www.dropbox.com/scl/fi/nwb113ous39omqc6mn7fm/CSD3103_Class_Lab_Work_Book.pdf?rlkey=2y3o33pkvg1owa0z88e2i13pr&dl=0
⁠
⁠

info

For the CSD 3103 final exam, study the importance of understanding and applying software development methodologies like Unified Process and Agile.

Thoroughly learn concepts such as:


Business domain analysis using lexical analysis and UML diagrams (
CSD 3103 s3 5:30 to 8:30 B124
⁠
,
CSD 3103 s3 5:30 to 8:30 B124
⁠
,
CSD 3103 s2 2 to 5 r B124
⁠
)
Identifying business objects, data attributes, and methods from user stories (
CSD 3103 s1 12:30 to 3:30 B122
⁠
)
Creating UML class diagrams, use case diagrams, and object interaction diagrams (
CSD 3103 s3 5:30 to 8:30 B124
⁠
,
CSD 3103 s2 2 to 5 r B124
⁠
)
Applying principles like high cohesion, low coupling, and responsibility-driven design (
WED CSD 3103 s4 9 to Noon B124
⁠
)
Understanding service-oriented architecture (SOA) and microservices (
CSD 3103 s2 2 to 5 r B124
⁠
)
Explaining Unified Process during interviews helped secure job offers (
CSD 3103 s1 12:30 to 3:30 B122
⁠
).
Hands-on skills like using TypeScript for domain modeling, setting up development environments with Node.js and NPM, and debugging techniques (
WED CSD 3103 s4 9 to Noon B124
⁠
,
WED CSD 3103 s4 9 to Noon B124
⁠
).
Prepare for the final exam by emphasizing both theoretical concepts and practical implementation of software engineering best practices.

History of JavaScript - How and why did it come into existance
What is ECMAScript : What is important about the different versions of ECMAScript

What is Node.js ? What is
NPMJS.com
⁠
? How do these work as application development enviroments.
npm init -y and package.json
Install TypeScript - the TypeScript compiler
and ts-node - the TypeScript Run Time

npm install --save-dev typescript ts-node

Building Node.js Applications with
NPMJS.com
⁠
packages
Using Visual Studio Code
The 2 Execution Contexts of JavaScript
COM
BOM

JavaScript Functions

⁠
NPMjs.com
⁠
Web Applications
Express.js
Middleware
Mongo DB


⁠
image.png
⁠
⁠
These questions will cover various topics from the course outline, focusing on key concepts and practical applications.

1. What are the key differences between let, const, and var in JavaScript?

Labs:
6 kinds of JavaScript Functions
Temporal DeadZone
Answer:
var is function-scoped and allows for hoisting, which can lead to unexpected behavior due to its placement in memory.
let is block-scoped and does not hoist in the same way var does, making it more predictable within code blocks.
const is also block-scoped but is used to declare variables that should not be reassigned after their initial value is set.
Explanation: var declarations are hoisted to the top of their enclosing scope, meaning they are accessible before they are defined. This can cause bugs, especially in larger codebases. let and const were introduced in ES6 to provide block scoping and to prevent accidental reassignments with const. These keywords enhance code readability and reduce the chances of errors by making variable behavior more predictable​.

2. Explain the concept of promises in JavaScript and how they improve asynchronous programming.

Answer:
A promise is an object representing the eventual completion or failure of an asynchronous operation. Promises provide a cleaner, more manageable way to handle asynchronous code compared to callbacks.
States: A promise can be pending, fulfilled, or rejected.
Methods: Promises have .then(), .catch(), and .finally() methods for handling resolved and rejected states.
Explanation: Promises were introduced to address the "callback hell" problem, where multiple nested callbacks make code difficult to read and maintain. Promises allow developers to chain operations, making asynchronous code more readable and maintainable by following a linear and predictable flow​.

3. How can you create a REST API using Express.js in Node.js?

Answer:
To create a REST API using Express.js:
Install Express: Use npm to install Express in your Node.js application.
Set up Express app: Create an instance of Express and set up middleware.
Define routes: Use HTTP methods like GET, POST, PUT, and DELETE to handle different routes.
Implement logic: Add logic for interacting with the database or performing other tasks within route handlers.
Start server: Use app.listen() to start the server on a specified port.
Explanation: Express.js is a minimal web framework for Node.js that simplifies the process of creating server-side applications. By leveraging its routing capabilities, developers can define clean and organized endpoints for their REST APIs​​.

4. Describe the role of middleware in an Express.js application.

Answer:
Middleware functions in Express.js are functions that have access to the request object (req), the response object (res), and the next middleware function in the application's request-response cycle. They can:
Execute code.
Make changes to the request and response objects.
End the request-response cycle.
Call the next middleware function in the stack.
Explanation: Middleware allows for modular and reusable code that can handle common tasks like logging, error handling, authentication, and data parsing. By stacking middleware functions, Express.js provides a flexible way to handle requests and responses​.

5. What is the purpose of the package.json file in a Node.js project?

Answer:
The package.json file is a manifest file in a Node.js project that contains:
Metadata about the project, such as its name, version, and description.
A list of dependencies and their versions.
Scripts for running tasks like tests or building the project.
Configuration options for the project.
Explanation: package.json is crucial for managing project dependencies and scripts. It ensures that everyone working on the project uses the same library versions, reducing "it works on my machine" issues and simplifying deployment by automating various development tasks



2. Question: Explain the concept of a Promise in JavaScript and provide an example of its usage.
Answer: A Promise in JavaScript is an object representing the eventual completion or failure of an asynchronous operation. It has three states: pending, fulfilled, or rejected. Promises provide a way to handle asynchronous operations more elegantly than callbacks.
Example:
```javascript function fetchData(url) { return new Promise((resolve, reject) => { fetch(url) .then(response => response.json()) .then(data => resolve(data)) .catch(error => reject(error)); }); }
fetchData('https://api.example.com/data') .then(data => console.log(data)) .catch(error => console.error(error)); ```
In this example, fetchData returns a Promise that resolves with the fetched data or rejects with an error. The then and catch methods are used to handle the fulfilled and rejected states respectively.
3. Question: What is Node.js and how does it differ from browser-based JavaScript?
Answer: Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine. It allows JavaScript to be run on the server-side. Key differences from browser-based JavaScript include:
- Environment: Node.js runs on servers, while browser JavaScript runs in web browsers. - APIs: Node.js provides APIs for file system operations, network operations, etc., which are not available in browsers. - Global object: In Node.js, the global object is 'global', while in browsers it's 'window'. - Modules: Node.js uses CommonJS module system by default, while browsers traditionally use script tags (though ES modules are now supported in modern browsers). - DOM: There's no DOM in Node.js, as it's not running in a browser environment. - Security: Node.js has full system access, while browser JavaScript is restricted by the same-origin policy and other security measures.
Understanding these differences is crucial for developing full-stack JavaScript applications.
4. Question: Describe the purpose and basic structure of package.json in a Node.js project.
Answer: package.json is a crucial file in Node.js projects that serves several purposes:
1. Project metadata: It contains descriptive information about the project like name, version, author, etc. 2. Dependencies: It lists both production and development dependencies of the project. 3. Scripts: It defines various scripts that can be run using npm run <script-name>. 4. Configuration: It can include configuration settings for various tools used in the project.
Basic structure:
```json { "name": "my-project", "version": "1.0.0", "description": "A sample Node.js project", "main": "index.js", "scripts": { "start": "node index.js", "test": "jest" }, "dependencies": { "express": "^4.17.1" }, "devDependencies": { "jest": "^26.6.3" } } ```
This file is essential for npm to understand and manage the project, its dependencies, and various scripts associated with it.
5. Question: What is Express.js and why is it commonly used in Node.js applications?
Answer: Express.js is a minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications. It's commonly used because:
1. Simplicity: It simplifies the process of writing server-side code and handling HTTP requests. 2. Middleware: It provides a powerful middleware mechanism for processing requests. 3. Routing: It offers an intuitive routing system for handling different HTTP methods and URLs. 4. Performance: It's known for its high performance and minimal overhead. 5. Large ecosystem: It has a vast ecosystem of plugins and middleware.
Example of a basic Express.js server:
```javascript const express = require('express'); const app = express(); const port = 3000;
app.get('/', (req, res) => { res.send('Hello World!'); });
app.listen(port, () => { console.log(`Server running at http://localhost:${port}`); }); ```
Express.js is a fundamental tool in the Node.js ecosystem for building web applications and APIs efficiently.
6. Question: Explain the concept of middleware in Express.js and provide an example.
Answer: Middleware in Express.js are functions that have access to the request object (req), the response object (res), and the next middleware function in the application's request-response cycle, commonly denoted by 'next'. Middleware can:
1. Execute any code. 2. Make changes to the request and response objects. 3. End the request-response cycle. 4. Call the next middleware in the stack.
Example:
```javascript const express = require('express'); const app = express();
// Custom middleware const loggerMiddleware = (req, res, next) => { console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`); next(); // Call next middleware };
app.use(loggerMiddleware); // Use the middleware
app.get('/', (req, res) => { res.send('Hello World!'); });
app.listen(3000); ```
In this example, loggerMiddleware is a custom middleware that logs the timestamp, HTTP method, and URL of each request. It's applied to all routes using app.use(). Understanding middleware is crucial for building flexible and maintainable Express.js applications.

7. Question: What is the purpose of the Model-View-Controller (MVC) architecture in web applications?


Answer: The Model-View-Controller (MVC) architecture is a design pattern used in web applications to separate the application logic into three interconnected components:
1. Model: Represents the data and business logic of the application. 2. View: Handles the presentation and rendering of data to the user. 3. Controller: Acts as an intermediary between Model and View, processing user input and updating the Model and View accordingly.
Purpose and benefits of MVC:
- Separation of Concerns: Each component has a distinct responsibility, making the code more organized and maintainable. - Modularity: Changes to one component have minimal impact on others, allowing for easier updates and modifications. - Reusability: Components, especially Models and Views, can be reused across different parts of the application. - Scalability: The separation makes it easier to scale different parts of the application independently. - Testability: Individual components can be tested in isolation, facilitating unit testing.
Understanding MVC is crucial for structuring large-scale web applications effectively, particularly when using frameworks that implement this pattern.

8. Question: Describe the differences between SQL and NoSQL databases, and give an example of when you might choose one over the other.

Answer: SQL (Relational) and NoSQL (Non-relational) databases differ in several key aspects:
1. Data Model: - SQL: Uses a structured schema with tables, rows, and columns. Relationships between tables are defined. - NoSQL: Can be schema-less, allowing for more flexible data structures. Common types include document, key-value, wide-column, and graph databases.
2. Scalability: - SQL: Generally scales vertically (increasing server power). - NoSQL: Often designed for horizontal scalability (adding more servers).
3. ACID Compliance: - SQL: Typically ACID compliant (Atomicity, Consistency, Isolation, Durability). - NoSQL: May sacrifice ACID compliance for performance and scalability.
4. Query Language: - SQL: Uses standardized SQL. - NoSQL: May use various query languages or APIs specific to the database.
5. Use Cases: - SQL: Ideal for complex queries, transactions, and when data integrity is crucial. - NoSQL: Better for rapid development, big data, real-time web applications.
Example scenario: - Choose SQL (e.g., PostgreSQL) for a banking system where data integrity and complex transactions are critical. - Choose NoSQL (e.g., MongoDB) for a social media application where rapid scalability and flexible data models are more important than complex joins.
Understanding these differences helps in selecting the appropriate database type for specific project requirements.
9. Question: What is RESTful API design and why is it important in web development?
Answer: RESTful (Representational State Transfer) API design is an architectural style for designing networked applications. It relies on a stateless, client-server protocol, almost always HTTP. Key principles include:
1. Resource-Based: APIs are modeled as resources that can be accessed and manipulated using HTTP methods. 2. Stateless: Each request from client to server must contain all information needed to understand and process the request. 3. Client-Server: The client and server are separated, allowing each to evolve independently. 4. Cacheable: Responses must define themselves as cacheable or not. 5. Uniform Interface: A uniform way of interacting with a given server irrespective of device or type of application.
Importance in web development: - Scalability: RESTful design allows for better scalability due to its stateless nature. - Flexibility: It's not tied to specific technologies and can be implemented using various programming languages. - Simplicity: The use of standard HTTP methods makes it intuitive and easy to understand. - Interoperability: It facilitates communication between different systems and platforms.
Example of RESTful endpoints: - GET /users (Retrieve all users) - POST /users (Create a new user) - GET /users/{id} (Retrieve a specific user) - PUT /users/{id} (Update a specific user) - DELETE /users/{id} (Delete a specific user)
Understanding RESTful API design is crucial for creating scalable and maintainable web services.
10. Question: Explain the concept of asynchronous programming in JavaScript and how it's implemented using async/await.
Answer: Asynchronous programming in JavaScript allows code execution to continue while waiting for long-running operations (like API calls or file I/O) to complete. This prevents blocking the main thread and improves application responsiveness.
async/await is a syntax for handling asynchronous operations that makes asynchronous code look and behave more like synchronous code. It's built on top of Promises.
Key points: - async function: Declares a function as asynchronous. - await keyword: Used inside an async function to wait for a Promise to resolve.
Example:
```javascript async function fetchUserData(userId) { try { const response = await fetch(`https://api.example.com/users/${userId}`); if (!response.ok) { throw new Error('User not found'); } const userData = await response.json(); console.log(userData); return userData; } catch (error) { console.error('Error fetching user data:', error); } }
// Usage fetchUserData(123).then(data => { // Do something with the data }); ```
In this example, the async function allows the use of await to handle the asynchronous fetch operation in a more readable, synchronous-looking manner. Error handling is done using try/catch.
Understanding async/await is crucial for writing clean, efficient asynchronous code in modern JavaScript.
11. Question: What is the purpose of webpack in modern JavaScript development?
Answer: Webpack is a static module bundler for modern JavaScript applications. Its main purposes include:
1. Module Bundling: It takes modules with dependencies and generates static assets representing those modules.
2. Asset Management: It can handle not just JavaScript, but also CSS, images, and other assets, treating them as modules.
3. Code Splitting: It allows splitting your code into various bundles which can be loaded on demand.
4. Optimization: It can minify and optimize code for production.
5. Development Server: It provides a development server with hot module replacement for faster development.
6. Loader System: It uses loaders to preprocess files, allowing you to bundle any static resource beyond JavaScript.
Example of a basic webpack.config.js:
```javascript const path = require('path');
module.exports = { entry: './src/index.js', output: { filename: 'main.js', path: path.resolve(__dirname, 'dist'), }, module: { rules: [ { test: /\.css$/, use: ['style-loader', 'css-loader'], }, ], }, }; ```
This configuration specifies an entry point, an output file, and a rule for processing CSS files.
Understanding webpack is crucial for managing complex JavaScript projects and optimizing them for production.
12. Question: Describe the concept of Cross-Origin Resource Sharing (CORS) and why it's important in web development.
Answer: Cross-Origin Resource Sharing (CORS) is a security mechanism implemented by browsers to control access to resources (e.g., APIs) from a different domain than the one serving the web page.
Key points: 1. Same-Origin Policy: By default, web browsers restrict cross-origin HTTP requests initiated from scripts. 2. CORS Headers: The server can include specific headers in its responses to allow or restrict access from different origins. 3. Preflight Requests: For certain types of requests, the browser sends a preflight request (OPTIONS) to check if the actual request is safe to send.
Importance: - Security: It prevents malicious sites from making unauthorized requests to other domains on behalf of the user. - Controlled Access: It allows servers to specify which origins are allowed to access their resources. - API Usage: It's crucial for web applications that need to access APIs hosted on different domains.
Example of enabling CORS in an Express.js server:
```javascript const express = require('express'); const cors = require('cors'); const app = express();
app.use(cors({ origin: 'https://allowed-origin.com' }));
app.get('/api/data', (req, res) => { res.json({ message: 'This is accessible from allowed-origin.com' }); });
app.listen(3000); ```
Understanding CORS is essential for developing secure web applications that interact with resources across different domains.
13.(Not on this Exam) Question: What is the purpose of Jest in JavaScript testing, and provide an example of a simple test case.
Answer: Jest is a popular JavaScript testing framework developed by Facebook. Its main purposes include:
1. Unit Testing: Testing individual units of code in isolation. 2. Mocking: Creating mock objects to simulate dependencies. 3. Code Coverage: Reporting on how much of your code is covered by tests. 4. Assertion Library: Providing a rich set of matchers for making assertions. 5. Snapshot Testing: Capturing and comparing UI components.
Example of a simple Jest test case:
```javascript // Function to be tested function sum(a, b) { return a + b; }
// Test suite describe('sum function', () => { // Individual test case test('adds 1 + 2 to equal 3', () => { expect(sum(1, 2)).toBe(3); });
test('adds -1 + 1 to equal 0', () => { expect(sum(-1, 1)).toBe(0); }); }); ```
To run this test: 1. Install Jest: npm install --save-dev jest 2. Add a test script in package.json: "scripts": { "test": "jest" } 3. Run: npm test
Understanding Jest and writing effective tests is crucial for ensuring code quality and reliability in JavaScript projects.

14. Question: Explain the concept of serverless computing and how it relates to Node.js development.

Answer: Serverless computing is a cloud computing execution model where the cloud provider dynamically manages the allocation and provisioning of servers. Key characteristics include:

1. No Server Management: Developers don't need to worry about server provisioning or maintenance. 2. Pay-per-Use: You're charged based on the resources consumed by your application, not for idle server time. 3. Auto-scaling: The infrastructure automatically scales based on the application's needs. 4. Event-driven: Functions are typically triggered by events.
Relation to Node.js: - Node.js is well-suited for serverless due to its event-driven, non-blocking I/O model. - Platforms like AWS Lambda
Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.