# Dynamic vs Static

So what is typing? For many Python developers, this can feel new, because most classic languages such as C, Java, Rust, and many others were originally designed as statically typed languages. But what does that mean? Let’s look at a small C example:

int sum(int a, int b) {
    return a + b;
}

int main() {
    printf("%d\n", sum(10, 20));

    // printf("%d\n", sum("10", 20));
}

This code works and prints 30. But note that the last line is commented out. If we uncomment it and compile again, we will get an error log like this:

error: passing argument 1 of ‘sum’ makes integer from pointer without cast
   10 |     printf("%d\n", sum("10", 20));
      |                        ^~~~
      |                        |
      |                        char *
note: expected ‘int’ but argument is of type ‘char *’

The log says that the function parameter expected int but got char * (for simplicity, think of it as a string). At first glance, this may not look surprising for Python developers, because this Python code would also fail:

def sum(a, b):
    return a + b

print(sum("10", 20)) # TypeError

So what is the difference? Let’s tweak both examples in C and Python, and call sum with two strings:

print(sum("10", "20")) # > 1020

Here we get no error, because polymorphism works and string addition is valid. But what happens in C?

int main() {
    printf("%d\n", sum("10", "20"));
}

You cannot even compile this program. You get the same error log as before. Notice how we defined sum in C: we explicitly set input argument types to int. That means arguments of any other type cannot be passed into this function. This is static typing. Static typing also requires a type for each variable and prevents changing variable types after declaration. In other words, the type is fixed.

The second group is dynamically typed languages: Python, Lua, JavaScript, and others. In those languages, the variable type is not strictly fixed and can change during execution.

# Benefits of Typing

Now to the question: why do we need typing if Python already works well without it? First, speed. At a low level (whatever representation you use), types are always needed. If we do not write them explicitly, it only means someone else does that for us (for example, a virtual machine), which requires resources. That is reflected in language speed rankings:

In this rating, Python is at the bottom. Will typed Python fix that? Unfortunately, no. Python was not and still is not a statically typed language. Type annotations in Python remain optional. You can omit them, and the Python interpreter does not enforce them at runtime.

This brings us to the second benefit of types: code quality.

“The goal of typing in Python is to help development tools find errors in Python code bases through static analysis, without running code tests.”

Luciano Ramalho, “Fluent Python”

Extending this idea, typing goals are:

• Early error detection, before runtime and before production failures.
• “Test extraction”: correct typing can reduce the number of tests, which are often harder to write and maintain than types. Tests can then focus on business logic, not primitive mismatches.
• Better readability: PEP 20 says “Explicit is better than implicit.” When reading code, function signatures are often enough without diving into implementation.
• Better IDE workflow with more hints and warnings.
• Better architecture quality: types force cleaner abstractions.

# How to Write Typed Code

Before code, let’s separate three important concepts: interface, abstract class, and protocol. What is the difference?

• Interface is a class where all methods are abstract, with no implementation details.
• Abstract class is a class with both abstract and implemented methods.
• Protocol is an implicit interface.

The first two are straightforward. Let’s focus on the last one. In Python, an interface pattern is usually implemented through inheritance: a class implementing an interface inherits from that interface class. A class implementing a protocol does not have to inherit from it and may not even know about it.

## Primitives

Let’s finally look at how to write typed code. Start with a simple function that repeats a string n times.

def multi_string(string, n):
    return string * n

print(multi_string("cat", 3)) # > catcatcat

This function takes a string and a number and returns a string built by concatenating the original string with itself n times. Now type it:

def multi_string(string: str, n: int) -> str:
    return string * n

Syntax is simple: input parameter types go after a colon, output type goes after an arrow. Your IDE can now highlight errors if inputs are wrong or if returned values are handled incorrectly.

You can annotate all common primitives this way: str, int, bytes, float, Decimal, bool.

## Union Types

In real code there are more complex cases where a function should accept multiple types, but not arbitrary ones. In those cases use unions:

def normalize(data: str | bytes) -> str:
    if isinstance(data, bytes):
        return data.decode("utf-8")
    return data

Here normalize accepts either a string or bytes and always returns a UTF-8 string. With union (|), you can list multiple types, but you should use this carefully. If you feel like writing a long union of ten types, pause and reconsider. We will cover ways to handle such cases below.

Unions are also valid for return types, but mostly for optional results. Example:

def parse_int(value: str) -> int | None:
    if not value.isdigit():
        return None
    return int(value)

This means the function result is optional. It may return int, or may not return one if parsing fails. But annotating returns as int | str or other unrelated combinations is usually bad practice. It becomes unclear how to process the result. In practice, return either a concrete type with known methods/attributes, or None. Breaking this rule tends to complicate code.

## Collection Specification

Besides primitives, you can and should annotate collections. Avoid plain data: list; specify element types too. Use square brackets:

def format_user(user: tuple[str, int]) -> str:
    name, score = user
    return f"{name}: {score} points"

def average(values: list[float]) -> float:
    if len(values) == 0:
        return 0
    return sum(values) / len(values)

def total_count(counters: dict[str, int]) -> int:
    return sum(counters.values())

Of course, this does not cover all production scenarios. In TypedDict, NamedTuple, and Dataclass, we extend this toolkit.

## Mapping and MutableMapping

Mapping and MutableMapping are abstract base classes for dict-like structures. Mapping guarantees read-only behavior (keys, values, iteration), while MutableMapping says the object is mutable.

from collections.abc import Mapping, MutableMapping

def read_config(cfg: Mapping[str, str]) -> str:
    return cfg["DATABASE_URL"]

def patch_config(cfg: MutableMapping[str, str]) -> None:
    cfg["DEBUG"] = "1"

If a function only reads data, use Mapping. If it mutates data, use MutableMapping. This is a small but important signal for readers and type checkers.

## NamedTuple

When you need a fixed set of fields while keeping tuple behavior, NamedTuple is useful. It is immutable and indexable, but also lets you access fields by name.

from typing import NamedTuple

class User(NamedTuple):
    id: int
    username: str
    score: int

def print_user(user: User) -> str:
    return f"{user.username} ({user.id}) = {user.score}"

NamedTuple is good for compact data structures that should not change after creation. If you need mutability and richer behavior, prefer dataclass or a regular class.

## TypedDict

If your structure is a dictionary and you want typed keys and values, use TypedDict. It describes dictionary shape and works at static analysis level.

from typing import TypedDict

class User(TypedDict):
    id: int
    username: str
    email: str | None

def send_email(user: User) -> None:
    ...

This is especially useful when data comes from JSON or another dynamic source but you still want a strict key contract. If some keys are optional, define that explicitly to keep type checks meaningful.

## Dataclass

dataclass is a convenient way to define a data container with initializer, comparisons, and readable repr. This class is mutable by default and works well for domain objects and DTOs.

from dataclasses import dataclass

@dataclass
class User:
    id: int
    username: str
    email: str | None = None

def normalize(user: User) -> User:
    user.username = user.username.lower()
    return user

dataclass is a good fit when you need mutable structure and clear data modeling. If an object must be immutable, use @dataclass(frozen=True).

## Enum

Enum helps define a closed set of values. This is useful when a field has a strict list of allowed options and you do not want random strings in your code.

from enum import Enum

class Status(Enum):
    NEW = "new"
    DONE = "done"
    FAILED = "failed"

def is_done(status: Status) -> bool:
    return status is Status.DONE

This approach is practical for statuses, roles, flags, modes, and other enumerable domain values.

## Custom Classes

The type system can specify not only primitives but also your own or library classes. For example:

class User:
    id: int
    username: str
    email: str
    friends: list[User]

def hand_shake(user1: User, user2: User) -> None:
    user1.friends.append(user2)
    user2.friends.append(user1)

## Abstract Classes

Python has an excellent module, collections.abc. It already defines a large set of abstract classes that cover most practical needs. They are useful when you want to describe behavior, not a concrete implementation. What is available there?

collections.abc.ABCMeta
collections.abc.AsyncGenerator
collections.abc.AsyncIterable
collections.abc.AsyncIterator
collections.abc.Awaitable
collections.abc.Buffer
collections.abc.ByteString
collections.abc.Callable
collections.abc.Collection
collections.abc.Container
collections.abc.Coroutine
collections.abc.EllipsisType
collections.abc.FunctionType
collections.abc.Generator
collections.abc.GenericAlias
collections.abc.Hashable
collections.abc.ItemsView
collections.abc.Iterable
collections.abc.Iterator
collections.abc.KeysView
collections.abc.Mapping
collections.abc.MappingView
collections.abc.MutableMapping
collections.abc.MutableSequence
collections.abc.MutableSet
collections.abc.Reversible
collections.abc.Sequence
collections.abc.Set
collections.abc.Sized
collections.abc.ValuesView

As you can see, there are many abstract classes. Most describe a property of a collection. Using them in annotations lets you express wider polymorphic input boundaries for your functions:

from collections.abc import Iterable

def total(values: Iterable[int]) -> int:
    return sum(values)

total([1, 2, 3])
total((1, 2, 3))
total({1, 2, 3})

Sometimes you still see imports from typing like from typing import Iterable, Sequence. In practice, those are re-exports from collections.abc. Today it is better to import these ABCs directly from collections.abc.

## Sequence and Iterable

These two are often confused. Iterable only guarantees that an object can be iterated in a loop. No indexing, length, or ordering is promised. Sequence guarantees iteration plus indexing and length, that is __getitem__ and __len__. This leads to a practical difference in what operations are safe.

from collections.abc import Iterable, Sequence

def sum_any(values: Iterable[int]) -> int:
    total = 0
    for v in values:
        total += v
    return total

def head(values: Sequence[int]) -> int:
    return values[0]

sum_any accepts a list, tuple, or generator. head cannot accept a generator, because it has no indexing and you cannot do values[0]. So, if you only need iteration, use Iterable; if you rely on indexing or length, use Sequence.

## Callable

Callable is used when a function accepts another function. This is especially important for callbacks, event handlers, and higher-order functions.

from collections.abc import Callable

def apply(values: list[int], fn: Callable[[int], int]) -> list[int]:
    return [fn(v) for v in values]

If the signature is unknown in advance, you can use Callable[..., ReturnType], but this should be a last resort.

## Generics

Generics are parameterized types. In simple terms, these are types that accept other types. This matters when you want to preserve the relation between input and output instead of losing it to Any. For example, first returns the same item type as inside the input collection:

from collections.abc import Sequence
from typing import TypeVar

T = TypeVar("T")

def first(items: Sequence[T]) -> T:
    return items[0]

Without generics, you would write Sequence[Any] and lose output type. With generics, the analyzer knows that if input is Sequence[str], the result is str. This is especially important for collections, factories, and repositories where one implementation handles multiple types.

It is also useful to know that TypeVar has a bound parameter that restricts which types can be used in a generic:

from collections.abc import Hashable, Iterable
from typing import TypeVar

HashableT = TypeVar("HashableT", bound=Hashable)
def mode(data: Iterable[HashableT]) -> HashableT:
    ...

## Literal

Literal lets you fix exact allowed values, not just a base type. This is useful when a parameter has a closed set of modes, statuses, or keys.

from typing import Literal

def export_report(format: Literal["csv", "json"]) -> bytes:
    ...

The signature above defines the contract clearly: no third format exists here. This makes APIs clearer and lets type checkers catch typos such as "jsno" before runtime.

## Static Analyzers

Now it is time to discuss what makes typing practical in Python: static analyzers. They read annotations, compare them with actual code, and report problems before runtime.

• mypy is the classic static type checker for gradual typing. Strength: plugin ecosystem and precise per-module strictness tuning. Weakness: without tuning it can be either too soft or too noisy.
• pyright is a fast and clear checker. Strength: good diagnostics and fast feedback. Weakness: plugin-style extensibility is weaker than in mypy.
• pyrefly is a new fast Rust analyzer. Strength: high speed and LSP integration. Weakness: still young, so some behavior may change.
• ty is a new Rust tool by Astral (currently beta). Strength: speed and modern architecture. Weakness: pre-release stage; feature set is still catching up to mature checkers.

You can install and run them with uv:

uv tool install mypy
uv tool install pyright
uv tool install pyrefly
uv tool install ty

uvx mypy .
uvx pyright .
uvx pyrefly check
uvx ty check

Here is a business-oriented example with intentional typing mistakes:

from dataclasses import dataclass
from typing import NewType

UserId = NewType("UserId", int)

@dataclass
class User:
    id: UserId
    email: str
    is_active: bool

def discount(total: int, percent: int) -> int:
    return total - total * (percent / 100)

def send_invoice(user: User, amount: int) -> str:
    if not user.is_active:
        return None
    return f"invoice for {user.email}: {amount}"

def main() -> None:
    user = User(id=42, email=123, is_active="yes")
    total = discount("1000", 10)
    send_invoice(user, "500")

Running pyright on this file will produce messages roughly like:

error: Type "float" is not assignable to return type "int"
error: Type "None" is not assignable to return type "str"
error: "Literal[42]" is not assignable to "UserId"
error: "Literal[123]" is not assignable to "str"
error: "Literal['yes']" is not assignable to "bool"
error: "Literal['1000']" is not assignable to "int"
error: "Literal['500']" is not assignable to "int"

What matters in this output:

• Errors in discount and send_invoice show function contract violations: the signature promises one thing, implementation does another.
• Errors in main show boundary-layer issues (input/DTO) passing wrong types into domain logic.
• The UserId error demonstrates why NewType is useful in business code: a user identifier cannot be accidentally replaced by a plain int without an explicit decision.

## Stub Files (.pyi)

Sometimes you want typing for code you cannot or should not edit. Examples: generated code, third-party library code, or your own module where you do not want to mix typing and implementation. That is what stub files with .pyi extension are for.

A .pyi file contains type signatures only and no implementation. Static analyzers look for these files near source code or in dedicated types-* packages. Example:

calc.py:

def add(a, b):
    return a + b

calc.pyi:

def add(a: int, b: int) -> int: ...

This way you can keep typing separate from implementation, sometimes even without access to source code.

## TypeAlias

When a type gets complex, move it into an alias to keep signatures readable. This is especially useful for business terms like UserId, Currency, or Payload.

from typing import TypeAlias

UserId: TypeAlias = int
Payload: TypeAlias = dict[str, str | int | float]

Then you can write:

def send(user_id: UserId, payload: Payload) -> None:
    ...

In Python 3.12+, you can use the type statement instead:

type UserId = int
type Payload = dict[str, str | int | float]

This is the same alias, just shorter and easier to read.

## TypeAlias vs NewType

TypeAlias is just a type synonym, it does not create a new type. NewType creates a distinct type at static-checking level, even though at runtime it is just a wrapper function. This is useful when you have logically different values of the same base type, for example UserId and OrderId.

from typing import NewType, TypeAlias

UserId: TypeAlias = int
OrderId = NewType("OrderId", int)

def get_user(user_id: UserId) -> None:
    ...

def get_order(order_id: OrderId) -> None:
    ...

UserId and int are treated as the same type. OrderId is not compatible with int without explicit conversion.

# How to Use Typing Correctly

Set the right expectation first. Like tests, the purpose of types is to fail when the code is wrong. If they never fail, they are not doing useful work. The less forgiving your typing setup is, the better it protects your code. Strict typing (like strict tests) catches bugs, but only if checks can actually fail.

Writing truly correct typed code is hard. It is a separate skill that grows the same way architecture and testing skills grow. So start small and increase strictness gradually.

## Returning None

Also consider the case where a function returns nothing:

def print_weather(weather: Weather):
    print("Weather:")
    for date, data in weather.by_days().items():
        print(date)
        print(f"\t{data.temperature}")
        print(f"\t{data.humidity}")
        print(f"\t{data.wind_speed}")
        print("========")

tmp = print_weather(Weather()) + 1

In Python, if a function has no return, it returns None. Static analyzers know this too. For example, pyright on this intentionally broken code will show:

error:
    Operator "+" not supported for types "None" and "Literal[1]"

This shows that pyright understands the return type as None. Does that mean you can skip return annotations? No. First, PEP 20 says explicit is better than implicit. Second, consider developer experience (DX) in Python. Everyone knows typing is optional, so missing return annotation is ambiguous. When you see a function signature without return type, you cannot tell whether the author skipped typing or the function really returns None. You resolve that only by reading implementation details, which slows code navigation.

## Function Input vs Output

Continuing the return-type topic: avoid using abstract classes from collections.abc, or custom abstract classes, for function return types. They are better suited for input types where you want broad polymorphism. Return values should be concrete so it is clear how to use the result.

Important

A function should be more explicit about what concrete type it returns than what it accepts.

If you want to go deeper, here are useful resources to configure your tools and understand Python typing in detail:

• FastAPI type hints guide (helpful for web developers)
• RealPython, Type Checking Guide
• Exercises

So, where does any contribution begin? Ideally, with a problem. A problem can be called anything, including a lack of new features, missing or incomplete documentation pages on a specific topic, some question, or simply trivial bugs that exist everywhere. You personally will not confuse a problem with anything else, because it will be accompanied by an itchy feeling that “something is annoying.” But will this be a problem for other users and developers? In order to understand this and synchronize your perception with the team’s perception, an issue exists.

CONTRIBUTION.md

Every project has its own established rules on how to participate in it. These rules are described either in README.md in a separate “Contribution” paragraph, or in a special CONTRIBUTION.md file. Be sure to read it at the very beginning. This file has the highest priority. That is, even if you understand that some practices deviate from the correct scheme that we will consider below, you should still follow them. Some large projects, such as Postgres or linux-kernel, still work entirely via mailing lists. One should respect the traditions that have formed in the repository, even if they now look like legacy.

# 1. Issue

An issue is a ticket that is stored in the repository. Anyone who comes to the repository can create it. But I recommend that before rushing to describe your problem, you make several attempts to search for similar issues, so as not to burden the repository maintainers with unnecessary work. Let’s see how this can be done:

gh issue list --search "app crashed"

This and all further examples will use the official gh utility. It allows you to perform all basic GitHub operations from the console. I recommend using it for simple operations to speed up your workflow.

The search parameter allows you to add various search filters directly inside it. Let’s try to add them:

gh issue list --search "app crashed is:open label:bug created:>2024-01-01"

It is quite possible, especially in large projects, that this will allow you to find an already created ticket for your problem and even find a solution or answer in it. If not, then do not hesitate to open a new issue. The following scheme will help structure it in the best way:

  graph LR
    A[Excepted] ---> B("Action (run/click/etc)")
    B ---> C[Got]

In large projects, there are issue templates that will help you format an issue according to the standards adopted in that project. You can create an issue with the command:

gh issue create

Another excellent practice is providing a Docker image in which the entire environment is configured and the problem is guaranteed to be reproducible. Or at least provide a log. A professional approach would also be to localize the problem as much as possible. For example, you received an error in the following file:

import fruits
import logistic

a = fruits.Apple()
basket = fruits.MakeBasket()
basket.put(a)
logistic.send(basket)

Of course, you could write exactly this in the issue. But it would be even better to independently experiment with this code and understand what exactly is wrong. For example, check whether the apple was successfully added to the basket:

basket.put(a)
print(basket.content())

Perhaps the problem is that we are trying to send an empty basket, which would mean a bug in the put method. Or perhaps the problem is in the send method after all. In this way, we cut off the unnecessary, leaving the essence of the problem in the issue message.

Remember that even the fact of successfully creating an issue—for example, proposing a valuable feature or discovering a real bug or vulnerability—is already a contribution to the project, and that is already a success. A failure, on the other hand, would be creating a duplicate issue or overloading maintainers with unnecessary context.

# 2. Fork

When you understand which problem you are solving and are convinced that it is really a problem, you can move on to solving it. To do this, you should first fork the repository. This will be valuable support for you if, for example, you are testing CI or simply getting far ahead of the original repository, and it will also allow you to send pull requests, since you most likely do not have permission to make changes to the original repository:

gh repo fork <OWNER>/<REPO>

After cloning the fork locally, make changes in a separate branch, which it will be more convenient to name after the issue number you are trying to close. Why? Because in a short, concise branch name it is far from always possible to express the essence of the problem, which may have taken several months of discussion in the ticket. Therefore, it is much more convenient to simply refer to it by the issue number:

git switch -c 42

In GitHub flow, we do not create a complex branch structure where each branch has its own meaning. Instead, we have a master branch into which only changes that have passed all checks are merged. These changes come there from many so-called feature branches, which we propose to tie to specific issues. And from time to time, we release a version from the master branch. As a result, we get a fairly concise structure:

  %%{init: {
  "gitGraph": {
    "tagLabelColor": "#ffffff",
    "tagLabelBackground": "#d73a49"
  }
}}%%
gitGraph
    commit
    commit
    branch "42"
    checkout "42"
    commit
    commit
    checkout main
    merge "42"
    commit tag: "🚩 v1.1.23"

    branch "44"
    checkout "44"
    commit
    commit
    commit
    checkout main
    merge "44"
    commit tag: "🚩 v1.2.0"

Also, do not forget to synchronize your fork so as not to lose connection with the original project:

gh repo sync <your-username>/<fork-repo> --branch main

# 3. Pull request

When the changes are made and committed, you can send a pull request. The most convenient way is to simply stay on your branch and run the command below. gh will form a suitable pull request itself:

gh pr create

After creating the PR, checks may automatically start if CI is configured in the repository. And this is great. Because checks simplify and speed up the review process. You can immediately see, for example, that your code does not pass style checks, or that you did not write tests for your code and because of this the code coverage failed. Do not ignore this, but make new commits in the same branch, and after pushing them they will automatically be added to the PR and the checks will be restarted. The repository maintainer will not even begin reviewing your PR until all checks in it turn green. You can check the status of the pull request with the command:

gh pr status

Also try to make a neat commit history in the pull request to simplify the review process. Squash commits will help you with this.

When you have broken through all automated checks, do not hesitate to contact the repository architect and ask for a review. He will either review your PR himself or delegate it to someone from the team. On GitHub, this is done simply via a tag: @username. Often, notifications that a new pull request has arrived may be disabled, and moreover, the architect will not know when you have made all the fixes to pass CI. Therefore, modesty here may lead to the fact that your pull request will simply not be seen by anyone. This, by the way, also applies to issues.

If you understand that your pull request completely closes the issue you were solving, then in the PR messages you can specify Close #49, and then the issue will be automatically closed after the pull request is merged.

# 4. Merge

So, when you have passed all automated checks and manual review, your code will get into the master branch of the repository, and you can consider yourself a full-fledged contributor to this project. Keep it up!

Also pay attention to an interesting practice that, in my opinion, is very professional. Imagine that you discovered and reported some bug in an issue. This is already a contribution to the repository. Next, it is proposed to create a pull request in which you write a test that reproduces this bug. The test, of course, will fail. But you send the pull request, thereby adding this test in a disabled state to the codebase. You can also leave a TODO tag. And this will become an even greater contribution to the repository, since you have added a meaningful test, and this is always very useful. And finally, with a second pull request, you already submit changes that fix the code so that it passes this test. And once again you increase your contribution. Thus, you have left behind a lot of artifacts in the repository: an issue, an enhanced test system, and a fixed bug. This will be an excellent example of implementing the TDD (Test Driven Development) approach.

Thus, you and I have gone through the full cycle from the problem to the contribution to the master branch.:

  flowchart LR
    BUG["Find a bug / feature   "] --> ISSUE["Create Issue  "]
    ISSUE --> DISCUSS["Discussion  "]
    DISCUSS --> PR["Open Pull Request  "]
    PR --> CI["PR Checks with CI 󰦕 "]
    CI --> REVIEW["Reviewer Reviews PR  "]
    REVIEW --> MERGE["Merge PR into main  "]
    MERGE --> BUG

You can test your strength right now by finding a suitable issue using these wonderful services:

• Good First Issue — Issues that are great for beginners.
• Awesome for Beginners — A collection of projects for beginners.
• Up For Grabs — Tasks open for solving across various technologies.
• First Contributions — A repository with a manual and a list of open projects.
• First Timers Only — More similar resources.

Do not forget that you yourself can also register your projects on these resources to attract new developers!

GitHub CLI

If you are interested in productive work with GitHub from the console using the gh utility, pay attention to it documentation. And also for that, that gh supports extensions that you can familiarize yourself with you can use the gh ext browse command or write your own!

Some additional reading:

• Official GitHub guideline
• Pull Requests like a Pro, Navendu Pottekkat
• 10 Common Mistakes to Avoid When Contributing to Open Source Projects
• Open Source for Beginners

Firstly, let’s make a little speculations, using our intuition. We, sure, if $\sum\limits_{i = 1}^{n}{x_i} = n$, that $H_0$ is false, because we haven’t reason for assume, that coin can be $0$, therefore $p = 1$. But, what about case, when we have $n = 20$ and $\sum{x_i} = 15$? In this case, we can’t be sure. Our questions, it’s, how to make a decision in such situations. In this decision we may make a one of two types of errors:

And in statistics our default predisposition it’s minimization errors of type 1. For example, if we made a medicine drug and after testing we checking $H_0$: “Our medicine drug is effective.”. If we make error of type 1, we will put broken drug to many peoples — it’s not good. In business, if make first type error we need to spend more many for new model. That’s the reason, for:

For make this decision we need to compare $\sum{x_i}$ with $0.5n$. How big is difference? The theorem of Moivre–Laplace:

Let’s use it in our case:

For example, if in real experiment we got $Z = 10$, that’s mean $H_0$ is very unlikely. So, we need to define the border $t$ for $Z$, after that we reject $H_0$: We need to find the value of $t$, that probability of cross over it, is significance level $\alpha$. If $|Z| > q_{1 - \frac{\alpha}{2}}$, we talk $H_1$ is truth and we reject $H_0$. Else, we approve $H_0$.

The interesting fact is first type of errors very easy for control. We can always say, that $H_0$ is truth. Then probability of errors type 1 will equal zero.

Whole numbers:

• TINYINT — from $-128$ to $127$.
• SMALLINT — from $-32 768$ to $32 767$.
• INTAGER — from $−2 147 483 648$ to $−2 147 483 647$.
• BIGINT — very big!

Float numbers:

• FLOAT — single precision, approximately 7-8 significant digits.
• DOUBLE — double precision, approximately 15-16 significant digits.
• NUMERIC / DECIMAL — fixed precision, use as NUMERIC(precision, scale), where precision – total digits count, scale – count digits after dot.

Strings:

• CHAR(n) — string of fixed length. n defined maximum string length, if string less than n it sill be fill with spaces.
• VARCHAR(n) — string of variable length. n defined maximum string length. It’s more optimized and effective, because keep only real string length.
• TEXT — string of variable length, without limits (it depends on DBMS).
• ENUM — enumerate. Keep only one from defined list values, for example ENUM('male', 'female', 'other').

Date and time:

• DATE — store only date (year, month, day).
• TIME — store only time (hours, minutes, seconds).
• DATETIME — store time and date.
• TIMESTAMP — store date and time, considering time zone.

Logical data:

• BOOLEAN — store logical value: TRUE or FALSE. Some time can be represented as TINYINT with $1 = \texttt{TRUE}$ and $2 = \texttt{FALSE}$.

Binary data:

• BLOB (Binary Large Object) — store big binary data, like images, videos, audios and so on.
• BINARY(n) — binary string with fixed length n.
• VARBINARY(n) — binary string with variable length, but max length is n.

Other:

• JSON — store the json data.
• XML — store xml data.

# Relation algebra

Relational algebra serves is the theoretical basis for SQL. This means that any query that can be expressed in SQL can also be expressed in relational algebra, and vice versa. Understanding relational algebra helps you understand how SQL queries are processed and optimized.

Key concepts:

• Relation — in relation algebra it’s the similar as table in database: columns and rows.
• Attribute — column in relation.
• Tuple — row in relation.
• Relation Schema — description structure of relation, which include attributes names and data types.

Let’s see on operators of relation algebra. You can try all of this examples in RealX.

π (pi) — Operation, that create new relation, selecting specified attributes from source relation. It’s similar as SELECT in SQL. For example we can get the list of all books titles and authors:

π author, title (books)

As result:

+-----------------+-----------------------------+
| author          | title                       |
|-----------------+-----------------------------|
| Salinger        | The catcher in the Rye      |
| Robert Martin   | Clean code                  |
| Platon          | The State                   |
+-----------------+-----------------------------+

σ (sigma) — Operation, that create new relation contains only tuples, which satisfy specified condition. It’s similar as WHERE in SQL. This example give me the books only from Salinger:

σ author = "Salinger" (books)

∪ (union) — Operation, that create new relation contains all tuples, which exists at least one of two source relations. Its similar as UNION in SQL. I can union books from Salinger and books published at 2024-01-05:

(σ author = 'Selinger' (books)) ∪ (σ publish_at = '2024-01-05' (books))

− (subtraction) — Operation, that create new relation, includes tuples, which contains into first relation but missing in second. Next example show ids of books, that no from Salinger.

π id (books) – π id (σ author = 'Salinger' (books))

× (cross join) — Operation, that create new relation contains all combinations of tuples from two source relations. It’s similar as CROSS JOIN in SQL. For example:

(σ id = 1 (books)) × (σ book_id = 1 (reviews))

⋈ (natural join) — Operation, that create new relation, contains tuples from two source relations, that have same values in attributes with same name. Duplicated attributes remove from result relation. It’s similar as NATURAL JOIN in SQL. For example:

books ⋈ reviews

⋈ θ (theta join) — Operation, that create new relation, contains tuples from two source relations and satisfy specified condition θ. Condition can include operators: =, ≠, >, <, ≥, ≤. For example:

(books) ⋈ books.id = reviews.book_id (reviews)

⋈ = (equjoin) — A special case of theta join, where condition is equal values of attributes. The previous example show this.

÷ (division) — Binary operation, that create new relation, contains tuples from first source relation, that connected with all tuples from second source relation. This is a powerful operator for solving tasks like: “Find all X, that connected with Y.” For example:

π title, author (σ status = 'available' (library)) ÷ 
π title (σ author = 'Selinjer' (books))

Here is two terms, first is π title, author (σ status = 'available' (library)) and it’s return the available books with title and author attributes:

+-----------------+-----------------------------+
| author          | title                       |
|-----------------+-----------------------------|
| Salinger        | The catcher in the Rye      |
| Robert Martin   | Clean Code                  |
| Platon          | The State                   |
| Selinjer        | Advanced Algebra            |
| Selinjer        | Linear Algebra              |
+-----------------+-----------------------------+

Second term π title (σ publish_at = '2024-01-05' (books)) is return the list of Selinjer books:

+------------------+
| author           |
|------------------|
| Selinjer         |
| Stive Machonnel  |
+------------------+

Division of this two relations will return the list of titles where authors equals and drop author attribute:

+-----------------------------+
| title                       |
|-----------------------------|
| Advanced Algebra            |
| Linear Algebra              |
+-----------------------------+

This is the available books in library from author published it at '2024-01-05'.

γ (aggregation) — Operation, that groups tuples by specified attributes and execute aggregate function (sum, max, min, count, average). It’s similar as GROUP BY in SQL. For example:

γ title; COUNT(author) -> count (books)

The problem settings is pretty simple: we want to calculate statistics (mean, variance, covariance, correlation) step by step, when we receive $n$ data in a stream, without saving all data and additional iteration. Let’s remind formulas on base way. Mean:

Variance:

As you see for mean we need sum: first problem — how to get sum without all numbers? And for variance we need mean: second problem — how to know mean without all data?

# Intuition of method

Let’s try to feel the intuition of Welford method. Imagine we have the dataset: $A = \{1, 2, 3\}$, mean of this dataset is $\overline{x}_A = \frac{1 + 2 +3}{3} = 2$ and then we got one more number: $6$. Do you feel it will be move our mean to the bigger side? But how much bigger? Imagine similar dataset but with more data: $B = \{1, 1, 2, 2, 3, 3\}$ the mean also is $2$ and we also adding number $6$. Again we fill it will be move to the bigger side, but no so strong. Let’s check our intuition:

Our intuition was right! It remains for us to figure out how we can calculate this delta, if we got only previous mean $\overline{x}_{i - 1}$, new number $x_i$ and count of our numbers. The Welford method told: every new value move mean in its own direction with weight $1/i$:

Let’s check it for $B$ dataset. We got mean without new number $\overline{x}_{i - 1} = 2$ and new number $x_i = 6$ and it’s a seventh number, $i = 7$. Goal is find a $\overline{x}_i$ mean with Welfod forumula:

It’s absolutely exact value, as you see. Nice!

# Variance, correlation, covariance

The real power of Welford’s algorithm reveals itself when calculating variance. The naive approach requires storing all data points and recalculating the mean before computing variance, which is computationally expensive. Welford’s method elegantly solves this by maintaining a running estimate of variance using the following recurrence relation:

For variance, we maintain the current mean $\overline{x}$ and the sum of squares of differences $S$. For each new data point $x_n$ at step $n$:

The population variance can then be calculated as $\sigma^2 = S_n/n$, while the sample variance is $s^2 = S_n/(n-1)$.

This approach extends beautifully to covariance and correlation. For two variables $X$ and $Y$, we maintain counts $n$, means $\overline{x}$ and $\overline{y}$, and accumulated products $C_{xy}$:

The covariance is then $\text{cov}(X,Y) = \frac{C_{xy_n}}{(n-1)}$ and correlation is $\text{corr}(X,Y) = \frac{C_{xy_n}}{\sqrt{S_{x_n} S_{y_n}}}$.

# C implementation

Here’s a complete C implementation of Welford’s algorithm for calculating mean and variance:

#include <stdio.h>
#include <math.h>

typedef struct {
    long long n;
    double mean;
    double M2;
} welford_state;

void welford_update(welford_state *state, double x) {
    state->n++;
    double delta = x - state->mean;
    state->mean += delta / state->n;
    state->M2 += delta * (x - state->mean);
}

double welford_mean(const welford_state *state) {
    return state->mean;
}

double welford_variance(const welford_state *state) {
    return (state->n > 1) ? state->M2 / (state->n - 1) : 0.0;
}

double welford_stddev(const welford_state *state) {
    return sqrt(welford_variance(state));
}

int main() {
    welford_state state = {0, 0.0, 0.0};
    double test_data[] = {1.0, 2.0, 3.0, 6.0};
    size_t data_size = sizeof(test_data) / sizeof(test_data[0]);
    
    for (size_t i = 0; i < data_size; i++) {
        welford_update(&state, test_data[i]);
        printf("Added %.1f: mean=%.3f, variance=%.3f, stddev=%.3f\n",
               test_data[i], welford_mean(&state), 
               welford_variance(&state), welford_stddev(&state));
    }
    
    return 0;
}

For covariance and correlation, we can extend this approach:

typedef struct {
    long long n;
    double mean_x, mean_y;
    double C2;
} welford_cov_state;

void welford_cov_update(welford_cov_state *state, double x, double y) {
    state->n++;
    double delta_x = x - state->mean_x;
    double delta_y = y - state->mean_y;
    state->mean_x += delta_x / state->n;
    state->mean_y += delta_y / state->n;
    state->C2 += delta_x * (y - state->mean_y);
}

double welford_covariance(const welford_cov_state *state) {
    return (state->n > 1) ? state->C2 / (state->n - 1) : 0.0;
}

As developers, we live in a world of dynamic values. API tokens, temporary URLs from tunneling services like ngrok or localtunnel, database connection strings, and feature flags are the lifeblood of our modern applications. In compiled languages or Node.js environments, we have a rich ecosystem of tools like dotenv and configuration libraries to manage this dynamism seamlessly. They allow us to externalize configuration, injecting values from environment variables or secret managers at runtime.

But what about the static parts of our projects? Consider a simple HTML file that needs to display a temporary public URL, a JavaScript config object for a lightweight script, or a static configuration file for a legacy system. These aren’t processed by a bundler or a framework; they are flat files. The traditional solution is manual, error-prone, and frustrating: run a command, watch its output, copy the new value, open a file, find the right line, paste, save, and then repeat for every other file that needs the same value — boredom. This process breaks flow state and is utterly antithetical to the automation we cherish.

I found myself facing this exact problem one too many times. The constant context-switching between my terminal and editor to update URLs was a nagging inefficiency. I knew there had to be a better way — a way to treat these static files as dynamic endpoints for configuration. This frustration was the catalyst for Devsyringe, a CLI utility written in Go designed to automate this very workflow.

# The Core Idea: Declarative Configuration Injection

The motivation behind Devsyringe wasn’t to build another templating engine or a complex build system. The goal was simpler and more focused: to create a tool that can run a command, parse its output for a specific value using a regex, and then inject that value into one or more target files. The entire behavior is defined declaratively in a simple YAML configuration file, typically named devsyringe.yaml.

Think of it as a universal adapter between the dynamic output of CLI tools and the static text of your config files. It’s purpose-built for scenarios where heavier solutions are overkill or simply don’t fit. The real magic is in the hands-off automation; you define the rules once, and from then on, a single command keeps everything in sync. It’s the missing glue that makes your entire setup feel truly dynamic.

# Real-World Use Cases and Practical Applications

Let’s move beyond abstract concepts and look at practical, powerful use cases that save you from tedious manual work. The pattern is universal — any CLI command that outputs a value you need in a file is a perfect candidate for automation.

The Classic Tunnel Automation. When developing web applications, you often need to expose your local server to the internet. Tools like localtunnel or serveo generate unique, random URLs that must be configured in both your frontend and backend code. Here’s how Devsyringe handles this automatically:

serums:
  localtunnel:
    source: lt --port 8080
    mask: https://[a-z0-9\-]+\.loca\.lt
    targets:
      env_file:
        path: ./.env
        clues: ["API_BASE_URL"]
      frontend_config:
        path: ./src/config.js
        clues: ["API_URL", "const"]

This configuration defines a complete workflow: execute the tunnel command, extract the URL using regex, and inject it into both the .env file and JavaScript configuration. The entire process becomes a single command: dsy inject.

Dynamic Documentation and Résumé Automation.
Here’s a more sophisticated use case: keeping technical documentation or LaTeX-generated résumés updated with live statistics. Imagine your résumé.tex file contains a line like: \newcommand{\githubstars}{427}

With Devsyringe, you can automatically populate this with your current GitHub statistics:

serums:
  github_stats:
    source: curl -s "https://api.github.com/users/yourusername/repos" | jq 'reduce .[] as $repo (0; . + $repo.stargazers_count)'
    mask: "(\d+)"
    targets:
      resume:
        path: ./resume.tex
        clues: ["githubstars"]

This setup calls the GitHub API, calculates your total star count across all repositories, and updates the LaTeX source file. Your résumé maintains accurate, current statistics without manual intervention — perfect for job applications or portfolio updates. But then you can set up CI for regular updates with each push if you use the resume repository.

Advanced Infrastructure Management. For more complex setups, Devsyringe shines in infrastructure automation. Consider these scenarios:

• Fetching fresh database credentials from HashiCorv Vault and injecting them into application properties
• Retrieving current deployment endpoints from service discovery and updating API gateway configurations
• Pulling infrastructure IP addresses from cloud providers and updating security group rules
• Extracting build metadata from CI systems and updating deployment manifests

The pattern remains consistent: command  output extraction  file injection. This simplicity makes it adaptable to countless automation scenarios. If you want a plain value from your hands — no problem, use: echo '<my-value>' as command, devsyringe will do the rest himself.

# Technical Architecture and Implementation

While Devsyringe’s concept is simple, building a robust CLI tool requires careful architecture. The project leverages Go’s strengths for concurrent processing and cross-platform compatibility while maintaining simplicity and reliability.

Project Structure and Design Patterns. The architectural elegance of Devsyringe lies in its deliberate use of the Decorator Pattern, which mirrors the layered structure of a cabbage — each leaf wraps around the core, adding functionality while preserving the integrity of the inner layers. This pattern is foundational to the tool’s design: lower-level components remain blissfully unaware of the layers above them, ensuring modularity and separation of concerns.

Crucially, this philosophy extends beyond the tool’s internal architecture to its interaction with your projects. Devsyringe operates as an invisible decorator for your codebase. Your application remains completely unaware of its presence—no special imports, hooks, or changes to your code are required. It simply updates static files on disk, and your project runs exactly as it did before, just with new values in place. It’s automation that feels like magic because it leaves no trace of itself behind.

This approach enables seamless integration into any workflow. Whether you’re using it locally to manage tunnel URLs or in CI/CD to inject build-time secrets, Devsyringe enhances your environment without altering its fundamental behavior. Your configuration files remain valid, your build processes unchanged, and your mental model intact — all while gaining the power of dynamic value injection.

The codebase follows standard Go conventions with clear separation of concerns:

│── cmd
│   └── dsy
│       └── main.go
└── internal
    ├── cli
    │   ├── commands.go
    │   └── tui
    │       └── tui.go
    ├── config
    │   └── config.go
    ├── process
    │   ├── process.go
    │   └── procmanager.go
    └── utils
        └── utils.go

This organization makes the codebase maintainable and testable while keeping logical components separated.

Key Technical Decisions. The implementation makes several thoughtful choices that enhance reliability and user experience:

Cobra CLI Framework provides professional-grade command structure, automatic help generation, and shell completion. The TUI interface, built with tview, offers real-time process monitoring that surpasses typical CLI tools: The process management system uses goroutines and channels for concurrent command execution and output capture. File injection employs simple pattern matching rather than complex parsing, making it universally applicable to any text format.

Robust Error Handling and Validation. The tool includes comprehensive error checking at every stage: configuration validation, command execution, output parsing, and file operations. Meaningful error messages guide users toward resolving issues rather than failing cryptically.

# Distribution and Cross-Platform Compatibility

A tool is only useful if it’s easily installable. Devsyringe leverages modern Go tooling to provide seamless installation across all major platforms.

Automated Builds with Goreleaser. The project uses Goreleaser to automate the release process, generating: Cross-platform binaries for Windows, macOS, and Linux, Package manager support (Homebrew, AUR), Debian and RPM packages in GitHub releases with checksums and signatures. Windows support already in backlog.

Installation Simplicity. Users can install through multiple channels. For Go developers:

go install github.com/alchemmist/devsyringe/cmd/dsy@latest

For macOS users:

brew install devsyringe

For Arch Linux users:

paru -S devsyringe

This multi-channel approach ensures the tool is accessible to developers regardless of their preferred environment.

# Why Devsyringe Will Change Your Workflow

The true value of Devsyringe emerges after the first time you use it in anger. That moment when you realize you’ll never again manually update a tunnel URL across multiple files. When your documentation automatically stays current with your API versions. When your résumé updates itself with your latest achievements.

It’s not just about time saved — though that accumulates surprisingly fast. It’s about maintaining flow state. It’s about eliminating the tiny frustrations that add up throughout a development session. It’s about having a tool that makes your entire development environment feel more integrated and automated.

The learning curve is intentionally shallow. The YAML configuration is straightforward, the commands are intuitive, and the feedback is immediate. You can go from installation to solving real problems in under five minutes.

# Getting Started and Next Steps

Ready to eliminate manual file updates from your workflow? Installation is simple:

go install github.com/alchemmist/devsyringe/cmd/dsy@latest

Visit the GitHub repository for complete documentation, examples, and source code. The README contains practical examples you can adapt immediately for your use cases.

Consider where in your workflow you’re still copying values between terminal and editor. That’s your starting point. Whether it’s tunnel URLs, API keys, version numbers, or statistics — Devsyringe can probably automate it. In repository you can find many issues, if you interested of this project, welcome!

Next we will set up a useful workflow for this case. But, this setup will use new feature, which is hardwired into Hyprland and most likely absent in other DEs/compositors. I will demonstrate our final goal. For example, my screen share can be looks, like this:

If you like my wallpaper you can find this and more very good stuff in my dotfiles repository on GitHub. Don’f forget: I love your stars!

Let’s go step-by-step. Firstly, let’s recall that in Hyprland release of version 0.50.0 a new windowrulev2 option noscreenshare was added. It’s a new release and now it isn’t controlled from hyprctl only from the config file, like this:

windowrulev2 = noscreenshare, class:^(org.telegram.desktop|obsidian|discord)$

This option will tell Hyprland to draw a black rectangle instead of window content (even if this window isn’t in focus or int the background). This works perfect and protects our privacy. But, I’ve found two inconvenient cases: 1. When we want to make screenshot (in my case, with flameshot) Hyprland interpret it as try to share our screen and hide all privacy windows. 2. Sometimes, I want to share something from my Obsidian, for example, and dive into configs in this moment — not so good.

# CLI control noscreenshare option

To fix this experience, let’s write a script for control window rule in config. If you don’t have time, the full version of the script here. Script will comment or uncomment line in config file with rule and save info about current rule state in maker-file ~/.config/hypr/.screenshare_rule_disabled. And script can be run with command toggle to change state to the opposite:

#!/bin/bash

CONFIG_FILE="$HOME/.config/hypr/hyprland.conf"
STATE_FILE="$HOME/.config/hypr/.screenshare_rule_disabled"

toggle_rule() {
	# TODO
}

case ${1} in
    "toggle")
        toggle_rule
        ;;
esac

Let’s write toggle_rule function. We will use sed (Stream Editor) Linux util. It’s one of the most powerful tools for text processing in Linux and Unix systems. It’s commonly used for tasks like search and replace, text transformation, and stream editing. Syntax of sed, in general, looks like this:

sed [options] "script" [file...]

We need -i option edit file in-place. Then write a script. Firstly we need to find string with noscreenshare rule, like in regex:

"/windowrolev2.*noscreenshare.*"

We start with "/" for write search query, this we need to line start with "windowrolev2", after that ".*" for any count of any symbols, between which "noscreenshare". Then we use "/" for end search query, and "s/" (substitute) for replace:

"/windowrulev2.*noscreenshare.*/s/^#//"

Finally, we use "^#" regular expression for find hash at the start of line and replace it to nothing: "//". Full command looks like:

sed -i '/windowrulev2.*noscreenshare.*/s/^#//' "$CONFIG_FILE"

Then use sed for add hash to start of line similar, depending on existence of marker-file:

toggle_rule() {
    if [ -f "$STATE_FILE" ]; then
        sed -i '/windowrulev2.*noscreenshare.*/s/^#//' "$CONFIG_FILE"
        rm -f "$STATE_FILE"
        CLASS="on"
    else
        sed -i '/windowrulev2.*noscreenshare.*/s/^/#/' "$CONFIG_FILE"
        touch "$STATE_FILE"
        CLASS="of"
    fi
}

In last step of script, we call this function, if toggle option was given, and return a json-like string for waybar. Full script:

#!/bin/bash

CONFIG_FILE="$HOME/.config/hypr/hyprland.conf"
STATE_FILE="$HOME/.config/hypr/.screenshare_rule_disabled"

toggle_rule() {
    if [ -f "$STATE_FILE" ]; then
        sed -i '/windowrulev2.*noscreenshare.*/s/^#//' "$CONFIG_FILE"
        rm -f "$STATE_FILE"
        CLASS="on"
    else
        sed -i '/windowrulev2.*noscreenshare.*/s/^/#/' "$CONFIG_FILE"
        touch "$STATE_FILE"
        CLASS="off"
    fi
}

case ${1} in
    "toggle")
        toggle_rule
        ;;
    *)
        if [ -f "$STATE_FILE" ]; then
            CLASS="off"
        else
            CLASS="on"
        fi
        ;;
esac

echo "{\"class\": \"$CLASS\", \"alt\": \"$CLASS\"}"

# Waybar module

To use this conveniently and instantly detect the current privacy state we write a waybar module:

"custom/noscreenshare": {
  "exec": "~/scripts/toggle_noscreenshare.sh",
  "on-click": "~/scripts/toggle_noscreenshare.sh toggle && pkill -SIGRTMIN+4 waybar",
  "signal": 4,
  "interval": "once",
  "return-type": "json",
  "format": "{icon}",
  "format-icons": {
    "off": "",
    "on": "󰗹"
  },
  "tooltip": false
},

Let’s describe whats going on here. To get value for this module we use exec field and set our script. Then we defined what will happen, when we click on module at on-click option: run script with toggle option and send system signal to waybar. This allows you to not reload all waybar process, but only this module. Here it’s very important to sync signal value and number at pkill -SIGRTMIN+4 waybar command, and to make this value unique only for this waybar module. Then we configure to run our script once on waybar startup and define view format (tooltip: false for not showing text, when hovering over cursor) . I’m using this nerdfonts icons for this, but they are not the same size. Therefore I fine-tune padding and add some styles:

#custom-noscreenshare {
  background: #1e1e2e;
  opacity: 0.7;
  padding: 0px 10px;
  margin: 5px 5px 3px 0px;
  border: 0px solid #181825;
  border-radius: 10px;
}

#custom-noscreenshare.on {
  font-size: 18px; 
  padding-right: 14px;
}

#custom-noscreenshare.off {
  font-size: 16px;
  padding-right: 16px;
  padding-left: 9px
}

After that we have got nice interface for hands-on control of our privacy:

FindProcess(ByTitle(title))
FindProcess(ByPID(pid))

This code is an example of the result of the predicate pattern. This example is synthetic, but here we’re trying to achieve a similar result here. Firstly, let’s figure out the predicate. Predicate is a function, that returns a boolean value — very simple!

Now, for example, we will write a method findProcess for ProcManager on Go with predicate pattern. The ProcManager has a field processes []*Process, which is slice of processes. And the Process has many unique fields, that we can use to searching. Our method will take a predicate and apply it to all items in the list until the predicate returns true, or the list ends and the search returns hmm... nothing was found.

For example, in Python we have a standard function filter, which takes an array of items and a predicate function, like this:

filter([1, 2, 3, 4, 5], lambda n: n % 2 == 0)

But here we need to handle predicates manually, because this is a more general function. For our case we add intermediate step: a predicate builder. Finally we will get this scheme: Let’s write a method findProcess:

func (pm *ProcManager) findProcess(searchPredicate ProcessSearchPredicate) (*Process, error) {
	pm.mu.RLock()
	defer pm.mu.RUnlock()

	for _, proc := range pm.processes {
		if searchPredicate(proc) {
			return proc, nil
		}
	}
	return nil, fmt.Errorf("no process with this parameter")
}

This method takes one argument: searchPredicate with specific type ProcessSearchPreciate:

type ProcessSearchPredicate func(p *Process) bool

Let’s see: it’s function from Process to bool — a predicate. Then we can write a predicate builder functions, like filter options:

func ByTitle(title string) ProcessSearchPredicate {
	return func(p *Process) bool {
		return p.Title == title
	}
}

func ByPID(pid int) ProcessSearchPredicate {
	return func(p *Process) bool {
		return p.PID == pid
	}
}

It will work like this:

proc, err := pm.findProcess(ByTitle(title))

This is already good, but I want to use autocomplete in my code editor for filter options. To make it we can rewrite filter options from functions to methods and use one empty object to call it, like this:

type ProcessSearchFilter struct{}

var filter = ProcessSearchFilter{}

func (f ProcessSearchFilter) ByTitle(title string) ProcessSearchPredicate {
	return func(p *Process) bool {
		return p.Title == title
	}
}

func (f ProcessSearchFilter) ByPID(pid int) ProcessSearchPredicate {
	return func(p *Process) bool {
		return p.PID == pid
	}
}

After that we can use like this:

proc, err := pm.findProcess(filter.ByTitle(title))

And my workflow in my code editor is very comfortable:

If you like my code editor view you can use my Neovim theme: nothing. And you can use my nvim config, find it in my dotfiles

Now we will understand how to find the desired value and then make a beautiful minimalistic waybar module for battery.

# Find a battery degradation value

Firstly get list of all power devices:

upower -e

Then find battery from this list:

upower -e | grep BAT

# For example:
# /org/freedesktop/UPower/devices/battery_BATT

Then get detailed information about this device, with -i flag of upower:

upower -i $(upower -e | grep BAT)

We got something like this:

  native-path:          BATT
  vendor:               DESAY
  model:                BASE-BAT
  serial:               1
  power supply:         yes
  updated:              Fri Jul 11 11:37:00 2025 (7 seconds ago)
  has history:          yes
  has statistics:       yes
  battery
    present:             yes
    rechargeable:        yes
    state:               charging
    warning-level:       none
    energy:              25.514 Wh
    energy-empty:        0 Wh
    energy-full:         47.5052 Wh
    energy-full-design:  59.4247 Wh
    energy-rate:         11.1573 W
    voltage:             11.972 V
    charge-cycles:       650
    time to full:        2.0 hours
    percentage:          53%
    capacity:            79.9417%
    technology:          lithium-ion
    charge-start-threshold:        75%
    charge-end-threshold:          80%
    charge-threshold-supported:    yes
    icon-name:          'battery-good-charging-symbolic'
  History (charge):
    1752222927	53.000	charging
  History (rate):
    1752223020	11.157	charging
    1752222990	11.123	charging
    1752222987	11.192	charging
    1752222957	10.822	charging
    1752222927	10.857	charging

Here many interesting information, for example charge-cycles, time to full battery, and so on. But now we use two parameters:

• energy-full-design — the original full battery volume
• energy-full — current battery volume Deference between this two parameters is degradation of battery: $$ \text{Degradation} = \left(1 - \frac{E_{\text{full}}}{E_{\text{design}}}\right) \times 100\% $$ Now let’s calculate this metric in percents.

First find this parameters in big output and devide them, with awk:

upower -i $(upower -e | grep BAT) | awk '\
	/energy-full:/ {ef=$2}\
	/energy-full-design:/ {efd=$2}\
	END {print ef/efd}'

Here we find energy-full and save to variable ef, find enengry-full-design and save to efd variable. On the end we divide them: ef/efd.

After that calculate percent value, with bc (is shell calculator for expression with float numbers):

echo "(1 - $(upower -i $(upower -e | grep BAT) | awk '\
        /energy-full:/ {ef=$2}\
        /energy-full-design:/ {efd=$2}\
        END {print ef/efd}')) * 100 + 0.5" \
	| bc

# Output example:
# 20.558200

Here we make + 0.5 for rounding when the fractional part is cut off later.

In last step we need to round value. We make it simple: we already add 0.5 to value and now it remains to cut off the fractional part with cut util:

echo "(1 - $(upower -i $(upower -e | grep BAT) | awk '\
        /energy-full:/ {ef=$2}\
        /energy-full-design:/ {efd=$2}\
        END {print ef/efd}')) * 100 + 0.5" \
	| bc \
	| cut -d'.' -f1

# Output example:
# 20

Here -d'.' means we split by dot and -f1 means we take first part.

# Waybar module

In my waybar config ~/.config/waybar/config.json I’m add two modules on right section, but you can do as you want. Finally i’m got this:

If you like my wallpaper you can find this and more very good stuff in my dotfiles repository on GitHub. Don’f forget: I love your stars!

Let’s see:

{
  "modules-left": [...],
  "modules-center": [...],
  "modules-left": [...],
  "modules-right": [
    "battery",
    "custom/battery-degradation",
  ],
}

First module it’s default battery module, for me it’s great work on hyprland. Here we define levels of good, warning and critical level of charging, define nerd icons format for different battery state:

"battery": {
  "states": {
    "good": 90,
    "warning": 25,
    "critical": 10
  },
  "format": "{icon} {capacity}%",
  "format-charging": " {capacity}%",
  "format-plugged": " {capacity}%",
  "format-icons": ["󰂎", "󰁺", "󰁻", "󰁼", "󰁽", "󰁾", "󰁿", "󰂀", "󰂁", "󰂂", "󰁹"],
  "tooltip": "{time}",
  "style": "{capacity < 10 ? 'color: red;' : 'color: normal;'}"
}

Second module it’s today topic: custom/batterydegradaion:

"custom/battery-degradation": {
  "format": " {}%",
  "interval": "once",
  "exec": "~/scripts/battery-degradation.sh",
  "tooltip": false
}

I’m put our command to script, for me it’s useful. You can do same, don’t forgot add shebang #!/bin/bash and:

chmod +x ~/scripts/battery-degradation.sh

In module we define the format with nerd icon and percent, turn off tooltip and set run once on waybar start (because this parameter changing very long).

And finish this modules with css style in ~/.config/waybar/style.css:

#battery,
#custom-battery-degradation {
  background: #1e1e2e;
  opacity: 0.7;
  padding: 0px 10px;
  margin: 3px 0px;
  margin-top: 5px;
  border: 0px solid #181825;
}

#battery {
  padding-right: 10px;
  border-radius: 10px 0px 0px 10px;
  min-width: 50px;
}

#custom-battery-degradation {
  border-radius: 0px 10px 10px 0px;
  margin-right: 5px;
  min-width: 35px;
}

#battery.critical {
  color: red;
}

Done! As result:

We have source vectors $v_1, v_2, \dots, v_n$, and we need to get orthogonal vectors $u_1, u_2, \dots, u_n$. In general, describe the method: 0. Remove all zero vector.

1. We take first vector unchanged: $u_1 = v_1$.
2. Next vector find from $v_2$ and projections to last vectors: $u_2 = v_2 - \text{Proj}_{u_1}{v_2}$.
3. Again: $u_3 = v_3 - \text{Proj}_{u_1}{v_3} - \text{Proj}_{u_2}{v_3}$.
4. And continue it to $u_n$ vector: $u_n = v_n - \text{Proj}_{u_1}{v_n} - \text{Proj}_{u_2}{v_n} - \dots - \text{Proj}_{u_{n - 1}}{v_n}$. Let’s remind how to find projection: $\text{Proj}_{u}{v} = \frac{\langle u, v\rangle}{||u||^2}u$. If we want orthonormal basis we can product all vectors $u$ to $\frac{1}{||u_i||}$.

Let’s see on example: $v_1 = \begin{pmatrix}1 \\ 1\end{pmatrix}, \ v_2 = \begin{pmatrix}1 \\ 0\end{pmatrix}$. Firstly set $u_1 = v_1$, then $u_2 = v_2 - \text{Proj}_{u_1}{v_2} = \begin{pmatrix}1 \\ 0\end{pmatrix} - \begin{pmatrix}0.5 \\ 0.5\end{pmatrix} = \begin{pmatrix}0.5 \\ -0.5\end{pmatrix}$. Finally we got orthogonal vectors $u_1 = \begin{pmatrix}1 \\ 0\end{pmatrix}$, $u_2 = \begin{pmatrix}0.5 \\ -0.5\end{pmatrix}$.

See on example: $f(x, y, z) = x^2 + y^2 - 4x - 4y + z^4 - 4z^2$. Let’s find gradient:

Then set equal to zero: $\nabla f = 0$, and got system of equations:

Finally, we got this stationary points: $(2, 2, 0), \ (2, 2, \sqrt{2}), \ (2, 2, -\sqrt{2})$.

If you want to continue analysis, use Hessian matrix.

Now, look at case, when we have function and constraints. This is where the Lagrange multiplier method comes into play. For example, function is $f(x, y) = x^2 + y^2$ on condition $x + y = 1$. Rewrite a condition as: $g(x, y) = 0$, therefore $g(x, y) = x + y - 1$. Then, find gradients for all functions:

After that, write down the Lagrange equation and solve it. In general, Lagrange equation looks like:

In our case:

Done! Stationary point is $\left(\frac{1}{2}, \frac{1}{2} \right)$. Let’s resume: if functions without constraints use equation $\nabla f = 0$, else use Lagrange multiplier method.

How to find stationary points of the function you can read at this article: “Stationary points and Lagrange method”

Let’s learn it on example. Function and stationary points:

Firstly, build Hessian matrix. In general form Hessian matrix looks like:

For our function it is: $H = \begin{bmatrix}6x & -3 \\-3 & 6y\end{bmatrix}$. Then substitute points in this matrix and find eigenvalues:

Then use this rules:

• If Hessian eigenvalues is positives, point is local minimum
• If Hessian eigenvalues is negative, point is local maximum
• If Hessian eigenvalues not defined, point is saddle

As result, point $A$ it is saddle point and point $B$ it is local minimum.

Let’s consider the plane $\pi$ in $\mathbb{R}^3$ space, which passes through zero-coordinate. Consider two non-collinear vectors $u$ an $v$ from this plane. Then, any point $x \in \pi$ we can be represented as: $x = \alpha u + \beta v$.

Okay, it’s mean we can define plane $\pi$ as:

Let’s generalize the concept of a plane passing through the origin to a space of arbitrary dimension: The linear Span of vectors $v_1, v_2, \dots, v_k \ \in \ \mathbb{R}^n$ is called set of vectors, represented in form of sum of vectors $v_1, v_2, \dots, v_k$ with arbitrary ratio:

Expression $\alpha_1 v_1 + \alpha_2 v_2 + \dots + \alpha_k v_k$ will call linear combination of vectors $v_1, v_2, \dots, v_k$.

Let’s final this with pivotal definition: linear subspace $\mathbb{R}^n$ called span of finite numbers of vectors $v_1, v_2, \dots v_k \ \in \mathbb{R}^n$:

The span concept and subspace concept equivalents. And any span and subspace contain a $0$, because we can make all ratio $\alpha_1, \alpha_2, \dots, \alpha_k$ equal to zero .

Why linear subspace is important? Here is an example:

Let us take a black-and-white digital photograph of size 512 by 512 pixels. In computer memory, this photograph can be represented as $512 \times 512 = 262144$ numbers — each representing the intensity of the corresponding pixel, ranging from 0 (completely black) to 1 (completely white). Thus, the photograph can be represented as a vector $x$ in a space of dimension $d=262144$.

Now, let us consider an important practical problem — compressing the photograph without significant loss. It turns out that this problem can be solved by finding a special low-dimensional subspace and projecting the vector $x$ onto this subspace.

We told, that subspace need to contain zero. It’s mean line $y = 2x$ is a subspace, but line $y = x + 2$ not. But many properties of subspace saved when it doesn’t contain zero. Therefore, we call such subspaces as affine subspaces. Affine subspaces of $\mathbb{R}^n$ is a set of vectors $A$ of the form $a + v$, where $a \in \mathbb{R}^n$ — is a fixed vector, and vector $v$ belongs to linear subspace $V$. Let linear subspace $V$ is span of vectors $v_1, v_2, \dots, v_k$. Then, affine affine subspace is a set:

Let $V$ — subspace in $\mathbb{R}^n$. Dimension of this subspace is minimal count of vectors $v_1, v_2, \dots, v_k \in \mathbb{R}^n$ for define subspace $V$:

Dimension is denoted by: $\dim{(V)}$. Let’s think about it. For example, we have two non-collinear vectors $u, v \in \mathbb{R}^{100}$ and subspace $V = \text{span}(u, v)$. We know every vector $x \in V$ have 100 coordinates, but, by subspace definition: $x = \alpha u + \beta v$. it’s mean any vector $x$ defined only two parameters $\alpha$ and $\beta$, therefore $\dim{(V))} = 2$. For define point in $\mathbb{R}^n$ we need $n$ parameters, for define point in $V$ we need $\dim{(V)}$ parameters.

Exist subspace, which defined only one vector $0$: $V = \text{span}(0)$. We call this subspace trivial, and considered $\dim{(V)} = 0$.

If we have subspace $V = \text{span}(v_1, v_2, \dots, v_k)$, when $\dim{(V)}$ can be smaller than $k$? if and only if one of the vectors can be express as linear combination rest vectors, for example: $v_1 = \gamma_2v_2 + \gamma_3v_3 + \dots + \gamma_kv_k$.

Set of vectors called linearly independent if equality:

holds only for $\alpha_1 = \alpha_2 = \dots = \alpha_k = 0$. If equality can be holds for non-zero rates, vectors linearly dependent.

Consider space $\mathbb{R}^n$ and a given non-zero vector $w \in \mathbb{R}^n$ . Then set of vectors $P$, perpendicular $w$:

is linear subspace with $\dim{(P)} = n - 1$

# The line in plane and space

How to define a line in plane? Of course, through two points. But it’s not all. Exists are three more methods:

1. Parametric equation Let line $l$ set by two points $r_0 = (x_0; y_0)$ and $r_1 = (x_1;y_1)$. Observe that vector $a = r_0 - r_1$ in same direction with $l$. Therefore, any point on $l$ may define as $r = r_0 + ta$, where $t \in \mathbb{R}$ and full line $l$ way be with $-\infty < t < \infty$. This expression we call parametric equation:

   $$ l = \{r: r = r_o + at, \ t \in \mathbb{R} \} $$

2. Linear equation Let’s write the parametric equation using coordinates:

   $$ \begin{bmatrix}x \\ y\end{bmatrix} = \begin{bmatrix}x_0\\y_0\end{bmatrix} + \begin{bmatrix}t \cdot a_1 \\ t \cdot a_2\end{bmatrix} \Rightarrow \begin{cases}x = x_0 + ta_1 \\ y = y_0 + ta_2\end{cases} $$

   Suppose that, $a_1 \neq 0$ and $a_2 \neq 0$ and solve $t$ from each equation: $\frac{x - x_0}{a_1} = \frac{y - y_0}{a_2} \Rightarrow a_2x - a_1y + (a_1y_0 - a_2x_0) = 0$. Since $a_1, a_2, x_0, x_1$ it’s a numbers, that mean we can define it as linear equation:

   $$ Ax + By + C = 0 $$

   where $A = a_2$, $B = -a_1$, $C = (a_1y_0 - a_2x_0)$

3. Normal and translation Last method. Let’s select random point on line $l$ with radius-vector $r_0$. Let’s draw a vector $n$ from point $r_0$, that is perpendicular line $l$. Then for any point $r$ on line $l$ vectors $r - r_0$ and $n$ will be perpendicular. Rewrite it with scalar product:

   $$ l = \{ r: \langle r - r_0;n\rangle = 0\} $$

   Of course, $r_0$ it can by any point on line $l$ and normal vector $n$ any vector perpendicular to line $l$. To find normal to line, we need direction vector $a = \begin{pmatrix}a_1 \\ a_2\end{pmatrix}$ from parametric equation and then normal vector will be: $n = \begin{bmatrix}-a_2\\ a_1\end{bmatrix}$ or $n’ = -n = \begin{bmatrix} a_2 \\ -a_1\end{bmatrix}$

Let’s resume and see the relationship between this methods. If line passes through two points $r_0 = (x_0; y_0)$ and $r_1 = (x_1; y_1)$, then his can be define of of the three methods:

• parametric equation : $$ r = r_0 + ta = \begin{bmatrix}x_0\\y_0\end{bmatrix} + t \cdot \begin{bmatrix}x_1 - x_0 \\ y_1 - y_0\end{bmatrix} = \begin{bmatrix}x_0\\y_0\end{bmatrix} + \begin{bmatrix}t \cdot a_1 \\ t \cdot a_2\end{bmatrix} $$
• linear equation: $$ Ax + By + C = \underbrace{a_2}_{A} x + \underbrace{(-a_1)}_{B} y + \underbrace{(a_1 y_0 - a_2 x_0)}_{C} = 0; $$
• normal and translation: $$ \langle r - r_0; n\rangle = \left\langle \begin{bmatrix}x - x_0\\y - y_0\end{bmatrix}; \begin{bmatrix}a_1 \\ -a_1\end{bmatrix}\right\rangle = \left\langle\begin{bmatrix}x - x_0 \\ y - y_0\end{bmatrix}; \begin{bmatrix}A \\ B\end{bmatrix} \right\rangle $$ What about line in space? Parametric equation doesn’t change, one vectors will get longer. Linear equation will change: now it’s not one equation, it’s system of two equations: $$ \begin{cases} a_2x - a_1y + (a_1y_0 - a_2x_0) = 0 \\ a_3y - a_2z + (a_2z_0 - a_3y_0) = 0 \end{cases} $$ Method with normal and translation not working in space!

Addition: let’s take to look at distance from point to line:

And we can detect where point relative to a line: group of points from one side, for which $Ax +By + C > 0$ is true; group from another side, for which $Ax +By + C < 0$ is true.

# The plane in space

Again this question. How to define a plane in space? Of course, through with three points non-collinear, that do not lie on the same straight line. Collinear points lie on the same line. And again let’s consider three methods:

1. Parametric equation: $$ \pi = \{r: r = r_0 + t_1v_1 + t_2v_2, \quad t_1, t_2 \in \mathbb{R}\} $$
2. Normal and translation is the same as for line: $\langle r - r_0; n\rangle = 0$
3. Linear equation: start from normal and translation and expand it: $$ \langle r - r_0; n\rangle = 0 \quad \Rightarrow \quad \underbrace{n_1}_{A} x\ + \ \underbrace{n_2}_{B} y\ + \ \underbrace{n_3}_{C} z \ \underbrace{- \langle r_0 ;n\rangle}_{D} = 0. \ \Rightarrow \ Ax + By + Cz + D = 0 $$ Let’s look to relationship between this methods:

• For rewrite parametric equation to normal and translation we need to find normal vector from this system of equations: $\begin{cases}\langle n; v_1\rangle = 0 \\ \langle n; v_2\rangle = 0\end{cases}$
• For rewrite normal and translation form to linear equation we can use this: $A = n_1$, $B = n_2$, $C = n_3$, $D = -\langle n ;r_0\rangle$
• If we have three points, defined plane, we can go to parametric equation: $\begin{array}a v_1 = r_1 - r_0\\ v_2 = r_2 - r_0\end{array}$

Projection point $P$ on plan $\pi$ we call point $P_\pi \in \pi$, the closest to the point $P$: $P_\pi = \arg{\min{||P - X||}}, \ X \in \pi$. Then, the distance from point $P$ to plane $\pi$ will be $d(P, \pi)$ — the distance between point $P$ and her projection $P_\pi$:

Detecting where point relative a plane is the same as line.

# The basic operations of vectors

1. Sum of vectors is a sum of corresponding coordinates: $$ v + w = \begin{pmatrix}v_1 \\ v_2 \\ \ldots \\ v_n \end{pmatrix} + \begin{pmatrix}w_1 \\ w_2 \\ \ldots \\ w_n \end{pmatrix} = \begin{pmatrix}v_1 + w_1 \\ v_2 + w_2 \\ \ldots \\ v_n + w_n \end{pmatrix} $$

We can add vectors only they have same dimension. 2. Product of vector by scalar is a product off each coordinates by a scalar:

3. Difference of vectors is a sum of vectors, but one of vector product by scalar $-1$. 4. Scalar product of vectors:

Properties of scalar vectors product:

• Commutativity: $\langle v; w\rangle = \langle w; v\rangle$
• Distributivity over addition: $\langle x; (v + w)\rangle = \langle x; v\rangle + \langle x; w \rangle$
• Compatibility with scalar multiplication: $\langle v; \lambda w\rangle = \lambda \langle v;w\rangle$
• If scalar product equal zero we call this two vectors orthogonal or perpendicular

# Geometric meaning

In geometry vector is a segment having a direction.

The length of vector we calculate with Pythagoras’s theorem: $||v|| = \sqrt{\sum\limits_{i = 1}^{n}{x_i}}$. If length of vector equal one we call it a unit vector. If $v$ not a unit vector we can change it multiplying by $\lambda = \frac{1}{||v||}$. We can calculate distance and angle between two vectors. Distance is a length of difference two vectors: $d = ||v - w|| = \sqrt{\sum\limits_{i = 1}^{n}{(v_i - w_i)^2}}$. Angle between two vectors follows from Law of Cosines:

Often be helpful: $||u|| = \sqrt{\langle u;u\rangle}$. Next operation is projection vector $u$ to vector $w$:

Another property of vectors: module of scalar product does not exceed product of their length — the Cauchy–Schwarz inequality:

The Triangle inequality: $||v + w|| \leqslant ||v|| + ||w||$, so length of sum of vectors less than or equal to sum of vectors lengths. If vectors is orthogonal, work the Pythagoras’s theorem: $||a + b||^2 = ||a||^2 + ||b||^2$.

Let’s think! How we deploy manually? In the simple case, we connect to server, pull repository and then restart our app. We want automate all of this. Let’s start with first point. We connect to server with SSH, but what we need to do it? Often connection looks like this:

ssh root@192.168.0.1 -i ~/.ssh/id_rsa25519

Here i have three information unit for get access:

1. Server IP address
2. Username of user
3. SSH private key We make “clear” deployment, therefore all step in our manually pipeline will be automate. In order to GitHub Actions can connect to our server we need to give all information. GitHub have special entity for it: Secrets and Variables now, for more security we put all to secrets.

Open your GitHub repository and go to Settings, here in Security section click to Secrets and Variables and go to Actions. Then we will add three secrets: SSH_USER, SSH_HOST, SSH_KEY. Remember, the public pair of SSH_KEY private key need to be added to ~/.ssh/authorized_keys on server. Nice! First step was finished.

Next we need to pull repository. If your server is clean, you need to firstly clone it. If your repository is private, most likely, when you try to do it, you got something like this:

git@github.com: Permission denied (publickey).
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

You need to generate (or migrate) the ssh keys on your server. For generate you can use this:

ssh-keygen -C github -t ed25519

Then copy ~/.ssh/id_ed25519.pub and copy on GitHub repository settings at Deploy keys. After you can clone repository. In order to GitHub Actions know where your project we make new secret SSH_PROJECT_PATH.

Last step: GitHub Actions. Restart service or anything steps, what you want, we describe .gitub/workflows/deploy.yaml (file name doesn’t matter):

name: Deploy
on:
  push:
    branches:
      - main
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Pull repo
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SSH_HOST }}
          username: ${{ secrets.SSH_USER }}
          key: ${{ secrets.SSH_KEY }}
          script: |
            cd ${{ secrets.SSH_PROJECT_PATH }}
            git pull origin main --rebase
      - name: Compose down
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SSH_HOST }}
          username: ${{ secrets.SSH_USER }}
          key: ${{ secrets.SSH_KEY }}
          script: |
            cd ${{ secrets.SSH_PROJECT_PATH }}
            docker compose down
      - name: Compose up
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SSH_HOST }}
          username: ${{ secrets.SSH_USER }}
          key: ${{ secrets.SSH_KEY }}
          script: |
            cd ${{ secrets.SSH_PROJECT_PATH }}
            docker compose up -d

In this example I’m using docker for restart my services. Choose your way!

docker system prune

# 1. Clean packages

Next tips for Arch-base systems:

Find heaviest packages. This command show top-20 most heavy packages:

pacman -Qi | awk '/^Name/{name=$3} /^Installed Size/{print $4 $5, name}' | sort -hr | head -n 20

Find unused dependencies:

pacman -Qdtq

Pay attention, in this list can be important packages for you, that are no one is using, it’s doesn’t mean this need to be remove.

If you’re sure, you can be remove all this list:

sudo pacman -Rns $(pacman -Qdtq)

Find forgotten packages. This command show top-20 long-unused packages:

expac --timefmt='%Y-%m-%d %T' '%l %n' | sort | head -n 20

Clean pacman cache. This command remove all old versions of packages, apart from last and current:

sudo paccache -r

This command remove all packages, apart from current installed:

sudo paccache -r -k 0

Keep in mind, after that you can be rollback to old package version without internet.

# 2. Clean files

This command show top-15 the heaviest directories at home:

du -h ~/ --max-depth=1 | sort -hr | head -n 15

This command show top-20 the heaviest directories at home:

find ~/ -type f -exec du -Sh {} + | sort -rh | head -n 20

I think that’s two command enough to do all clean up what you want. You can find heavies directory at home, than go here. Then again run command for this directory. Then go to heaviest, then find heavy files…