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