diff --git a/.github/src/Roles/JavaScript.md b/.github/src/Roles/JavaScript.md index 576912f0..efff431e 100644 --- a/.github/src/Roles/JavaScript.md +++ b/.github/src/Roles/JavaScript.md @@ -1,54 +1,54 @@ ## JavaScript - To start asynchronous programming - - arrow function - - ...spread - - ...rest - - instanceof - - typeof - - destructuring - - generator - - iterator - - chaining - - yield - - Symbol - - class - - this - - super - - try..catch - - return - - new Error - - default parameters - - Object - - Array - - Map - - Set - - IIFE - - throw + - arrow function: 🖐️ used + - ...spread: 🖐️ used + - ...rest: 🖐️ used + - instanceof: 🖐️ used + - typeof: 🖐️ used + - destructuring: 🖐️ used + - generator: 🖐️ used + - iterator: 🖐️ used + - chaining: 🎓 known + - yield: 🎓 known + - Symbol: 🎓 known + - class: 🖐️ used + - this: 🖐️ used + - super: 🖐️ used + - try..catch: 🖐️ used + - return: 🖐️ used + - new Error: 🖐️ used + - default parameters: 🖐️ used + - Object: 🖐️ used + - Array: 🖐️ used + - Map: 🖐️ used + - Set: 🖐️ used + - IIFE: 🖐️ used + - throw: 🖐️ used - To start Node.js - - async function - - async generator - - async iterator - - optional chaining - - global - - globalThis - - getters and setters - - prototype - - equality operators - - logical operators - - ternary operator - - await - - template literal - - strict mode - - Reflect - - for await - - import - - export - - mixin - - extend - - Proxy - - timers - - EventEmitter - - Date - - BigInt - - npm + - async function: 🖐️ used + - async generator: 🎓 known + - async iterator: 🎓 known + - optional chaining: 🎓 known + - global: 🎓 known + - globalThis: 🎓 known + - getters and setters: 🖐️ used + - prototype: 🎓 known + - equality operators: 🖐️ used + - logical operators: 🖐️ used + - ternary operator: 🖐️ used + - await: 🖐️ used + - template literal: 🖐️ used + - strict mode: 🖐️ used + - Reflect: 🎓 known + - for await: 🎓 known + - import: 🖐️ used + - export: 🖐️ used + - mixin: 🎓 known + - extend: 🎓 known + - Proxy: 🎓 known + - timers: 🖐️ used + - EventEmitter: 🎓 known + - Date: 🖐️ used + - BigInt: 🖐️ used + - npm: 🎓 known diff --git a/.github/src/Roles/NodeJS.md b/.github/src/Roles/NodeJS.md index 6f381703..16d89345 100644 --- a/.github/src/Roles/NodeJS.md +++ b/.github/src/Roles/NodeJS.md @@ -477,18 +477,18 @@ - Resource leaks - Data race - Native addons - - C and C++ addons - - Rust addons - - Zig addons + - `C` and `C++` addons + - `Rust` addons + - `Zig` addons - NAN (Native Abstractions for Node.js) - Node-API (formerly N-API) - - NAPI C and C++ - - NAPI Rust - - NAPI Zig - - Webassembly WAT - - Webassembly C and C++ - - Webassembly Rust - - Webassembly Zig - - Webassembly AssemblyScript + - NAPI `C` and `C++` + - NAPI `Rust` + - NAPI `Zig` + - Webassembly `WAT` + - Webassembly `C` and `C++` + - Webassembly `Rust` + - Webassembly `Zig` + - Webassembly `AssemblyScript` - Shared memory - V8 binary serialization diff --git a/.github/src/skills.js b/.github/src/check.js similarity index 53% rename from .github/src/skills.js rename to .github/src/check.js index 1c1bdcb5..79942b0f 100644 --- a/.github/src/skills.js +++ b/.github/src/check.js @@ -6,6 +6,11 @@ const cp = require('node:child_process'); const metautil = require('metautil'); const concolor = require('concolor'); +const caption = concolor('b,white'); +const chapter = concolor('b,yellow'); +const fatal = concolor('b,white/red'); +const fixup = concolor('b,black/yellow'); + const TITLE = 'Software engineering self assessment'; const PARSING_TIMEOUT = 1000; const EXECUTION_TIMEOUT = 5000; @@ -22,33 +27,30 @@ const BADGE = `[![Skills](${BASE}?${STYLE})](${LINK})`; let exitCode = 0; -const fatal = concolor('b,white/red'); -const fixup = concolor('b,black/yellow'); - const wrongFormat = (msg, file) => { exitCode = 1; console.log(fatal` Wrong file format: ${msg} `); - console.log(`File: ${file}`); + console.log(fatal` File: ${file} `); }; const warnFixup = (msg, file) => { console.log(fixup` Fixup file format: ${msg} `); - console.log(`File: ${file}`); + console.log(fixup` File: ${file} `); }; const codeBlock = (code) => '```\n' + code + '\n```'; -const loadFile = async (file) => { - const fileName = path.join(PATH, file); - const data = await fs.readFile(fileName, 'utf8'); +const loadFile = async (filePath) => { + const fileName = path.basename(filePath); + const data = await fs.readFile(filePath, 'utf8'); if (data.includes('\r')) { - warnFixup('expected LF linebreaks, not CRLF or CR', file); + warnFixup('expected LF linebreaks, not CRLF or CR', fileName); } if (!data.startsWith('## ')) { - wrongFormat('no markdown «## Heading»', file); + wrongFormat('no markdown «## Heading»', fileName); } if (!data.endsWith('\n')) { - warnFixup('no newline at the end of file', file); + warnFixup('no newline at the end of file', fileName); } return data; }; @@ -114,13 +116,14 @@ const formatSkill = (line) => { return { skill, level }; }; -const getSkills = (data, file) => { +const getSkills = (data, file, options) => { const lines = data.split('\n'); if (lines.at(-1).trim() === '') lines.pop(); let section = ''; let empty = 0; + const sections = {}; + const skills = new Map(); const out = []; - const skills = []; for (const [i, s] of lines.entries()) { const line = s.trim(); if (line === '') { @@ -140,6 +143,7 @@ const getSkills = (data, file) => { if (s.startsWith('-')) { out.push(line); section = line.slice(1).trim(); + sections[section] = {}; continue; } if (s.startsWith(' -')) { @@ -147,15 +151,22 @@ const getSkills = (data, file) => { if (level === undefined) { const msg = 'not matching level and emoji'; wrongFormat(`${msg} «${line}» at line ${i + 1}`, file); - out.push(s + ' 👉 Warning: ' + msg); - skills.push(skill); + out.push(`${s} 👉 Warning: ${msg}`); + skills.set(skill, ''); continue; } - if (skills.includes(skill)) { + if (skills.has(skill) && options.unique) { warnFixup(`removed duplicate skill «${skill}» at line ${i + 1}`, file); } else { - out.push(level ? ` - ${skill}: ${level}` : ` - ${skill}`); - skills.push(skill); + if (level) { + out.push(` - ${skill}: ${level}`); + sections[section][skill] = level; + skills.set(skill, level); + } else { + out.push(` - ${skill}`); + sections[section][skill] = ''; + skills.set(skill, ''); + } } continue; } @@ -163,42 +174,106 @@ const getSkills = (data, file) => { } const output = out.join('\n') + '\n'; if (data !== output) { - const fileName = path.join(PATH, file); - fs.writeFile(fileName, output).catch(() => {}); - console.log(`Fixup: ${data.length} -> ${output.length} saved: ${file}`); + fs.writeFile(file, output).catch(() => {}); + const fileName = file.slice(PATH.length); + console.log(`Fixup: ${data.length} -> ${output.length} saved: ${fileName}`); } - return skills; + return { sections, skills }; }; -const analise = async (section) => { - const file = `Skills/${section}.md`; +const analise = async (dir, unit, options) => { + console.log(chapter` Unit: ${unit}`); + const file = `${dir}/${unit}.md`; const md = await loadFile(file); - const skills = getSkills(md, file); - console.log(concolor.info(`Skills: ${skills.length}`)); - return; + const data = getSkills(md, file, options); + const { sections, skills } = data; + const count = Object.keys(sections).length; + console.log(` Sections: ${count}, Skills: ${skills.size}\n`); + return data; }; -(async () => { - console.log(concolor.white(TITLE)); - console.log(concolor.info('Auto Checker')); - - const files = await fs.readdir(`${PATH}/Skills/`); - const sections = files +const loadDir = async (place, options = {}) => { + const dir = path.join(PATH, place); + const files = await fs.readdir(dir); + const units = files .filter((file) => file.endsWith('.md')) .map((file) => file.substring(0, file.length - '.md'.length)); - for (const section of sections) { - console.log(concolor`\nCheck: ${section}(b,white)`); - await analise(section); + const collection = {}; + for (const unit of units) { + collection[unit] = await analise(dir, unit, options); } + return collection; +}; - const badgeCode = codeBlock(BADGE); +const match = (expected, answered) => { + const todo = []; + for (const section in expected.sections) { + todo.push(`- ${section}`); + const needed = expected.sections[section]; + let count = 0; + const entries = Object.entries(needed); + for (const [skill, level] of entries) { + if (level) count++; + const actual = answered.skills.get(skill) || '🤷 unknown'; + todo.push(` - ${skill}: ${actual} ⟶ ${level}`); + } + } + return todo; +}; + +const getTotal = (answered) => { + const total = []; + for (const section in answered.sections) { + const skills = answered.sections[section]; + let count = 0; + const entries = Object.entries(skills); + for (const [skill, level] of entries) { + if (level) count++; + } + total.push(` - ${section}: ${count} of ${entries.length}`); + } + return total; +}; + +(async () => { + console.log(caption`${TITLE}`); + console.log('Auto Checker\n'); - const report = `## ${TITLE}\n\n${BADGE}\n\n${badgeCode}\n`; + console.log(caption`Load skills`); + const skills = await loadDir('Skills', { unique: true }); + + console.log(caption`Load roles`); + const roles = await loadDir('.github/src/Roles'); + + console.log(caption`Match profiles`); + const units = Object.keys(skills); + const todos = []; + const totals = ['## Assessment totals\n']; + for (const unit of units) { + console.log(chapter` Unit: ${unit}`); + const expected = roles[unit]; + const answered = skills[unit]; + if (expected) { + const todo = match(expected, answered); + todos.push(`\n## ${unit}\n`); + todos.push(...todo); + } + totals.push(`- ${unit}`); + const total = getTotal(answered); + totals.push(...total); + } + + const badgeCode = codeBlock(BADGE); + const report = [ + `## ${TITLE}\n\n${BADGE}\n\n${badgeCode}\n`, + ...totals, + ...todos, + ].join('\n') + '\n'; await fs.writeFile(`${PATH}/Profile/REPORT.md`, report); - const readme = await loadFile('.github/src/Templates/README.md'); - const newReadme = readme.replace('$BADGE', BADGE); - await fs.writeFile(`${PATH}/README.md`, newReadme); + const template = await loadFile(`${PATH}/.github/src/Templates/README.md`); + const readme = template.replace('$BADGE', BADGE); + await fs.writeFile(`${PATH}/README.md`, readme); console.log(''); process.exit(exitCode); diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 4be27914..8d60877f 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -19,12 +19,12 @@ jobs: ${{ runner.os }}-node- - run: npm ci working-directory: .github/src - - run: node skills.js + - run: node check.js working-directory: .github/src - name: Generate results run: | git config --global user.name "Metarhia skill bot" git config --global user.email "timur@metarhia.com" - git add ./Profile ./README.md + git add ./Profile ./README.md ./Skills git commit -m "Automated skill analysis" git push diff --git a/Profile/REPORT.md b/Profile/REPORT.md index e84bed6f..8c8aa154 100644 --- a/Profile/REPORT.md +++ b/Profile/REPORT.md @@ -1 +1,677 @@ ## Software engineering self assessment + +[![Skills](https://img.shields.io/badge/Self_Assessment-skills-009933?style=flat-square)](https://github.com///github) + +``` +[![Skills](https://img.shields.io/badge/Self_Assessment-skills-009933?style=flat-square)](https://github.com///github) +``` + +## Assessment totals + +- Architecture + - Application structure: 0 of 13 + - Application architecture: 0 of 25 + - Solution architecture: 0 of 10 + - Enterprise architecture: 0 of 6 +- Async + - Theory: 0 of 20 + - Async contracts: 0 of 18 + - Async adapters and utils: 0 of 5 + - Async abstractions interfaces: 0 of 11 + - JavaScript & Node.js specific: 0 of 19 + - Techniques: 0 of 11 +- JavaScript + - Language: 0 of 38 + - Statements: 0 of 18 + - Functions: 0 of 5 + - Data structures: 0 of 15 + - Infrastructure: 0 of 5 +- NodeJS + - Internals and concepts: 0 of 9 + - Modularity, layers and dependencies: 0 of 15 + - Environment: 0 of 6 + - Internal API: 0 of 27 + - Network: 0 of 28 + - Technique and tools: 0 of 16 + - Data access: 0 of 5 + - Error handling and debugging: 0 of 14 + - Integrations and bindings: 0 of 16 +- Paradigms + - Theory: 0 of 19 + - OOP basics: 0 of 20 + - Patterns: 0 of 22 +- Programming + - Concepts: 0 of 14 + - Syntax and concepts: 0 of 28 + - Functions: 0 of 22 + - Data structures: 0 of 23 + - Process & style: 0 of 26 + +## Async + +- For Node.js applied programming + - try..catch: 🤷 unknown ⟶ + - Callbacks: 🤷 unknown ⟶ + - Callback-last-error-first: 🤷 unknown ⟶ + - Promise: 🤷 unknown ⟶ + - Async/await: 🤷 unknown ⟶ + - Event: 🤷 unknown ⟶ + - Signal: 🤷 unknown ⟶ + - Stream: 🤷 unknown ⟶ + - Timers: 🤷 unknown ⟶ + - Callback hell: 🤷 unknown ⟶ + - Promise hell: 🤷 unknown ⟶ + - Race conditions: 🤷 unknown ⟶ + - Promise.all: 🤷 unknown ⟶ + - Promise.allSettled: 🤷 unknown ⟶ + - Promise.race: 🤷 unknown ⟶ + - Promise.any: 🤷 unknown ⟶ + - Error handling in async code: 🤷 unknown ⟶ +- To start Node.js + - Event loop: 🤷 unknown ⟶ + - Non-blocking: 🤷 unknown ⟶ + - Async I/O: 🤷 unknown ⟶ + - Thread: 🤷 unknown ⟶ + - Process: 🤷 unknown ⟶ + - Async Iterator: 🤷 unknown ⟶ + - Chain of responsibility: 🤷 unknown ⟶ + - Middleware: 🤷 unknown ⟶ + - callbackify: 🤷 unknown ⟶ + - promisify: 🤷 unknown ⟶ + - asyncify: 🤷 unknown ⟶ + - EventEmitter: 🤷 unknown ⟶ + - Observable/Observer: 🤷 unknown ⟶ + - Readable: 🤷 unknown ⟶ + - Writable: 🤷 unknown ⟶ + - Transform: 🤷 unknown ⟶ + - Async Pool: 🤷 unknown ⟶ + - Async Queue: 🤷 unknown ⟶ + - Async Collector: 🤷 unknown ⟶ + - setImmediate: 🤷 unknown ⟶ + - nextTick: 🤷 unknown ⟶ + - AbortController: 🤷 unknown ⟶ + - AbortSignal: 🤷 unknown ⟶ + - Web Locks API: 🤷 unknown ⟶ + - Revealing Constructor: 🤷 unknown ⟶ + - ref() and unref(): 🤷 unknown ⟶ +- For Node.js platform/system programming + - Thread pool: 🤷 unknown ⟶ + - Pattern Reactor: 🤷 unknown ⟶ + - CAS operations: 🤷 unknown ⟶ + - libuv: 🤷 unknown ⟶ + - Dead locks: 🤷 unknown ⟶ + - Live locks: 🤷 unknown ⟶ + - Concurrent programming: 🤷 unknown ⟶ + - Parallel programming: 🤷 unknown ⟶ + - Actor Model: 🤷 unknown ⟶ + - Thenable: 🤷 unknown ⟶ + - Sync generator: 🤷 unknown ⟶ + - Async Generator: 🤷 unknown ⟶ + - Coroutine: 🤷 unknown ⟶ + - Locks: 🤷 unknown ⟶ + - callbacks compose: 🤷 unknown ⟶ + - async compose: 🤷 unknown ⟶ + - Semaphore: 🤷 unknown ⟶ + - Mutex: 🤷 unknown ⟶ + - Spin Lock: 🤷 unknown ⟶ + - Promise unhandled rejection: 🤷 unknown ⟶ + - Promise double resolve: 🤷 unknown ⟶ + - Atomics: 🤷 unknown ⟶ + - High resolution clock: 🤷 unknown ⟶ + - Better stack traces with return await: 🤷 unknown ⟶ + - JSON streaming serialization: 🤷 unknown ⟶ + - AsyncLocalStorage: 🤷 unknown ⟶ + - AsyncResource: 🤷 unknown ⟶ + - RxJS library: 🤷 unknown ⟶ + - Async composition: 🤷 unknown ⟶ + - IPC: 🤷 unknown ⟶ + - Channel API: 🤷 unknown ⟶ + +## JavaScript + +- To start asynchronous programming + - arrow function: 🤷 unknown ⟶ 🖐️ used + - ...spread: 🤷 unknown ⟶ 🖐️ used + - ...rest: 🤷 unknown ⟶ 🖐️ used + - instanceof: 🤷 unknown ⟶ 🖐️ used + - typeof: 🤷 unknown ⟶ 🖐️ used + - destructuring: 🤷 unknown ⟶ 🖐️ used + - generator: 🤷 unknown ⟶ 🖐️ used + - iterator: 🤷 unknown ⟶ 🖐️ used + - chaining: 🤷 unknown ⟶ 🎓 known + - yield: 🤷 unknown ⟶ 🎓 known + - Symbol: 🤷 unknown ⟶ 🎓 known + - class: 🤷 unknown ⟶ 🖐️ used + - this: 🤷 unknown ⟶ 🖐️ used + - super: 🤷 unknown ⟶ 🖐️ used + - try..catch: 🤷 unknown ⟶ 🖐️ used + - return: 🤷 unknown ⟶ 🖐️ used + - new Error: 🤷 unknown ⟶ 🖐️ used + - default parameters: 🤷 unknown ⟶ 🖐️ used + - Object: 🤷 unknown ⟶ 🖐️ used + - Array: 🤷 unknown ⟶ 🖐️ used + - Map: 🤷 unknown ⟶ 🖐️ used + - Set: 🤷 unknown ⟶ 🖐️ used + - IIFE: 🤷 unknown ⟶ 🖐️ used + - throw: 🤷 unknown ⟶ 🖐️ used +- To start Node.js + - async function: 🤷 unknown ⟶ 🖐️ used + - async generator: 🤷 unknown ⟶ 🎓 known + - async iterator: 🤷 unknown ⟶ 🎓 known + - optional chaining: 🤷 unknown ⟶ 🎓 known + - global: 🤷 unknown ⟶ 🎓 known + - globalThis: 🤷 unknown ⟶ 🎓 known + - getters and setters: 🤷 unknown ⟶ 🖐️ used + - prototype: 🤷 unknown ⟶ 🎓 known + - equality operators: 🤷 unknown ⟶ 🖐️ used + - logical operators: 🤷 unknown ⟶ 🖐️ used + - ternary operator: 🤷 unknown ⟶ 🖐️ used + - await: 🤷 unknown ⟶ 🖐️ used + - template literal: 🤷 unknown ⟶ 🖐️ used + - strict mode: 🤷 unknown ⟶ 🖐️ used + - Reflect: 🤷 unknown ⟶ 🎓 known + - for await: 🤷 unknown ⟶ 🎓 known + - import: 🤷 unknown ⟶ 🖐️ used + - export: 🤷 unknown ⟶ 🖐️ used + - mixin: 🤷 unknown ⟶ 🎓 known + - extend: 🤷 unknown ⟶ 🎓 known + - Proxy: 🤷 unknown ⟶ 🎓 known + - timers: 🤷 unknown ⟶ 🖐️ used + - EventEmitter: 🤷 unknown ⟶ 🎓 known + - Date: 🤷 unknown ⟶ 🖐️ used + - BigInt: 🤷 unknown ⟶ 🖐️ used + - npm: 🤷 unknown ⟶ 🎓 known + +## NodeJS + +- API and domain logic developer + - Strong and weak sides of node.js: 🤷 unknown ⟶ + - Stateful and stateless servers: 🤷 unknown ⟶ + - Nonblocking I/O and blocking code: 🤷 unknown ⟶ + - CommonJS modules: 🤷 unknown ⟶ + - ECMAScript modules: 🤷 unknown ⟶ + - Modules as singletons: 🤷 unknown ⟶ + - Dependencies: 🤷 unknown ⟶ + - npm, node_modules: 🤷 unknown ⟶ + - package.json and package lock: 🤷 unknown ⟶ + - Dependency injection: 🤷 unknown ⟶ + - DI containers: 🤷 unknown ⟶ + - Coupling and cohesion: 🤷 unknown ⟶ + - Framework agnostic approach: 🤷 unknown ⟶ + - Streams API: 🤷 unknown ⟶ + - Crypto API: 🤷 unknown ⟶ + - Password hashing with crypto.scrypt: 🤷 unknown ⟶ + - File system API (sync and async): 🤷 unknown ⟶ + - Native fetch and nodejs/undici: 🤷 unknown ⟶ + - Generating crypto random UUID: 🤷 unknown ⟶ + - Module `node:url` vs new URL: 🤷 unknown ⟶ + - Module `node:assert`: 🤷 unknown ⟶ + - Blob, File, Buffer, module `node:buffer`: 🤷 unknown ⟶ + - Endpoint throttling: 🤷 unknown ⟶ + - HTTP(S): 🤷 unknown ⟶ + - TCP/SSL: 🤷 unknown ⟶ + - TLS: 🤷 unknown ⟶ + - Websocket: 🤷 unknown ⟶ + - REST: 🤷 unknown ⟶ + - RPC: 🤷 unknown ⟶ + - Routing: 🤷 unknown ⟶ + - DoS: 🤷 unknown ⟶ + - DDoS: 🤷 unknown ⟶ + - Path traversal: 🤷 unknown ⟶ + - DNS: 🤷 unknown ⟶ + - Fetch API: 🤷 unknown ⟶ + - IncomingMessage: 🤷 unknown ⟶ + - SQL injection: 🤷 unknown ⟶ + - SSL certificates: 🤷 unknown ⟶ + - Protocol agnostic approach: 🤷 unknown ⟶ + - Native test runner: 🤷 unknown ⟶ + - Logging: 🤷 unknown ⟶ + - Application configuring: 🤷 unknown ⟶ + - Testing: 🤷 unknown ⟶ + - CI/CD: 🤷 unknown ⟶ + - Readable: 🤷 unknown ⟶ + - Writable: 🤷 unknown ⟶ + - Transform: 🤷 unknown ⟶ + - back pressure: 🤷 unknown ⟶ + - Buffer: 🤷 unknown ⟶ + - Console: 🤷 unknown ⟶ + - Data access layer: 🤷 unknown ⟶ + - Repository: 🤷 unknown ⟶ + - Active record: 🤷 unknown ⟶ + - Query builder: 🤷 unknown ⟶ + - Object-Relational Mapping: 🤷 unknown ⟶ + - Error: 🤷 unknown ⟶ + - error.cause: 🤷 unknown ⟶ + - error.code: 🤷 unknown ⟶ + - error.message: 🤷 unknown ⟶ + - error.stack: 🤷 unknown ⟶ + - How to avoid mixins: 🤷 unknown ⟶ + - Uncaught exceptions: 🤷 unknown ⟶ + - Memory leaks: 🤷 unknown ⟶ + - Resource leaks: 🤷 unknown ⟶ + - Data race: 🤷 unknown ⟶ +- Enterprise applications + - Strong and weak sides of node.js: 🤷 unknown ⟶ + - Stateful and stateless servers: 🤷 unknown ⟶ + - Nonblocking I/O and blocking code: 🤷 unknown ⟶ + - Node.js LTS schedule: 🤷 unknown ⟶ + - CommonJS modules: 🤷 unknown ⟶ + - ECMAScript modules: 🤷 unknown ⟶ + - Modules as singletons: 🤷 unknown ⟶ + - Dependencies: 🤷 unknown ⟶ + - npm, node_modules: 🤷 unknown ⟶ + - package.json and package lock: 🤷 unknown ⟶ + - Dependency injection: 🤷 unknown ⟶ + - DI containers: 🤷 unknown ⟶ + - Coupling and cohesion: 🤷 unknown ⟶ + - Framework agnostic approach: 🤷 unknown ⟶ + - Command line arguments: 🤷 unknown ⟶ + - Node.js CLI: 🤷 unknown ⟶ + - Graceful shutdown: 🤷 unknown ⟶ + - Clustering: 🤷 unknown ⟶ + - Watch filesystem changes with --watch: 🤷 unknown ⟶ + - Streams API: 🤷 unknown ⟶ + - Crypto API: 🤷 unknown ⟶ + - Password hashing with crypto.scrypt: 🤷 unknown ⟶ + - File system API (sync and async): 🤷 unknown ⟶ + - Copy folder recursively: 🤷 unknown ⟶ + - Worker threads: 🤷 unknown ⟶ + - Native fetch and nodejs/undici: 🤷 unknown ⟶ + - worker_threads: 🤷 unknown ⟶ + - child_process: 🤷 unknown ⟶ + - Generating crypto random UUID: 🤷 unknown ⟶ + - Module `node:url` vs new URL: 🤷 unknown ⟶ + - Module `node:assert`: 🤷 unknown ⟶ + - Internationalization: 🤷 unknown ⟶ + - Blob, File, Buffer, module `node:buffer`: 🤷 unknown ⟶ + - Module `node:zlib`: 🤷 unknown ⟶ + - Endpoint throttling: 🤷 unknown ⟶ + - HTTP(S): 🤷 unknown ⟶ + - TCP/SSL: 🤷 unknown ⟶ + - TLS: 🤷 unknown ⟶ + - Websocket: 🤷 unknown ⟶ + - SSE: 🤷 unknown ⟶ + - Long polling: 🤷 unknown ⟶ + - REST: 🤷 unknown ⟶ + - RPC: 🤷 unknown ⟶ + - Routing: 🤷 unknown ⟶ + - DoS: 🤷 unknown ⟶ + - DDoS: 🤷 unknown ⟶ + - XSS: 🤷 unknown ⟶ + - Path traversal: 🤷 unknown ⟶ + - CSRF: 🤷 unknown ⟶ + - DNS: 🤷 unknown ⟶ + - Fetch API: 🤷 unknown ⟶ + - IncomingMessage: 🤷 unknown ⟶ + - SQL injection: 🤷 unknown ⟶ + - noDelay: 🤷 unknown ⟶ + - keep-alive: 🤷 unknown ⟶ + - ALPN: 🤷 unknown ⟶ + - SNI callback: 🤷 unknown ⟶ + - SSL certificates: 🤷 unknown ⟶ + - Protocol agnostic approach: 🤷 unknown ⟶ + - Native test runner: 🤷 unknown ⟶ + - Logging: 🤷 unknown ⟶ + - Application configuring: 🤷 unknown ⟶ + - Testing: 🤷 unknown ⟶ + - CI/CD: 🤷 unknown ⟶ + - Readable: 🤷 unknown ⟶ + - Writable: 🤷 unknown ⟶ + - Transform: 🤷 unknown ⟶ + - back pressure: 🤷 unknown ⟶ + - Buffer: 🤷 unknown ⟶ + - Console: 🤷 unknown ⟶ + - Inspector: 🤷 unknown ⟶ + - Reliability: 🤷 unknown ⟶ + - Quality: 🤷 unknown ⟶ + - Availability: 🤷 unknown ⟶ + - Flexibility: 🤷 unknown ⟶ + - Data access layer: 🤷 unknown ⟶ + - Repository: 🤷 unknown ⟶ + - Active record: 🤷 unknown ⟶ + - Query builder: 🤷 unknown ⟶ + - Object-Relational Mapping: 🤷 unknown ⟶ + - Error: 🤷 unknown ⟶ + - error.cause: 🤷 unknown ⟶ + - error.code: 🤷 unknown ⟶ + - error.message: 🤷 unknown ⟶ + - error.stack: 🤷 unknown ⟶ + - How to avoid mixins: 🤷 unknown ⟶ + - Error.captureStackTrace: 🤷 unknown ⟶ + - Uncaught exceptions: 🤷 unknown ⟶ + - Heap dump: 🤷 unknown ⟶ + - Debugging tools: 🤷 unknown ⟶ + - Flame graph: 🤷 unknown ⟶ + - Memory leaks: 🤷 unknown ⟶ + - Resource leaks: 🤷 unknown ⟶ + - Data race: 🤷 unknown ⟶ +- Real-Time, gamedev, messaging + - Strong and weak sides of node.js: 🤷 unknown ⟶ + - Stateful and stateless servers: 🤷 unknown ⟶ + - Nonblocking I/O and blocking code: 🤷 unknown ⟶ + - Event loop phases: 🤷 unknown ⟶ + - Event loop microtasks and macrotasks: 🤷 unknown ⟶ + - I/O-bound, CPU-bound, memory-bound tasks: 🤷 unknown ⟶ + - Interactive applications (close to real-time): 🤷 unknown ⟶ + - CommonJS modules: 🤷 unknown ⟶ + - ECMAScript modules: 🤷 unknown ⟶ + - Dependencies: 🤷 unknown ⟶ + - npm, node_modules: 🤷 unknown ⟶ + - package.json and package lock: 🤷 unknown ⟶ + - Dependency injection: 🤷 unknown ⟶ + - DI containers: 🤷 unknown ⟶ + - Coupling and cohesion: 🤷 unknown ⟶ + - Framework agnostic approach: 🤷 unknown ⟶ + - Graceful shutdown: 🤷 unknown ⟶ + - Clustering: 🤷 unknown ⟶ + - Streams API: 🤷 unknown ⟶ + - File system API (sync and async): 🤷 unknown ⟶ + - Worker threads: 🤷 unknown ⟶ + - Native fetch and nodejs/undici: 🤷 unknown ⟶ + - Stream back pressure: 🤷 unknown ⟶ + - worker_threads: 🤷 unknown ⟶ + - child_process: 🤷 unknown ⟶ + - Generating crypto random UUID: 🤷 unknown ⟶ + - Endpoint throttling: 🤷 unknown ⟶ + - HTTP(S): 🤷 unknown ⟶ + - TCP/SSL: 🤷 unknown ⟶ + - UDP: 🤷 unknown ⟶ + - TLS: 🤷 unknown ⟶ + - Websocket: 🤷 unknown ⟶ + - SSE: 🤷 unknown ⟶ + - HTTP/3 (QUIC): 🤷 unknown ⟶ + - Long polling: 🤷 unknown ⟶ + - REST: 🤷 unknown ⟶ + - RPC: 🤷 unknown ⟶ + - Routing: 🤷 unknown ⟶ + - DoS: 🤷 unknown ⟶ + - DDoS: 🤷 unknown ⟶ + - XSS: 🤷 unknown ⟶ + - Path traversal: 🤷 unknown ⟶ + - DNS: 🤷 unknown ⟶ + - Fetch API: 🤷 unknown ⟶ + - IncomingMessage: 🤷 unknown ⟶ + - noDelay: 🤷 unknown ⟶ + - keep-alive: 🤷 unknown ⟶ + - Protocol agnostic approach: 🤷 unknown ⟶ + - Logging: 🤷 unknown ⟶ + - Application configuring: 🤷 unknown ⟶ + - Testing: 🤷 unknown ⟶ + - CI/CD: 🤷 unknown ⟶ + - Readable: 🤷 unknown ⟶ + - Writable: 🤷 unknown ⟶ + - Transform: 🤷 unknown ⟶ + - back pressure: 🤷 unknown ⟶ + - Buffer: 🤷 unknown ⟶ + - Inspector: 🤷 unknown ⟶ + - Reliability: 🤷 unknown ⟶ + - Availability: 🤷 unknown ⟶ + - Data access layer: 🤷 unknown ⟶ + - Error: 🤷 unknown ⟶ + - error.cause: 🤷 unknown ⟶ + - error.code: 🤷 unknown ⟶ + - error.message: 🤷 unknown ⟶ + - error.stack: 🤷 unknown ⟶ + - How to avoid mixins: 🤷 unknown ⟶ + - Heap dump: 🤷 unknown ⟶ + - Memory leaks: 🤷 unknown ⟶ + - Resource leaks: 🤷 unknown ⟶ + - Data race: 🤷 unknown ⟶ +- Web and Frontend + - Strong and weak sides of node.js: 🤷 unknown ⟶ + - Stateful and stateless servers: 🤷 unknown ⟶ + - CommonJS modules: 🤷 unknown ⟶ + - ECMAScript modules: 🤷 unknown ⟶ + - Dependencies: 🤷 unknown ⟶ + - npm, node_modules: 🤷 unknown ⟶ + - package.json and package lock: 🤷 unknown ⟶ + - Dependency injection: 🤷 unknown ⟶ + - DI containers: 🤷 unknown ⟶ + - Coupling and cohesion: 🤷 unknown ⟶ + - Framework agnostic approach: 🤷 unknown ⟶ + - Web Streams API: 🤷 unknown ⟶ + - Web Crypto API: 🤷 unknown ⟶ + - Native fetch and nodejs/undici: 🤷 unknown ⟶ + - Module `node:url` vs new URL: 🤷 unknown ⟶ + - Internationalization: 🤷 unknown ⟶ + - HTTP(S): 🤷 unknown ⟶ + - TCP/SSL: 🤷 unknown ⟶ + - Websocket: 🤷 unknown ⟶ + - REST: 🤷 unknown ⟶ + - RPC: 🤷 unknown ⟶ + - DNS: 🤷 unknown ⟶ + - Fetch API: 🤷 unknown ⟶ + - IncomingMessage: 🤷 unknown ⟶ + - SSL certificates: 🤷 unknown ⟶ + - Protocol agnostic approach: 🤷 unknown ⟶ + - Native test runner: 🤷 unknown ⟶ + - Testing: 🤷 unknown ⟶ + - CI/CD: 🤷 unknown ⟶ + - Console: 🤷 unknown ⟶ + - Inspector: 🤷 unknown ⟶ + - Data access layer: 🤷 unknown ⟶ + - Error: 🤷 unknown ⟶ + - error.cause: 🤷 unknown ⟶ + - error.code: 🤷 unknown ⟶ + - error.message: 🤷 unknown ⟶ + - error.stack: 🤷 unknown ⟶ + - How to avoid mixins: 🤷 unknown ⟶ + - Heap dump: 🤷 unknown ⟶ + - Debugging tools: 🤷 unknown ⟶ + - Memory leaks: 🤷 unknown ⟶ + - Resource leaks: 🤷 unknown ⟶ + - Data race: 🤷 unknown ⟶ +- Fullstack development + - Strong and weak sides of node.js: 🤷 unknown ⟶ + - Stateful and stateless servers: 🤷 unknown ⟶ + - Nonblocking I/O and blocking code: 🤷 unknown ⟶ + - CommonJS modules: 🤷 unknown ⟶ + - ECMAScript modules: 🤷 unknown ⟶ + - Dependencies: 🤷 unknown ⟶ + - npm, node_modules: 🤷 unknown ⟶ + - package.json and package lock: 🤷 unknown ⟶ + - Dependency injection: 🤷 unknown ⟶ + - DI containers: 🤷 unknown ⟶ + - Coupling and cohesion: 🤷 unknown ⟶ + - Framework agnostic approach: 🤷 unknown ⟶ + - Streams API: 🤷 unknown ⟶ + - Web Streams API: 🤷 unknown ⟶ + - Crypto API: 🤷 unknown ⟶ + - Password hashing with crypto.scrypt: 🤷 unknown ⟶ + - Web Crypto API: 🤷 unknown ⟶ + - File system API (sync and async): 🤷 unknown ⟶ + - Native fetch and nodejs/undici: 🤷 unknown ⟶ + - Module `node:url` vs new URL: 🤷 unknown ⟶ + - Module `node:assert`: 🤷 unknown ⟶ + - Internationalization: 🤷 unknown ⟶ + - Blob, File, Buffer, module `node:buffer`: 🤷 unknown ⟶ + - Module `node:zlib`: 🤷 unknown ⟶ + - Endpoint throttling: 🤷 unknown ⟶ + - HTTP(S): 🤷 unknown ⟶ + - TCP/SSL: 🤷 unknown ⟶ + - TLS: 🤷 unknown ⟶ + - Websocket: 🤷 unknown ⟶ + - SSE: 🤷 unknown ⟶ + - Long polling: 🤷 unknown ⟶ + - REST: 🤷 unknown ⟶ + - RPC: 🤷 unknown ⟶ + - Routing: 🤷 unknown ⟶ + - DoS: 🤷 unknown ⟶ + - DDoS: 🤷 unknown ⟶ + - XSS: 🤷 unknown ⟶ + - Path traversal: 🤷 unknown ⟶ + - CSRF: 🤷 unknown ⟶ + - DNS: 🤷 unknown ⟶ + - Fetch API: 🤷 unknown ⟶ + - IncomingMessage: 🤷 unknown ⟶ + - SQL injection: 🤷 unknown ⟶ + - noDelay: 🤷 unknown ⟶ + - keep-alive: 🤷 unknown ⟶ + - SSL certificates: 🤷 unknown ⟶ + - Protocol agnostic approach: 🤷 unknown ⟶ + - Native test runner: 🤷 unknown ⟶ + - Logging: 🤷 unknown ⟶ + - Application configuring: 🤷 unknown ⟶ + - Testing: 🤷 unknown ⟶ + - CI/CD: 🤷 unknown ⟶ + - Readable: 🤷 unknown ⟶ + - Writable: 🤷 unknown ⟶ + - Transform: 🤷 unknown ⟶ + - back pressure: 🤷 unknown ⟶ + - Buffer: 🤷 unknown ⟶ + - Console: 🤷 unknown ⟶ + - Inspector: 🤷 unknown ⟶ + - Reliability: 🤷 unknown ⟶ + - Data access layer: 🤷 unknown ⟶ + - Repository: 🤷 unknown ⟶ + - Active record: 🤷 unknown ⟶ + - Query builder: 🤷 unknown ⟶ + - Object-Relational Mapping: 🤷 unknown ⟶ + - Error: 🤷 unknown ⟶ + - error.cause: 🤷 unknown ⟶ + - error.code: 🤷 unknown ⟶ + - error.message: 🤷 unknown ⟶ + - error.stack: 🤷 unknown ⟶ + - How to avoid mixins: 🤷 unknown ⟶ + - Uncaught exceptions: 🤷 unknown ⟶ + - Heap dump: 🤷 unknown ⟶ + - Debugging tools: 🤷 unknown ⟶ + - Memory leaks: 🤷 unknown ⟶ + - Resource leaks: 🤷 unknown ⟶ + - Data race: 🤷 unknown ⟶ +- Platform/system development + - Strong and weak sides of node.js: 🤷 unknown ⟶ + - Stateful and stateless servers: 🤷 unknown ⟶ + - Nonblocking I/O and blocking code: 🤷 unknown ⟶ + - Event loop phases: 🤷 unknown ⟶ + - Event loop microtasks and macrotasks: 🤷 unknown ⟶ + - Garbage collection: 🤷 unknown ⟶ + - Node.js LTS schedule: 🤷 unknown ⟶ + - I/O-bound, CPU-bound, memory-bound tasks: 🤷 unknown ⟶ + - CommonJS modules: 🤷 unknown ⟶ + - ECMAScript modules: 🤷 unknown ⟶ + - Module `node:module`: 🤷 unknown ⟶ + - Caching in CJS and ESM: 🤷 unknown ⟶ + - Modules as singletons: 🤷 unknown ⟶ + - Contexts and scripts module `node:vm`: 🤷 unknown ⟶ + - Dependencies: 🤷 unknown ⟶ + - npm, node_modules: 🤷 unknown ⟶ + - package.json and package lock: 🤷 unknown ⟶ + - Module-based permissions model: 🤷 unknown ⟶ + - Isolation with modularity: 🤷 unknown ⟶ + - Dependency injection: 🤷 unknown ⟶ + - DI containers: 🤷 unknown ⟶ + - Coupling and cohesion: 🤷 unknown ⟶ + - Framework agnostic approach: 🤷 unknown ⟶ + - Command line arguments: 🤷 unknown ⟶ + - Node.js CLI: 🤷 unknown ⟶ + - Process-based permissions: 🤷 unknown ⟶ + - Graceful shutdown: 🤷 unknown ⟶ + - Clustering: 🤷 unknown ⟶ + - Watch filesystem changes with --watch: 🤷 unknown ⟶ + - Streams API: 🤷 unknown ⟶ + - Web Streams API: 🤷 unknown ⟶ + - Crypto API: 🤷 unknown ⟶ + - Password hashing with crypto.scrypt: 🤷 unknown ⟶ + - Web Crypto API: 🤷 unknown ⟶ + - File system API (sync and async): 🤷 unknown ⟶ + - Copy folder recursively: 🤷 unknown ⟶ + - Worker threads: 🤷 unknown ⟶ + - Performance hooks: 🤷 unknown ⟶ + - Native fetch and nodejs/undici: 🤷 unknown ⟶ + - async_hooks: 🤷 unknown ⟶ + - AsyncLocalStorage: 🤷 unknown ⟶ + - AsyncResource: 🤷 unknown ⟶ + - Deprecated domain API: 🤷 unknown ⟶ + - Node.js single executable: 🤷 unknown ⟶ + - Stream back pressure: 🤷 unknown ⟶ + - SharedArrayBuffer: 🤷 unknown ⟶ + - worker_threads: 🤷 unknown ⟶ + - child_process: 🤷 unknown ⟶ + - MessageChannel, MessagePort: 🤷 unknown ⟶ + - BroadcastChannel: 🤷 unknown ⟶ + - Generating crypto random UUID: 🤷 unknown ⟶ + - Module `node:url` vs new URL: 🤷 unknown ⟶ + - Module `node:assert`: 🤷 unknown ⟶ + - Internationalization: 🤷 unknown ⟶ + - Blob, File, Buffer, module `node:buffer`: 🤷 unknown ⟶ + - Module `node:zlib`: 🤷 unknown ⟶ + - IP sticky sessions: 🤷 unknown ⟶ + - Endpoint throttling: 🤷 unknown ⟶ + - HTTP(S): 🤷 unknown ⟶ + - TCP/SSL: 🤷 unknown ⟶ + - UDP: 🤷 unknown ⟶ + - TLS: 🤷 unknown ⟶ + - Websocket: 🤷 unknown ⟶ + - SSE: 🤷 unknown ⟶ + - HTTP/3 (QUIC): 🤷 unknown ⟶ + - Long polling: 🤷 unknown ⟶ + - REST: 🤷 unknown ⟶ + - RPC: 🤷 unknown ⟶ + - Routing: 🤷 unknown ⟶ + - DoS: 🤷 unknown ⟶ + - DDoS: 🤷 unknown ⟶ + - XSS: 🤷 unknown ⟶ + - Path traversal: 🤷 unknown ⟶ + - CSRF: 🤷 unknown ⟶ + - DNS: 🤷 unknown ⟶ + - Fetch API: 🤷 unknown ⟶ + - IncomingMessage: 🤷 unknown ⟶ + - SQL injection: 🤷 unknown ⟶ + - noDelay: 🤷 unknown ⟶ + - keep-alive: 🤷 unknown ⟶ + - ALPN: 🤷 unknown ⟶ + - SNI callback: 🤷 unknown ⟶ + - SSL certificates: 🤷 unknown ⟶ + - Protocol agnostic approach: 🤷 unknown ⟶ + - Native test runner: 🤷 unknown ⟶ + - Logging: 🤷 unknown ⟶ + - Application configuring: 🤷 unknown ⟶ + - Testing: 🤷 unknown ⟶ + - CI/CD: 🤷 unknown ⟶ + - Readable: 🤷 unknown ⟶ + - Writable: 🤷 unknown ⟶ + - Transform: 🤷 unknown ⟶ + - back pressure: 🤷 unknown ⟶ + - Buffer: 🤷 unknown ⟶ + - Console: 🤷 unknown ⟶ + - Inspector: 🤷 unknown ⟶ + - Reliability: 🤷 unknown ⟶ + - Quality: 🤷 unknown ⟶ + - Availability: 🤷 unknown ⟶ + - Flexibility: 🤷 unknown ⟶ + - Data access layer: 🤷 unknown ⟶ + - Repository: 🤷 unknown ⟶ + - Active record: 🤷 unknown ⟶ + - Query builder: 🤷 unknown ⟶ + - Object-Relational Mapping: 🤷 unknown ⟶ + - Error: 🤷 unknown ⟶ + - error.cause: 🤷 unknown ⟶ + - error.code: 🤷 unknown ⟶ + - error.message: 🤷 unknown ⟶ + - error.stack: 🤷 unknown ⟶ + - How to avoid mixins: 🤷 unknown ⟶ + - Error.captureStackTrace: 🤷 unknown ⟶ + - Uncaught exceptions: 🤷 unknown ⟶ + - Heap dump: 🤷 unknown ⟶ + - Debugging tools: 🤷 unknown ⟶ + - Flame graph: 🤷 unknown ⟶ + - Memory leaks: 🤷 unknown ⟶ + - Resource leaks: 🤷 unknown ⟶ + - Data race: 🤷 unknown ⟶ + - Native addons: 🤷 unknown ⟶ + - `C` and `C++` addons: 🤷 unknown ⟶ + - `Rust` addons: 🤷 unknown ⟶ + - `Zig` addons: 🤷 unknown ⟶ + - NAN (Native Abstractions for Node.js): 🤷 unknown ⟶ + - Node-API (formerly N-API): 🤷 unknown ⟶ + - NAPI `C` and `C++`: 🤷 unknown ⟶ + - NAPI `Rust`: 🤷 unknown ⟶ + - NAPI `Zig`: 🤷 unknown ⟶ + - Webassembly `WAT`: 🤷 unknown ⟶ + - Webassembly `C` and `C++`: 🤷 unknown ⟶ + - Webassembly `Rust`: 🤷 unknown ⟶ + - Webassembly `Zig`: 🤷 unknown ⟶ + - Webassembly `AssemblyScript`: 🤷 unknown ⟶ + - Shared memory: 🤷 unknown ⟶ + - V8 binary serialization: 🤷 unknown ⟶ diff --git a/README.md b/README.md index a581d940..20fd0a17 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ ## Software engineering self assessment +[![Skills](https://img.shields.io/badge/Self_Assessment-skills-009933?style=flat-square)](https://github.com///github) + ## Skills - [Programming fundamentals](Skills/Programming.md) diff --git a/Skills/Architecture.md b/Skills/Architecture.md index e342f849..254da6e8 100644 --- a/Skills/Architecture.md +++ b/Skills/Architecture.md @@ -40,7 +40,6 @@ - SaaS - FaaS clouds - Serverless - - Metaprogramming - Solution architecture - A software requirements specification (SRS) - Solution visions @@ -59,4 +58,3 @@ - Enterprise vision - Enterprise capabilities - Project scope - - Work breakdown structure diff --git a/Skills/NodeJS.md b/Skills/NodeJS.md index 713e692d..98162396 100644 --- a/Skills/NodeJS.md +++ b/Skills/NodeJS.md @@ -130,18 +130,18 @@ - Data race - Integrations and bindings - Native addons - - C and C++ addons - - Rust addons - - Zig addons + - `C` and `C++` addons + - `Rust` addons + - `Zig` addons - NAN (Native Abstractions for Node.js) - Node-API (formerly N-API) - - NAPI C and C++ - - NAPI Rust - - NAPI Zig - - Webassembly WAT - - Webassembly C and C++ - - Webassembly Rust - - Webassembly Zig - - Webassembly AssemblyScript + - NAPI `C` and `C++` + - NAPI `Rust` + - NAPI `Zig` + - Webassembly `WAT` + - Webassembly `C` and `C++` + - Webassembly `Rust` + - Webassembly `Zig` + - Webassembly `AssemblyScript` - Shared memory - V8 binary serialization pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy