From 37358c23b67dfe11cc4e01020093b7bc829ac1ad Mon Sep 17 00:00:00 2001 From: Timur Shemsedinov Date: Mon, 22 Jan 2024 23:02:27 +0200 Subject: [PATCH 01/10] Fix architecture skills --- Skills/Architecture.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/Skills/Architecture.md b/Skills/Architecture.md index e342f849f..254da6e85 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 From a4b096a8e8c2e625153c4d598af1211236911163 Mon Sep 17 00:00:00 2001 From: Timur Shemsedinov Date: Mon, 22 Jan 2024 23:02:46 +0200 Subject: [PATCH 02/10] Fix node.js skills --- Skills/NodeJS.md | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/Skills/NodeJS.md b/Skills/NodeJS.md index 713e692db..981623960 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 From 65f0cd29f1a06b16ef201378febbbd751cced3d4 Mon Sep 17 00:00:00 2001 From: Timur Shemsedinov Date: Mon, 22 Jan 2024 23:05:58 +0200 Subject: [PATCH 03/10] Load roles --- .github/src/skills.js | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/.github/src/skills.js b/.github/src/skills.js index 1c1bdcb52..f8dfa127d 100644 --- a/.github/src/skills.js +++ b/.github/src/skills.js @@ -171,26 +171,40 @@ const getSkills = (data, file) => { }; const analise = async (section) => { + console.log(concolor`\nCheck: ${section}(b,white)`); const file = `Skills/${section}.md`; const md = await loadFile(file); const skills = getSkills(md, file); console.log(concolor.info(`Skills: ${skills.length}`)); - return; +}; + +const match = async (role) => { + console.log(concolor`\nRoles: ${role}(b,white)`); + const file = `.github/src/Roles/${role}.md`; + const md = await loadFile(file); + console.log(concolor.info(`Size: ${md.length}`)); }; (async () => { console.log(concolor.white(TITLE)); console.log(concolor.info('Auto Checker')); - const files = await fs.readdir(`${PATH}/Skills/`); - const sections = files + const skillFiles = await fs.readdir(`${PATH}/Skills/`); + const sections = skillFiles .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 roleFiles = await fs.readdir(`${PATH}/.github/src/Roles/`); + const roles = roleFiles + .filter((file) => file.endsWith('.md')) + .map((file) => file.substring(0, file.length - '.md'.length)); + for (const role of roles) { + await match(role); + } + const badgeCode = codeBlock(BADGE); const report = `## ${TITLE}\n\n${BADGE}\n\n${badgeCode}\n`; From c60b062f53757c4facd1531a825e9ee01591b412 Mon Sep 17 00:00:00 2001 From: Timur Shemsedinov Date: Tue, 23 Jan 2024 08:29:16 +0200 Subject: [PATCH 04/10] Optimize auto checker --- .github/src/skills.js | 71 ++++++++++++++++++++++++++++--------------- 1 file changed, 47 insertions(+), 24 deletions(-) diff --git a/.github/src/skills.js b/.github/src/skills.js index f8dfa127d..1ad5840ed 100644 --- a/.github/src/skills.js +++ b/.github/src/skills.js @@ -6,7 +6,11 @@ const cp = require('node:child_process'); const metautil = require('metautil'); const concolor = require('concolor'); -const TITLE = 'Software engineering self assessment'; +const caption = concolor('b,white'); +const fatal = concolor('b,white/red'); +const fixup = concolor('b,black/yellow'); + +const TITLE = caption`Software engineering self assessment`; const PARSING_TIMEOUT = 1000; const EXECUTION_TIMEOUT = 5000; @@ -22,9 +26,6 @@ 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} `); @@ -147,14 +148,14 @@ 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); + out.push(`${s} 👉 Warning: ${msg}`); skills.push(skill); continue; } if (skills.includes(skill)) { warnFixup(`removed duplicate skill «${skill}» at line ${i + 1}`, file); } else { - out.push(level ? ` - ${skill}: ${level}` : ` - ${skill}`); + out.push(` - ${skill}${level ? ': ' + level : ''}`); skills.push(skill); } continue; @@ -170,40 +171,62 @@ const getSkills = (data, file) => { return skills; }; +const getRoles = (data, file) => { + const lines = data.split('\n'); + if (lines.at(-1).trim() === '') lines.pop(); + let section = ''; + const roles = {}; + for (const [i, s] of lines.entries()) { + const line = s.trim(); + if (s.startsWith('-')) { + section = line.slice(1).trim(); + roles[section] = []; + continue; + } + if (s.startsWith(' -')) { + const skill = line.slice(1).trim(); + roles[section].push(skill); + } + } + return roles; +}; + const analise = async (section) => { - console.log(concolor`\nCheck: ${section}(b,white)`); + console.log(caption`Skills: ${section}`); const file = `Skills/${section}.md`; const md = await loadFile(file); const skills = getSkills(md, file); - console.log(concolor.info(`Skills: ${skills.length}`)); + console.log(`Count: ${skills.length}\n`); + return skills; }; const match = async (role) => { - console.log(concolor`\nRoles: ${role}(b,white)`); + console.log(caption`Roles: ${role}`); const file = `.github/src/Roles/${role}.md`; const md = await loadFile(file); - console.log(concolor.info(`Size: ${md.length}`)); + const roles = getRoles(md, file); + console.log(`Count: ${Object.keys(roles).length}\n`); + return roles; }; -(async () => { - console.log(concolor.white(TITLE)); - console.log(concolor.info('Auto Checker')); - - const skillFiles = await fs.readdir(`${PATH}/Skills/`); - const sections = skillFiles +const loadDir = async (dir, mapper) => { + const files = await fs.readdir(dir); + const sections = files .filter((file) => file.endsWith('.md')) .map((file) => file.substring(0, file.length - '.md'.length)); + const collection = {}; for (const section of sections) { - await analise(section); + collection[section] = await mapper(section); } + return collection; +}; - const roleFiles = await fs.readdir(`${PATH}/.github/src/Roles/`); - const roles = roleFiles - .filter((file) => file.endsWith('.md')) - .map((file) => file.substring(0, file.length - '.md'.length)); - for (const role of roles) { - await match(role); - } +(async () => { + console.log(TITLE); + console.log('Auto Checker\n'); + + const skills = await loadDir(`${PATH}/Skills/`, analise); + const roles = await loadDir(`${PATH}/.github/src/Roles/`, match); const badgeCode = codeBlock(BADGE); From 47026b13b8dce9042005d0c03dba42654eee44ad Mon Sep 17 00:00:00 2001 From: Timur Shemsedinov Date: Tue, 23 Jan 2024 15:16:24 +0200 Subject: [PATCH 05/10] fixup! Fix node.js skills --- .github/src/Roles/NodeJS.md | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/.github/src/Roles/NodeJS.md b/.github/src/Roles/NodeJS.md index 6f381703d..16d89345a 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 From 666043e17f0722327006050ef9bf99bc80e2d16c Mon Sep 17 00:00:00 2001 From: Timur Shemsedinov Date: Tue, 23 Jan 2024 17:19:59 +0200 Subject: [PATCH 06/10] Unify skills and roles loader --- .github/src/skills.js | 111 +++++++++++++++++------------------------- 1 file changed, 46 insertions(+), 65 deletions(-) diff --git a/.github/src/skills.js b/.github/src/skills.js index 1ad5840ed..2b815d798 100644 --- a/.github/src/skills.js +++ b/.github/src/skills.js @@ -10,7 +10,7 @@ const caption = concolor('b,white'); const fatal = concolor('b,white/red'); const fixup = concolor('b,black/yellow'); -const TITLE = caption`Software engineering self assessment`; +const TITLE = 'Software engineering self assessment'; const PARSING_TIMEOUT = 1000; const EXECUTION_TIMEOUT = 5000; @@ -29,27 +29,27 @@ let exitCode = 0; 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; }; @@ -115,13 +115,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 Set(); const out = []; - const skills = []; for (const [i, s] of lines.entries()) { const line = s.trim(); if (line === '') { @@ -141,6 +142,7 @@ const getSkills = (data, file) => { if (s.startsWith('-')) { out.push(line); section = line.slice(1).trim(); + sections[section] = {}; continue; } if (s.startsWith(' -')) { @@ -149,14 +151,20 @@ const getSkills = (data, file) => { const msg = 'not matching level and emoji'; wrongFormat(`${msg} «${line}» at line ${i + 1}`, file); out.push(`${s} 👉 Warning: ${msg}`); - skills.push(skill); + skills.add(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(` - ${skill}${level ? ': ' + level : ''}`); - skills.push(skill); + if (level) { + out.push(` - ${skill}: ${level}`); + sections[section][skill] = level; + } else { + out.push(` - ${skill}`); + sections[section][skill] = ''; + } + skills.add(skill); } continue; } @@ -164,78 +172,51 @@ 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 getRoles = (data, file) => { - const lines = data.split('\n'); - if (lines.at(-1).trim() === '') lines.pop(); - let section = ''; - const roles = {}; - for (const [i, s] of lines.entries()) { - const line = s.trim(); - if (s.startsWith('-')) { - section = line.slice(1).trim(); - roles[section] = []; - continue; - } - if (s.startsWith(' -')) { - const skill = line.slice(1).trim(); - roles[section].push(skill); - } - } - return roles; -}; - -const analise = async (section) => { - console.log(caption`Skills: ${section}`); - const file = `Skills/${section}.md`; +const analise = async (dir, unit, options) => { + console.log(caption`Unit: ${unit}`); + const file = `${dir}/${unit}.md`; const md = await loadFile(file); - const skills = getSkills(md, file); - console.log(`Count: ${skills.length}\n`); - return skills; -}; - -const match = async (role) => { - console.log(caption`Roles: ${role}`); - const file = `.github/src/Roles/${role}.md`; - const md = await loadFile(file); - const roles = getRoles(md, file); - console.log(`Count: ${Object.keys(roles).length}\n`); - return roles; + 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; }; -const loadDir = async (dir, mapper) => { +const loadDir = async (place, options = {}) => { + const dir = path.join(PATH, place); const files = await fs.readdir(dir); - const sections = files + const units = files .filter((file) => file.endsWith('.md')) .map((file) => file.substring(0, file.length - '.md'.length)); const collection = {}; - for (const section of sections) { - collection[section] = await mapper(section); + for (const unit of units) { + collection[unit] = await analise(dir, unit, options); } return collection; }; (async () => { - console.log(TITLE); + console.log(caption`${TITLE}`); console.log('Auto Checker\n'); - const skills = await loadDir(`${PATH}/Skills/`, analise); - const roles = await loadDir(`${PATH}/.github/src/Roles/`, match); + const skills = await loadDir('Skills', { unique: true }); + const roles = await loadDir('.github/src/Roles'); const badgeCode = codeBlock(BADGE); - const report = `## ${TITLE}\n\n${BADGE}\n\n${badgeCode}\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); From 8bb6508ab74413da7c528b69b1a46548c7e1a093 Mon Sep 17 00:00:00 2001 From: Timur Shemsedinov Date: Tue, 23 Jan 2024 18:36:36 +0200 Subject: [PATCH 07/10] Match skills to profile --- .github/src/skills.js | 69 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 63 insertions(+), 6 deletions(-) diff --git a/.github/src/skills.js b/.github/src/skills.js index 2b815d798..79942b0f9 100644 --- a/.github/src/skills.js +++ b/.github/src/skills.js @@ -7,6 +7,7 @@ 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'); @@ -121,7 +122,7 @@ const getSkills = (data, file, options) => { let section = ''; let empty = 0; const sections = {}; - const skills = new Set(); + const skills = new Map(); const out = []; for (const [i, s] of lines.entries()) { const line = s.trim(); @@ -151,7 +152,7 @@ const getSkills = (data, file, options) => { const msg = 'not matching level and emoji'; wrongFormat(`${msg} «${line}» at line ${i + 1}`, file); out.push(`${s} 👉 Warning: ${msg}`); - skills.add(skill); + skills.set(skill, ''); continue; } if (skills.has(skill) && options.unique) { @@ -160,11 +161,12 @@ const getSkills = (data, file, options) => { if (level) { out.push(` - ${skill}: ${level}`); sections[section][skill] = level; + skills.set(skill, level); } else { out.push(` - ${skill}`); sections[section][skill] = ''; + skills.set(skill, ''); } - skills.add(skill); } continue; } @@ -180,13 +182,13 @@ const getSkills = (data, file, options) => { }; const analise = async (dir, unit, options) => { - console.log(caption`Unit: ${unit}`); + console.log(chapter` Unit: ${unit}`); const file = `${dir}/${unit}.md`; const md = await loadFile(file); const data = getSkills(md, file, options); const { sections, skills } = data; const count = Object.keys(sections).length; - console.log(`Sections: ${count}, Skills: ${skills.size}\n`); + console.log(` Sections: ${count}, Skills: ${skills.size}\n`); return data; }; @@ -203,15 +205,70 @@ const loadDir = async (place, options = {}) => { return collection; }; +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'); + 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`; + const report = [ + `## ${TITLE}\n\n${BADGE}\n\n${badgeCode}\n`, + ...totals, + ...todos, + ].join('\n') + '\n'; await fs.writeFile(`${PATH}/Profile/REPORT.md`, report); const template = await loadFile(`${PATH}/.github/src/Templates/README.md`); From 27c430577769ba3964322b3d83bd5ad669628eca Mon Sep 17 00:00:00 2001 From: Timur Shemsedinov Date: Tue, 23 Jan 2024 18:36:56 +0200 Subject: [PATCH 08/10] Add profile required skills example --- .github/src/Roles/JavaScript.md | 100 ++++++++++++++++---------------- 1 file changed, 50 insertions(+), 50 deletions(-) diff --git a/.github/src/Roles/JavaScript.md b/.github/src/Roles/JavaScript.md index 576912f04..efff431ec 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 From 19e46783a5fb4c1367baa5654a16de9fcca12d56 Mon Sep 17 00:00:00 2001 From: Timur Shemsedinov Date: Tue, 23 Jan 2024 19:21:17 +0200 Subject: [PATCH 09/10] Fix CI --- .github/src/{skills.js => check.js} | 0 .github/workflows/test.yml | 4 ++-- 2 files changed, 2 insertions(+), 2 deletions(-) rename .github/src/{skills.js => check.js} (100%) diff --git a/.github/src/skills.js b/.github/src/check.js similarity index 100% rename from .github/src/skills.js rename to .github/src/check.js diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 4be279146..8d60877fc 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 From b25b84745c8b8f892eba0c0d9a77e9f6c14b4f3a Mon Sep 17 00:00:00 2001 From: Metarhia skill bot Date: Tue, 23 Jan 2024 21:21:59 +0000 Subject: [PATCH 10/10] Automated skill analysis --- Profile/REPORT.md | 676 ++++++++++++++++++++++++++++++++++++++++++++++ README.md | 2 + 2 files changed, 678 insertions(+) diff --git a/Profile/REPORT.md b/Profile/REPORT.md index e84bed6f0..8c8aa1540 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 a581d9409..20fd0a170 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)