From 96ec8b98b668783025f64fe6257bb68b78a13c8f Mon Sep 17 00:00:00 2001 From: leonid-shutov Date: Wed, 18 Sep 2024 21:34:23 +0200 Subject: [PATCH] very first assessment --- Skills/Architecture.md | 166 ++++++++-------- Skills/Async.md | 156 +++++++-------- Skills/Databases.md | 174 ++++++++-------- Skills/JavaScript.md | 228 ++++++++++----------- Skills/NodeJS.md | 246 +++++++++++------------ Skills/Paradigms.md | 168 ++++++++-------- Skills/Programming.md | 441 ++++++++++++++++++++--------------------- 7 files changed, 789 insertions(+), 790 deletions(-) diff --git a/Skills/Architecture.md b/Skills/Architecture.md index 62dac42c..635819c8 100644 --- a/Skills/Architecture.md +++ b/Skills/Architecture.md @@ -1,100 +1,100 @@ ## Architecture - Application structure - - Modularity - - Components - - Directories - - GRASP - - SOLID - - GoF patterns - - CQS - - Leaking abstractions - - Multiparadigm code - - Contract programming - - Platform-agnostic - - Transport-agnostic - - Framework-agnostic - - Code coverage - - Cohesion - - Coupling - - Cyclomatic complexity - - Reliability - - Quality - - Availability - - Flexibility - - Law of Demeter (LoD) + - Modularity u + - Components u + - Directories u + - GRASP u + - SOLID e + - GoF patterns u + - CQS u + - Leaking abstractions k + - Multiparadigm code u + - Contract programming u + - Platform-agnostic u + - Transport-agnostic k + - Framework-agnostic u + - Code coverage u + - Cohesion u + - Coupling k + - Cyclomatic complexity h + - Reliability u + - Quality u + - Availability u + - Flexibility u + - Law of Demeter (LoD) u - Application architecture - - Isolation between layer - - Domain-specific language (DSL) - - System vs applied code - - Multilayer approach - - Hexagonal architecture - - Separation of concerns (SoC) - - Metaprogramming - - Inversion of control (IoC) - - Dependency injection (DI) - - Clean architecture - - Domain-driven design (DDD) - - Pub/sub - - Message brocker - - Agent - - Service locator - - Message Queue (MQ) - - CQRS - - Event sourcing - - E-R data modeling - - Entity-relationship diagram + - Isolation between layer u + - Domain-specific language (DSL) u + - System vs applied code u + - Multilayer approach u + - Hexagonal architecture k + - Separation of concerns (SoC) u + - Metaprogramming e + - Inversion of control (IoC) e + - Dependency injection (DI) e + - Clean architecture u + - Domain-driven design (DDD) u + - Pub/sub u + - Message brocker u + - Agent u + - Service locator u + - Message Queue (MQ) u + - CQRS u + - Event sourcing u + - E-R data modeling h + - Entity-relationship diagram u - IDEF1X - - UML + - UML u - Work breakdown structure - - Budget estimation - - Distributed systems - - High-intensive computing - - Load balancing - - Gateways - - On-premises - - IaaS - - PaaS - - SaaS - - FaaS clouds - - Serverless - - Vendor lock-in + - Budget estimation h + - Distributed systems u + - High-intensive computing k + - Load balancing u + - Gateways u + - On-premises k + - IaaS u + - PaaS u + - SaaS u + - FaaS clouds u + - Serverless u + - Vendor lock-in u - Bus factor - Solution architecture - - A software requirements specification (SRS) - - Solution visions - - Solution capabilities - - System design - - Process modelling - - Data modelling - - Solution components - - Risk assessment - - Non Functional Requirements (NFR) - - Clouds - - BPMN - - Low-code - - No-code - - Metric + - A software requirements specification (SRS) h + - Solution visions h + - Solution capabilities h + - System design h + - Process modelling h + - Data modelling u + - Solution components k + - Risk assessment h + - Non Functional Requirements (NFR) h + - Clouds u + - BPMN h + - Low-code u + - No-code u + - Metric u - Metric abuse - - ACID + - ACID u - CAP theorem - - Single source of truth (SSOT) + - Single source of truth (SSOT) u - Enterprise architecture - - Understanding business needs - - Enterprise strategy + - Understanding business needs u + - Enterprise strategy u - Integration with subsystems - - Enterprise vision - - Enterprise capabilities - - Project scope + - Enterprise vision k + - Enterprise capabilities k + - Project scope k - Enterprise service bus - - Service-oriented architecture - - Microservices - - Process choreography - - Service orchestration - - Data warehouse + - Service-oriented architecture k + - Microservices u + - Process choreography h + - Service orchestration k + - Data warehouse k - Business Intelligence - OLAP - OLTP - - Conways Law - - Quality assurance + - Conways Law u + - Quality assurance u - Engineering Hygiene diff --git a/Skills/Async.md b/Skills/Async.md index 63e26c83..6c365499 100644 --- a/Skills/Async.md +++ b/Skills/Async.md @@ -1,89 +1,89 @@ ## Asynchronous programming - Theory - - Event loop - - `try..catch` - - Non-blocking - - Async I/O - - Thread pool - - Pattern Reactor - - CAS operations + - Event loop u + - `try..catch` u + - Non-blocking u + - Async I/O u + - Thread pool u + - Pattern Reactor u + - CAS operations k - epoll - kqueue - Completion ports - - Event ports - - libuv - - Race conditions - - Dead locks - - Live locks - - Concurrent programming - - Parallel programming - - Actor Model - - Thread - - Process + - Event ports u + - libuv u + - Race conditions u + - Dead locks k + - Live locks k + - Concurrent programming u + - Parallel programming e + - Actor Model u + - Thread e + - Process e - Async contracts - - Callbacks - - Callback-last-error-first - - Thenable - - Promise - - Async/await - - Future - - Deferred - - Sync generator - - Async Generator - - Async Iterator - - Event - - Coroutine - - Goroutine - - Signal - - Stream - - Chain of responsibility - - Middleware - - Locks + - Callbacks u + - Callback-last-error-first u + - Thenable u + - Promise u + - Async/await u + - Future k + - Deferred u + - Sync generator k + - Async Generator u + - Async Iterator u + - Event u + - Coroutine k + - Goroutine k + - Signal u + - Stream u + - Chain of responsibility u + - Middleware u + - Locks k - Async adapters and utils - - callbackify - - promisify - - asyncify - - Callbacks compose - - Async compose + - callbackify k + - promisify u + - asyncify k + - Callbacks compose k + - Async compose k - Async abstractions interfaces - - EventEmitter - - Observable/Observer - - Readable - - Writable - - Transform - - Async Pool - - Async Queue - - Async Collector - - Semaphore - - Mutex - - Spin Lock + - EventEmitter u + - Observable/Observer u + - Readable u + - Writable u + - Transform u + - Async Pool k + - Async Queue k + - Async Collector k + - Semaphore k + - Mutex k + - Spin Lock k - JavaScript & Node.js specific - - Timers - - `setImmediate` - - `nextTick` - - AbortController - - AbortSignal - - Promise unhandled rejection - - Promise double resolve - - Atomics - - High resolution clock - - Callback hell - - Promise hell - - ref() and unref() - - Error handling in async code - - Better stack traces with return await - - JSON streaming serialization - - AsyncLocalStorage - - AsyncResource + - Timers u + - `setImmediate` k + - `nextTick` k + - AbortController u + - AbortSignal u + - Promise unhandled rejection u + - Promise double resolve k + - Atomics k + - High resolution clock k + - Callback hell k + - Promise hell k + - ref() and unref() k + - Error handling in async code u + - Better stack traces with return await u + - JSON streaming serialization u + - AsyncLocalStorage k + - AsyncResource k - Techniques - - Async.js library - - RxJS library - - Promise.all - - Promise.allSettled - - Promise.race - - Promise.any - - Web Locks API - - IPC - - Channel API - - Revealing constructor + - Async.js library k + - RxJS library k + - Promise.all u + - Promise.allSettled u + - Promise.race u + - Promise.any u + - Web Locks API k + - IPC k + - Channel API k + - Revealing constructor k diff --git a/Skills/Databases.md b/Skills/Databases.md index c499feb1..a7b5c8fe 100644 --- a/Skills/Databases.md +++ b/Skills/Databases.md @@ -1,94 +1,94 @@ ## Databases - Theory and concepts - - Data types - - Performance tuning - - Migrations - - Schema versioning - - Backup and recovery - - Database scalability - - Relational databases - - Key-value store - - Tuple store - - Graph databases - - Object databases - - Column databases - - Navigational databases - - Hierarchical databases - - In-memory databases - - Inverted index - - Data control language (DCL) - - Data definition language (DDL) - - Data manipulation language (DML) - - Data query language (DQL) + - Data types u + - Performance tuning u + - Migrations u + - Schema versioning u + - Backup and recovery u + - Database scalability u + - Relational databases u + - Key-value store u + - Tuple store u + - Graph databases k + - Object databases u + - Column databases k + - Navigational databases k + - Hierarchical databases k + - In-memory databases u + - Inverted index k + - Data control language (DCL) u + - Data definition language (DDL) u + - Data manipulation language (DML) u + - Data query language (DQL) u - Relational - - Entity-Relationship Diagram - - Normal forms - - Indexing - - Primary keys - - Foreign keys - - Transactions - - Views - - Subqueries - - Stored procedures - - SQL functions - - Materialized views - - Replications - - Virtualization + - Entity-Relationship Diagram k + - Normal forms u + - Indexing u + - Primary keys u + - Foreign keys u + - Transactions u + - Views u + - Subqueries u + - Stored procedures u + - SQL functions u + - Materialized views k + - Replications k + - Virtualization h - SQL - - `SELECT` - - `INSERT` - - `UPDATE` - - `DELETE` - - `LIMIT` - - `OFFSET` - - `ORDER BY` - - `GROUP BY` - - `HAVING` - - `EXISTS` - - `JOIN` - - `INNER JOIN` - - `LEFT JOIN` - - `RIGHT JOIN` - - `UNION` - - `DISTINCT` - - `WHERE` - - `LIKE` - - `IN` - - `BETWEEN` - - `CREATE TABLE` - - `ALTER TABLE` - - `DROP TABLE` - - `PRIMARY KEY` - - `FOREIGN KEY` - - `CHECK` - - `DEFAULT` - - `INDEX` - - `UNIQUE` - - `GRANT` - - `REVOKE` - - `DENY` - - `EXPLAIN` + - `SELECT` u + - `INSERT` u + - `UPDATE` u + - `DELETE` u + - `LIMIT` u + - `OFFSET` u + - `ORDER BY` u + - `GROUP BY` u + - `HAVING` u + - `EXISTS` u + - `JOIN` u + - `INNER JOIN` u + - `LEFT JOIN` u + - `RIGHT JOIN` u + - `UNION` u + - `DISTINCT` u + - `WHERE` u + - `LIKE` u + - `IN` u + - `BETWEEN` u + - `CREATE TABLE` u + - `ALTER TABLE` u + - `DROP TABLE` u + - `PRIMARY KEY` u + - `FOREIGN KEY` u + - `CHECK` u + - `DEFAULT` u + - `INDEX` u + - `UNIQUE` u + - `GRANT` u + - `REVOKE` u + - `DENY` u + - `EXPLAIN` u - Engines - - PostgreSQL - - Oracle - - MySQL - - MariaDB - - MS SQL Server - - Redis - - Rabbit - - MongoDB - - Memcached - - Riak - - DB2 - - SQLite - - DynamoDB - - Firebase + - PostgreSQL u + - Oracle k + - MySQL k + - MariaDB k + - MS SQL Server k + - Redis u + - Rabbit k + - MongoDB u + - Memcached u + - Riak h + - DB2 h + - SQLite k + - DynamoDB u + - Firebase u - Data engineering - - Data warehousing - - Business intelligence - - Big data - - Data analysis - - AI tools - - Cloud databases - - Data Visualization + - Data warehousing k + - Business intelligence h + - Big data k + - Data analysis k + - AI tools u + - Cloud databases u + - Data Visualization u diff --git a/Skills/JavaScript.md b/Skills/JavaScript.md index 0ff8fc89..36de031a 100644 --- a/Skills/JavaScript.md +++ b/Skills/JavaScript.md @@ -1,122 +1,122 @@ ## JavaScript - Language - - `Object` - - `Function` - - `Boolean` - - `Number` - - `BigInt` - - `String` - - `Symbol` - - `Infinity` - - `NaN` - - `undefined` - - `null` - - `this` - - `instanceof` - - `...spread` - - `...rest` - - `typeof` - - Destructuring - - Generators - - Iterators - - Async generator - - Async iterator - - Chaining - - Optional chaining - - IIFE - - Async IIFE - - `global` - - `globalThis` - - `window` - - Getters and setters - - `__proto__` - - `prototype` - - Equality operators - - Logical operators - - Logical Assignment - - Bitwise operators - - Ternary operator - - `void` - - `yield` - - `await` - - Template literal - - Strict mode - - Hoisting - - `delete` - - `in` - - `super` - - `eval` - - `static` - - `Number.parseInt` - - `Number.parseFloat` - - Property descriptors - - Sealing properties - - Freezing properties - - Computed properties - - Instance class fields - - Static class fields - - Private class fields - - Private class methods + - `Object` u + - `Function` u + - `Boolean` u + - `Number` u + - `BigInt` k + - `String` u + - `Symbol` u + - `Infinity` k + - `NaN` u + - `undefined` u + - `null` u + - `this` u + - `instanceof` u + - `...spread` u + - `...rest` u + - `typeof` u + - Destructuring u + - Generators u + - Iterators u + - Async generator u + - Async iterator u + - Chaining u + - Optional chaining u + - IIFE u + - Async IIFE u + - `global` u + - `globalThis` u + - `window` u + - Getters and setters u + - `__proto__` u + - `prototype` u + - Equality operators u + - Logical operators u + - Logical Assignment u + - Bitwise operators u + - Ternary operator u + - `void` u + - `yield` u + - `await` u + - Template literal u + - Strict mode u + - Hoisting u + - `delete` u + - `in` u + - `super` u + - `eval` u + - `static` u + - `Number.parseInt` u + - `Number.parseFloat` u + - Property descriptors u + - Sealing properties u + - Freezing properties u + - Computed properties u + - Instance class fields u + - Static class fields u + - Private class fields u + - Private class methods u - Statements - - `if` - - `while` - - `do..while` - - `for` - - `for..in` - - `for..of` - - `for await` - - `throw` - - `break` - - `continue` - - `import` - - `export` - - `label` - - `try..catch` - - `switch` - - `class` - - `extends` - - `with` - - `new` + - `if` u + - `while` u + - `do..while` u + - `for` u + - `for..in` u + - `for..of` u + - `for await` u + - `throw` u + - `break` u + - `continue` u + - `import` u + - `export` u + - `label` u + - `try..catch` u + - `switch` u + - `class` u + - `extends` u + - `with` u + - `new` u - Functions - - Arrow function - - Async function - - Function declaration - - Function expression - - Default parameters - - Functional object - - `Function.prototype.call` - - `Function.prototype.bind` - - `Function.prototype.apply` - - `return` + - Arrow function u + - Async function u + - Function declaration u + - Function expression u + - Default parameters u + - Functional object u + - `Function.prototype.call` u + - `Function.prototype.bind` u + - `Function.prototype.apply` u + - `return` u - Data structures - - `Array` - - `Map` - - `Set` - - `WeakMap` - - `WeakSet` - - Typed arrays - - Mixins - - `Object.assign` + - `Array` u + - `Map` u + - `Set` u + - `WeakMap` k + - `WeakSet` k + - Typed arrays u + - Mixins u + - `Object.assign` u - Standard classes and namespaces - - `Proxy` - - `RegExp` - - `Date` - - `Math` - - `Reflect` - - `Error` - - `Atomics` - - `JSON` - - `WeakRef` - - `FinalizationRegistry` - - `Intl` - - `Promise` - - `console` - - Timers + - `Proxy` u + - `RegExp` u + - `Date` u + - `Math` u + - `Reflect` k + - `Error` u + - `Atomics` k + - `JSON` u + - `WeakRef` k + - `FinalizationRegistry` k + - `Intl` u + - `Promise` u + - `console` u + - Timers u - Infrastructure - - V8 - - Node.js - - npm - - prettier - - MDN - - TC39 + - V8 u + - Node.js u + - npm u + - prettier u + - MDN u + - TC39 k diff --git a/Skills/NodeJS.md b/Skills/NodeJS.md index bd891457..674d4a7f 100644 --- a/Skills/NodeJS.md +++ b/Skills/NodeJS.md @@ -1,143 +1,143 @@ ## Node.js and backend - Internals and concepts - - Strong and weak sides of node.js - - Stateful and stateless servers - - Nonblocking I/O and blocking code - - Event loop phases - - Event loop microtasks and macrotasks - - Garbage collection - - Node.js LTS schedule - - I/O-bound, CPU-bound, memory-bound tasks - - Interactive applications (close to real-time) + - Strong and weak sides of node.js u + - Stateful and stateless servers u + - Nonblocking I/O and blocking code e + - Event loop phases u + - Event loop microtasks and macrotasks u + - Garbage collection k + - Node.js LTS schedule u + - I/O-bound, CPU-bound, memory-bound tasks u + - Interactive applications (close to real-time) k - Modularity, layers and dependencies - - CommonJS modules - - ECMAScript modules - - Module `node:module` - - Caching in CJS and ESM - - Modules as singletons - - Contexts and scripts module `node:vm` - - Dependencies: `npm`, `node_modules` - - Files `package.json`, `package-lock.json` - - Module-based permissions model - - Isolation with modularity - - Dependency injection - - DI containers - - Coupling and cohesion - - Framework agnostic approach + - CommonJS modules u + - ECMAScript modules u + - Module `node:module` u + - Caching in CJS and ESM u + - Modules as singletons t + - Contexts and scripts module `node:vm` k + - Dependencies: `npm`, `node_modules` u + - Files `package.json`, `package-lock.json` u + - Module-based permissions model k + - Isolation with modularity u + - Dependency injection e + - DI containers u + - Coupling and cohesion u + - Framework agnostic approach k - Environment - - Command line arguments - - Node.js CLI + - Command line arguments u + - Node.js CLI u - Process-based permissions - - Graceful shutdown - - Clustering - - Watch filesystem changes with --watch + - Graceful shutdown u + - Clustering u + - Watch filesystem changes with --watch k - Internal API - - Streams API + - Streams API u - Web Streams API - - Crypto API - - Password hashing with crypto.scrypt - - Web Crypto API - - File system API (sync and async) - - Copy folder recursively - - Worker threads - - Performance hooks - - Native fetch and nodejs/undici - - async_hooks - - AsyncLocalStorage + - Crypto API u + - Password hashing with crypto.scrypt k + - Web Crypto API k + - File system API (sync and async) u + - Copy folder recursively u + - Worker threads e + - Performance hooks k + - Native fetch and nodejs/undici u + - async_hooks k + - AsyncLocalStorage k - AsyncResource - Deprecated domain API - - Node.js single executable - - SharedArrayBuffer - - Module `node:worker_threads` - - Module `node:child_process` - - MessageChannel, MessagePort - - BroadcastChannel - - Generating crypto random UUID - - Module `node:url` vs `new URL` - - Module `node:assert` - - Internationalization - - Blob, File, Buffer, module `node:buffer` - - Module `node:zlib` + - Node.js single executable h + - SharedArrayBuffer e + - Module `node:worker_threads` e + - Module `node:child_process` e + - MessageChannel, MessagePort e + - BroadcastChannel e + - Generating crypto random UUID u + - Module `node:url` vs `new URL` u + - Module `node:assert` u + - Internationalization u + - Blob, File, Buffer, module `node:buffer` u + - Module `node:zlib` k - Network - - Endpoint throttling + - Endpoint throttling k - ALPN - SNI callback - - SSL certificates - - Protocol agnostic approach - - Fetch API + - SSL certificates k + - Protocol agnostic approach k + - Fetch API u - IncomingMessage - - HTTP(S) - - TCP/SSL - - UDP - - TLS - - Websocket - - SSE - - HTTP/3 (QUIC) - - Long polling - - REST - - RPC - - Routing - - DoS - - DDoS - - XSS - - Path traversal - - CSRF - - DNS - - SQL injection + - HTTP(S) u + - TCP/SSL h + - UDP u + - TLS h + - Websocket k + - SSE h + - HTTP/3 (QUIC) h + - Long polling u + - REST u + - RPC k + - Routing u + - DoS k + - DDoS k + - XSS k + - Path traversal k + - CSRF k + - DNS k + - SQL injection u - noDelay - keep-alive - - IP sticky sessions + - IP sticky sessions k - Technique and tools - - Native test runner - - Logging - - Application configuring - - Testing - - CI/CD - - Readable - - Writable - - Transform - - Back pressure - - Buffer - - Console - - Inspector + - Native test runner u + - Logging u + - Application configuring u + - Testing u + - CI/CD u + - Readable u + - Writable u + - Transform k + - Back pressure k + - Buffer u + - Console u + - Inspector u - Data access - - Data access layer - - Repository - - Active record - - Query builder - - Object-Relational Mapping - - CRUD - - DTO + - Data access layer u + - Repository u + - Active record u + - Query builder u + - Object-Relational Mapping u + - CRUD u + - DTO u - Error handling and debugging - - `Error` - - `error.cause` - - `error.code` - - `error.message` - - `error.stack` - - `Error.captureStackTrace` - - How to avoid mixins - - Uncaught exceptions - - Heap dump - - Debugging tools - - Flame graph - - Memory leaks - - Resource leaks - - Data race + - `Error` u + - `error.cause` u + - `error.code` u + - `error.message` u + - `error.stack` u + - `Error.captureStackTrace` u + - How to avoid mixins u + - Uncaught exceptions u + - Heap dump h + - Debugging tools u + - Flame graph u + - Memory leaks u + - Resource leaks k + - Data race u - Integrations and bindings - - Native 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` - - Shared memory - - V8 binary serialization + - Native addons k + - `C` and `C++` addons k + - `Rust` addons k + - `Zig` addons k + - NAN (Native Abstractions for Node.js) k + - Node-API (formerly N-API) k + - NAPI `C` and `C++` k + - NAPI `Rust` k + - NAPI `Zig` k + - Webassembly `WAT` k + - Webassembly `C` and `C++` k + - Webassembly `Rust` k + - Webassembly `Zig` k + - Webassembly `AssemblyScript` k + - Shared memory k + - V8 binary serialization k diff --git a/Skills/Paradigms.md b/Skills/Paradigms.md index 91d5f7e5..b6d8ec09 100644 --- a/Skills/Paradigms.md +++ b/Skills/Paradigms.md @@ -1,91 +1,91 @@ ## Multi-paradigm programming - Theory - - Procedural programming - - Imperative programming - - Structured programming - - Non-structured programming - - Functional programming - - Prototype-based programming - - Object-oriented programming - - Object-based programming - - Generic programming - - Concurrent computing - - Asynchronous programming - - Parallel programming - - Reactive programming - - Functional-reactive (FRP) - - Automata-based programming - - Domain-specific languages - - Multi-paradigm programming - - Metaprogramming - - Actor model - - Lambda calculus - - Black box - - Information hiding - - Aspect-oriented programming - - Anemic domain model - - Class composition + - Procedural programming u + - Imperative programming u + - Structured programming u + - Non-structured programming u + - Functional programming u + - Prototype-based programming u + - Object-oriented programming u + - Object-based programming u + - Generic programming u + - Concurrent computing u + - Asynchronous programming u + - Parallel programming k + - Reactive programming u + - Functional-reactive (FRP) u + - Automata-based programming u + - Domain-specific languages u + - Multi-paradigm programming u + - Metaprogramming u + - Actor model k + - Lambda calculus u + - Black box u + - Information hiding u + - Aspect-oriented programming u + - Anemic domain model u + - Class composition u - OOP basics - - Constructor - - Operator `new` - - Static method - - Method - - Async method - - Getters, Setters - - Public fields - - Private fields - - Field declarations - - Inheritance - - Parent class - - Polymorphism - - Abstract class - - Interface - - Encapsulation - - Hidden class - - Object form - - Instance - - Introspection - - Reflection - - The diamond problem + - Constructor u + - Operator `new` u + - Static method u + - Method u + - Async method u + - Getters, Setters u + - Public fields u + - Private fields u + - Field declarations u + - Inheritance u + - Parent class u + - Polymorphism u + - Abstract class u + - Interface u + - Encapsulation u + - Hidden class u + - Object form u + - Instance u + - Introspection u + - Reflection u + - The diamond problem k - GRASP - - Information expert - - Creator - - Controller - - Indirection - - Low coupling - - High cohesion - - Protected variations - - Pure fabrication + - Information expert u + - Creator u + - Controller u + - Indirection u + - Low coupling u + - High cohesion u + - Protected variations u + - Pure fabrication u - SOLID - - Single-responsibility principle (SRP) - - Open–closed principle (OCP) - - Liskov substitution principle (LSP) - - Interface segregation principle (ISP) - - Dependency inversion principle (DIP) + - Single-responsibility principle (SRP) e + - Open–closed principle (OCP) e + - Liskov substitution principle (LSP) e + - Interface segregation principle (ISP) e + - Dependency inversion principle (DIP) e - Patterns - - Singleton - - Factory Method - - Abstract Factory - - Adapter - - Observer - - Strategy - - Facade - - Proxy - - Chain of Responsibility - - Command - - Iterator - - State - - Bridge - - Builder - - Prototype - - Composite - - Decorator - - Flyweight - - Mediator - - Memento - - Template Method - - Visitor - - Reactor - - Active object - - Delegation + - Singleton u + - Factory Method u + - Abstract Factory u + - Adapter u + - Observer u + - Strategy u + - Facade u + - Proxy u + - Chain of Responsibility u + - Command u + - Iterator u + - State u + - Bridge u + - Builder u + - Prototype u + - Composite k + - Decorator u + - Flyweight k + - Mediator k + - Memento k + - Template Method u + - Visitor u + - Reactor u + - Active object k + - Delegation u diff --git a/Skills/Programming.md b/Skills/Programming.md index e976b503..87d0ee67 100644 --- a/Skills/Programming.md +++ b/Skills/Programming.md @@ -1,239 +1,238 @@ ## Programming fundamental concepts - Concepts - - Model - - Modeling - - Subject domain - - Algorithm - - Syntax - - Semantics - - Abstraction - - Paradigm - - Programm - - Programming paradigm - - Programming language - - Contract - - Module - - Library - - Package - - Component - - Framework - - Platform - - Source code - - Object code - - Machine code - - Microcode - - Software engineering - - Decomposition - - Control flow - - Data flow - - Code reuse - - Defensive programming - - Don't repeat yourself (DRY) - - KISS principle + - Model u + - Modeling u + - Subject domain u + - Algorithm u + - Syntax u + - Semantics u + - Abstraction u + - Paradigm u + - Programm u + - Programming paradigm u + - Programming language u + - Contract u + - Module u + - Library u + - Package u + - Component u + - Framework u + - Platform u + - Source code u + - Object code u + - Machine code u + - Microcode u + - Software engineering u + - Decomposition u + - Control flow u + - Data flow u + - Code reuse u + - Defensive programming u + - Don't repeat yourself (DRY) u + - KISS principle u - Syntax and concepts - - Value - - Identifier - - Variable - - Constant - - Scalar - - Literal - - Expression - - Heap - - Function - - Procedure - - Method - - Class - - Prototype - - Event - - Type - - Flag - - Lexical scope - - Code block - - Conditions - - Loops - - Assignment - - Regular expression - - Interface - - Namespaces - - Call stack - - Naming conventions - - Coding conventions - - Camel case - - Snake case - - Kebab case - - Trailing commas - - Return early - - Fail-fast + - Value u + - Identifier u + - Variable u + - Constant u + - Scalar u + - Literal u + - Expression u + - Heap u + - Function u + - Procedure u + - Method u + - Class u + - Prototype u + - Event u + - Type u + - Flag u + - Lexical scope u + - Code block u + - Conditions u + - Loops u + - Assignment u + - Regular expression u + - Interface u + - Namespaces u + - Call stack u + - Naming conventions u + - Coding conventions u + - Camel case u + - Snake case u + - Kebab case u + - Trailing commas u + - Return early u + - Fail-fast u - Types - - Primitive types - - Reference types - - Type systems - - Strong typing - - Weak typing - - Duck typing - - Static typing - - Dynamic typing - - Nominal typing - - Structural typing - - Explicit typing - - Type inference - - Covariance - - Contravariance + - Primitive types u + - Reference types u + - Type systems u + - Strong typing u + - Weak typing u + - Duck typing u + - Static typing u + - Dynamic typing u + - Nominal typing u + - Structural typing u + - Explicit typing u + - Type inference u + - Covariance u + - Contravariance u - Functions - - Signature - - Argument - - Parameter - - Pure function - - Lambda expression - - Side effects - - Closure - - Partial application - - Currying - - Higher order - - Recursion - - Tail call optimisation - - Callback - - Listener - - Composition - - Pipe - - Memoize - - Wrapper - - Functor - - Monad - - Monoid - - Generator - - Coroutine + - Signature u + - Argument u + - Parameter u + - Pure function u + - Lambda expression u + - Side effects u + - Closure u + - Partial application u + - Currying u + - Higher order u + - Recursion u + - Tail call optimisation u + - Callback u + - Listener u + - Composition u + - Pipe u + - Memoize u + - Wrapper u + - Functor u + - Monad k + - Monoid k + - Coroutine k - Data structures - - Array - - Structure - - Record - - Enum - - Instance - - Object - - Collection - - Set - - Hash table - - Linked list - - Doubly list - - Unrolled list - - Circular list - - Queue - - Stack - - Deque - - Tree - - Graph - - Iterator - - Mutable state - - Immutable state - - Serialization - - String parsing - - JSON - - JSON5 - - YAML + - Array u + - Structure k + - Record u + - Enum u + - Instance u + - Object u + - Collection u + - Set u + - Hash table u + - Linked list u + - Doubly list y + - Unrolled list k + - Circular list k + - Queue u + - Stack u + - Deque u + - Tree u + - Graph u + - Iterator u + - Mutable state u + - Immutable state u + - Serialization u + - String parsing u + - JSON u + - JSON5 u + - YAML u - Networking - - DNS - - CDN - - CORS - - IPv4 - - IPv6 - - NAT - - URL - - URN - - URI + - DNS u + - CDN u + - CORS u + - IPv4 u + - IPv6 u + - NAT u + - URL u + - URN u + - URI u - Process and tools - - Compiler - - Just-in-time compilation - - Ahead-of-time compilation - - Transpiler - - Linter - - Polyfill - - Interpreter - - Linker - - Dynamic linking - - Static linking - - Runtime - - Virtual machine - - Register-based VM - - Stack-based VM - - Containerization - - Debugger - - Tracing - - Garbage collection - - Refactoring - - Code review - - Exception - - Unittesting - - git - - Github - - Docker - - Kubernetes - - GCC - - LLVM + - Compiler u + - Just-in-time compilation u + - Ahead-of-time compilation u + - Transpiler u + - Linter u + - Polyfill u + - Interpreter u + - Linker u + - Dynamic linking u + - Static linking u + - Runtime u + - Virtual machine u + - Register-based VM k + - Stack-based VM k + - Containerization u + - Debugger u + - Tracing u + - Garbage collection k + - Refactoring u + - Code review u + - Exception u + - Unittesting u + - git u + - Github u + - Docker u + - Kubernetes u + - GCC h + - LLVM h - Antipatterns - - Magic numbers - - Hard code - - Soft code - - Cryptic code - - Improbability factor - - Accidental complexity + - Magic numbers k + - Hard code k + - Soft code k + - Cryptic code k + - Improbability factor h + - Accidental complexity k - Action at a distance - Spaghetti - - Silver bullet + - Silver bullet k - Not invented here - - Dead code - - Unreachable code - - Duplicate code - - Premature optimization - - Micro-optimization - - Nested loops - - Long method/function/procedure - - Long inheritance - - Large class/file - - Too many parameters - - Pass-through parameters - - Accumulate and fire - - Use switch/case - - Temporary field - - Handle object as instances and hashes at the same time - - Use fields instead of arguments - - Data clump - - Feature envy - - Monkey patch - - Yo-yo problem + - Dead code u + - Unreachable code u + - Duplicate code u + - Premature optimization k + - Micro-optimization u + - Nested loops u + - Long method/function/procedure u + - Long inheritance k + - Large class/file u + - Too many parameters k + - Pass-through parameters u + - Accumulate and fire k + - Use switch/case k + - Temporary field k + - Handle object as instances and hashes at the same time k + - Use fields instead of arguments k + - Data clump k + - Feature envy k + - Monkey patch k + - Yo-yo problem k - Runtimes and virtual machines - - Bytecode - - V8 - - VJM + - Bytecode k + - V8 k + - VJM h - CLR - Mono - Operating systems - - Interrupts - - Drivers - - Kernel - - Ring - - Virtual memory - - File system - - Linux - - Unix - - BSD - - MacOS - - Windows - - Real-time OS - - Embedded OS + - Interrupts u + - Drivers u + - Kernel u + - Ring h + - Virtual memory u + - File system u + - Linux u + - Unix u + - BSD k + - MacOS u + - Windows u + - Real-time OS h + - Embedded OS h - Standards - - ASCII - - Escape sequence - - RFC - - IETF - - IANA - - IEEE - - Base64 - - ECMA - - ICANN - - ISO - - MIME - - OWASP - - UTF-8 - - W3C - - ODMG + - ASCII u + - Escape sequence u + - RFC u + - IETF k + - IANA h + - IEEE k + - Base64 u + - ECMA u + - ICANN h + - ISO u + - MIME u + - OWASP u + - UTF-8 u + - W3C u + - ODMG k