diff --git a/Skills/Architecture.md b/Skills/Architecture.md
index 62dac42c..889cdc93 100644
--- a/Skills/Architecture.md
+++ b/Skills/Architecture.md
@@ -1,9 +1,9 @@
 ## Architecture
 
 - Application structure
-  - Modularity
-  - Components
-  - Directories
+  - Modularity k
+  - Components k
+  - Directories k
   - GRASP
   - SOLID
   - GoF patterns
diff --git a/Skills/DotNET.md b/Skills/DotNET.md
index cc2b08e2..814f33d3 100644
--- a/Skills/DotNET.md
+++ b/Skills/DotNET.md
@@ -29,7 +29,7 @@
   - Multithreading with Task Parallel Library (TPL)
   - Performance monitoring and diagnostics
 - APIs and Framework Features
-  - LINQ
+  - LINQ h
   - SignalR for real-time web functionality
   - High-performance RPC with `gRPC`
   - Security features (authentication, authorization)
@@ -78,11 +78,11 @@
   - Kubernetes for orchestration
   - Serverless computing
 - C# Development
-  - C# syntax and language fundamentals
-  - Advanced C# features (LINQ, async/await, delegates, events)
-  - Reflection and dynamic programming
-  - Data types and collections
-  - Generics and extension methods
+  - C# syntax and language fundamentals u
+  - Advanced C# features (LINQ, async/await, delegates, events) h
+  - Reflection and dynamic programming h
+  - Data types and collections u
+  - Generics and extension methods u
   - Attributes and annotations
   - Interoperability with other .NET languages
 - `F#` Development
@@ -120,7 +120,7 @@
   - .NET MAUI / Xamarin
   - Interoperability between managed code and iOS/Android API
 - Game development
-  - Unity
+  - Unity h
 - Web development
   - ASP.NET Core
   - Blazor
diff --git a/Skills/JavaScript.md b/Skills/JavaScript.md
index 0ff8fc89..90b41da0 100644
--- a/Skills/JavaScript.md
+++ b/Skills/JavaScript.md
@@ -1,29 +1,29 @@
 ## JavaScript
 
 - Language
-  - `Object`
-  - `Function`
-  - `Boolean`
-  - `Number`
-  - `BigInt`
-  - `String`
-  - `Symbol`
-  - `Infinity`
-  - `NaN`
-  - `undefined`
-  - `null`
-  - `this`
-  - `instanceof`
-  - `...spread`
-  - `...rest`
-  - `typeof`
-  - Destructuring
+  - `Object`  u
+  - `Function` u
+  - `Boolean` u
+  - `Number` u
+  - `BigInt` u
+  - `String` u
+  - `Symbol` u
+  - `Infinity` u
+  - `NaN` u
+  - `undefined` u
+  - `null` u
+  - `this` u
+  - `instanceof` u
+  - `...spread`h
+  - `...rest` h
+  - `typeof` u
+  - Destructuring u
   - Generators
-  - Iterators
+  - Iterators u
   - Async generator
   - Async iterator
-  - Chaining
-  - Optional chaining
+  - Chaining u
+  - Optional chaining 
   - IIFE
   - Async IIFE
   - `global`
@@ -37,7 +37,7 @@
   - Logical Assignment
   - Bitwise operators
   - Ternary operator
-  - `void`
+  - `void` u 
   - `yield`
   - `await`
   - Template literal
@@ -47,52 +47,52 @@
   - `in`
   - `super`
   - `eval`
-  - `static`
-  - `Number.parseInt`
-  - `Number.parseFloat`
+  - `static` u
+  - `Number.parseInt` u
+  - `Number.parseFloat` u
   - Property descriptors
   - Sealing properties
   - Freezing properties
-  - Computed properties
-  - Instance class fields
-  - Static class fields
-  - Private class fields
-  - Private class methods
+  - Computed properties 
+  - 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` 
+  - `with` u
+  - `new` u
 - Functions
-  - Arrow function
+  - Arrow function u
   - Async function
-  - Function declaration
-  - Function expression
-  - Default parameters
-  - Functional object
-  - `Function.prototype.call`
-  - `Function.prototype.bind`
-  - `Function.prototype.apply`
-  - `return`
+  - 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`
+  - `Array` u
   - `Map`
-  - `Set`
+  - `Set` 
   - `WeakMap`
   - `WeakSet`
   - Typed arrays
@@ -101,12 +101,12 @@
 - Standard classes and namespaces
   - `Proxy`
   - `RegExp`
-  - `Date`
-  - `Math`
-  - `Reflect`
-  - `Error`
-  - `Atomics`
-  - `JSON`
+  - `Date` u
+  - `Math` u
+  - `Reflect` u
+  - `Error` u
+  - `Atomics` u
+  - `JSON` h
   - `WeakRef`
   - `FinalizationRegistry`
   - `Intl`
@@ -115,7 +115,7 @@
   - Timers
 - Infrastructure
   - V8
-  - Node.js
+  - Node.js h
   - npm
   - prettier
   - MDN
diff --git a/Skills/Paradigms.md b/Skills/Paradigms.md
index 91d5f7e5..4305b616 100644
--- a/Skills/Paradigms.md
+++ b/Skills/Paradigms.md
@@ -1,48 +1,48 @@
 ## Multi-paradigm programming
 
 - Theory
-  - Procedural programming
-  - Imperative programming
-  - Structured programming
-  - Non-structured programming
-  - Functional programming
+  - Procedural programming k
+  - Imperative programming k
+  - Structured programming k
+  - Non-structured programming 
+  - Functional programming k
   - 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
+  - Object-oriented programming u
+  - Object-based programming u
+  - Generic programming h
+  - Concurrent computing h
+  - Asynchronous programming k
+  - Parallel programming h
+  - Reactive programming h
+  - Functional-reactive (FRP) h
+  - Automata-based programming h
+  - Domain-specific languages 
+  - Multi-paradigm programming h
+  - Metaprogramming h
   - Actor model
-  - Lambda calculus
+  - Lambda calculus h
   - Black box
   - Information hiding
   - Aspect-oriented programming
   - Anemic domain model
-  - Class composition
+  - Class composition u
 - OOP basics
-  - Constructor
-  - Operator `new`
-  - Static method
-  - Method
-  - Async method
-  - Getters, Setters
-  - Public fields
-  - Private fields
-  - Field declarations
+  - 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
-  - Parent class
-  - Polymorphism
-  - Abstract class
-  - Interface
-  - Encapsulation
-  - Hidden class
+  - Parent class h
+  - Polymorphism k
+  - Abstract class h
+  - Interface 
+  - Encapsulation u
+  - Hidden class 
   - Object form
   - Instance
   - Introspection
@@ -58,18 +58,18 @@
   - Protected variations
   - Pure fabrication
 - 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) h
+  - Open–closed principle (OCP) h
+  - Liskov substitution principle (LSP) h
+  - Interface segregation principle (ISP) h
+  - Dependency inversion principle (DIP) h
 - Patterns
-  - Singleton
+  - Singleton u
   - Factory Method
   - Abstract Factory
   - Adapter
   - Observer
-  - Strategy
+  - Strategy 
   - Facade
   - Proxy
   - Chain of Responsibility
diff --git a/Skills/Programming.md b/Skills/Programming.md
index e976b503..17211fd5 100644
--- a/Skills/Programming.md
+++ b/Skills/Programming.md
@@ -1,98 +1,98 @@
 ## Programming fundamental concepts
 
 - Concepts
-  - Model
-  - Modeling
+  - Model k
+  - Modeling u
   - Subject domain
-  - Algorithm
-  - Syntax
-  - Semantics
-  - Abstraction
-  - Paradigm
-  - Programm
-  - Programming paradigm
-  - Programming language
+  - Algorithm u
+  - Syntax u
+  - Semantics 
+  - Abstraction 
+  - Paradigm k
+  - Programm k
+  - Programming paradigm u
+  - Programming language u
   - Contract
-  - Module
-  - Library
+  - Module u
+  - Library u
   - Package
   - Component
-  - Framework
-  - Platform
-  - Source code
-  - Object code
-  - Machine code
-  - Microcode
-  - Software engineering
-  - Decomposition
-  - Control flow
+  - Framework h
+  - Platform k
+  - Source code k
+  - Object code u
+  - Machine code k
+  - Microcode h
+  - Software engineering k
+  - Decomposition u
+  - Control flow u
   - Data flow
   - Code reuse
   - Defensive programming
-  - Don't repeat yourself (DRY)
-  - KISS principle
+  - 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
+  - Value u
+  - Identifier u
+  - Variable u
+  - Constant u
+  - Scalar u
+  - Literal u
+  - Expression u
+  - Heap k
+  - Function u
+  - Procedure 
+  - Method u
+  - Class u
+  - Prototype h
+  - Event h
+  - Type u
+  - Flag u
+  - Lexical scope u
+  - Code block u
+  - Conditions u
+  - Loops u
+  - Assignment u
+  - Regular expression u
+  - Interface h 
+  - Namespaces u
+  - Call stack k
+  - Naming conventions u
+  - Coding conventions u
+  - Camel case u
+  - Snake case h
   - Kebab case
   - Trailing commas
-  - Return early
-  - Fail-fast
+  - 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
+  - Primitive types u
+  - Reference types u
+  - Type systems  k
+  - Strong typing u
+  - Weak typing u
+  - Duck typing u
+  - Static typing k
+  - Dynamic typing u 
+  - Nominal typing 
+  - Structural typing 
+  - Explicit typing u
+  - Type inference u 
+  - Covariance 
   - Contravariance
 - Functions
-  - Signature
-  - Argument
-  - Parameter
-  - Pure function
-  - Lambda expression
-  - Side effects
-  - Closure
-  - Partial application
-  - Currying
-  - Higher order
-  - Recursion
-  - Tail call optimisation
+  - Signature u
+  - Argument u
+  - Parameter u
+  - Pure function u
+  - Lambda expression u
+  - Side effects u
+  - Closure h 
+  - Partial application h
+  - Currying k 
+  - Higher order h
+  - Recursion u 
+  - Tail call optimisation 
   - Callback
   - Listener
   - Composition
@@ -105,30 +105,30 @@
   - Generator
   - Coroutine
 - Data structures
-  - Array
-  - Structure
-  - Record
-  - Enum
-  - Instance
-  - Object
-  - Collection
-  - Set
+  - Array u
+  - Structure u
+  - Record 
+  - Enum u 
+  - Instance u
+  - Object u 
+  - Collection u
+  - Set 
   - Hash table
-  - Linked list
-  - Doubly list
+  - Linked list h
+  - Doubly list h
   - Unrolled list
   - Circular list
   - Queue
-  - Stack
+  - Stack k
   - Deque
-  - Tree
-  - Graph
-  - Iterator
-  - Mutable state
-  - Immutable state
-  - Serialization
-  - String parsing
-  - JSON
+  - Tree h
+  - Graph h
+  - Iterator u
+  - Mutable state u
+  - Immutable state u
+  - Serialization 
+  - String parsing u
+  - JSON  h
   - JSON5
   - YAML
 - Networking
@@ -142,63 +142,63 @@
   - URN
   - URI
 - Process and tools
-  - Compiler
-  - Just-in-time compilation
+  - Compiler u
+  - Just-in-time compilation u
   - Ahead-of-time compilation
   - Transpiler
-  - Linter
+  - Linter h
   - Polyfill
   - Interpreter
-  - Linker
-  - Dynamic linking
-  - Static linking
-  - Runtime
-  - Virtual machine
+  - Linker h
+  - Dynamic linking h
+  - Static linking h
+  - Runtime u
+  - Virtual machine h
   - Register-based VM
   - Stack-based VM
   - Containerization
-  - Debugger
-  - Tracing
-  - Garbage collection
-  - Refactoring
-  - Code review
-  - Exception
-  - Unittesting
-  - git
-  - Github
-  - Docker
+  - Debugger u
+  - Tracing u
+  - Garbage collection u
+  - Refactoring u
+  - Code review u
+  - Exception k
+  - Unittesting u
+  - git u 
+  - Github u
+  - Docker h
   - Kubernetes
   - GCC
   - LLVM
 - Antipatterns
-  - Magic numbers
-  - Hard code
-  - Soft code
-  - Cryptic code
-  - Improbability factor
-  - Accidental complexity
-  - Action at a distance
-  - Spaghetti
-  - Silver bullet
-  - Not invented here
-  - Dead code
-  - Unreachable code
-  - Duplicate code
-  - Premature optimization
+  - Magic numbers k
+  - Hard code k
+  - Soft code k
+  - Cryptic code k
+  - Improbability factor k
+  - Accidental complexity k
+  - Action at a distance k
+  - Spaghetti  k
+  - Silver bullet k
+  - Not invented here k
+  - Dead code k
+  - Unreachable code k
+  - Duplicate code k
+  - Premature optimization 
   - Micro-optimization
-  - Nested loops
+  - Nested loops k
   - Long method/function/procedure
   - Long inheritance
   - Large class/file
-  - Too many parameters
-  - Pass-through parameters
+  - Too many parameters k
+  - Pass-through parameters k
   - Accumulate and fire
   - Use switch/case
-  - Temporary field
+  - Temporary field k
   - Handle object as instances and hashes at the same time
   - Use fields instead of arguments
-  - Data clump
-  - Feature envy
+  - Data clump k
+  - Feature envy k
   - Monkey patch
   - Yo-yo problem
 - Runtimes and virtual machines
@@ -214,21 +214,21 @@
   - Ring
   - Virtual memory
   - File system
-  - Linux
+  - Linux u
   - Unix
   - BSD
   - MacOS
-  - Windows
+  - Windows u
   - Real-time OS
   - Embedded OS
 - Standards
-  - ASCII
+  - ASCII u
   - Escape sequence
   - RFC
   - IETF
   - IANA
   - IEEE
-  - Base64
+  - Base64 h
   - ECMA
   - ICANN
   - ISO