Welcome to my Wiki!🌟

Hey there, and thanks for stopping by! 😊

Here, you’ll find a collection of guides, cheat sheets, and projects that I've curated throughout my journey as an engineer and lifelong learner. Whether it’s embedded systems, Linux kernel development, or just cool little hacks, I love sharing the things that make life easier for me (and hopefully for you too!).

🚀 About Me

I’m an embedded software engineer with a passion for building robust, efficient systems. From low-power IoT devices to cutting-edge Linux kernel modules, I’m all about learning, creating, and sharing knowledge.

🔍 What You'll Find Here

  • Handy cheat sheets and how-to guides for tools and technologies.
  • Nuggets of wisdom from my adventures in C, Rust, Python, and more!
  • A mix of work-related resources and personal tinkering projects.

🛠 Found an Issue?

Spotted something off or have a suggestion? Feel free to open an issue here. I’m always open to feedback and happy to improve! 🌟

💡 Pro Tip: This wiki is as much a personal archive as it is a public resource. Take what you need, and if you spot something I could improve, let me know! 🌱

Enjoy exploring, and happy learning!
— Marcelo 👨‍💻✨

Life

Broad Document Types

  1. Bills

    • Utility bills (electricity, water, gas)
    • Internet or phone bills
    • Subscription renewals

  2. Receipts

    • Purchase receipts (groceries, electronics, clothing)
    • Online order confirmations
    • Payment confirmations (e.g., from a creditor or bank)

  3. Financial Documents

    • Bank statements
    • Investment reports
    • Loan agreements

  4. Insurance Documents

    • Policies (health, car, home, life)
    • Claim documents

  5. Medical Records

    • Doctor's notes
    • Test results
    • Prescription records

  6. Personal Identification

    • Passports
    • Birth certificates
    • Driver's licenses

  7. Tax Documents

    • Tax returns
    • W2/1099 forms (or equivalents in your country)
    • Receipts for deductible expenses

  8. Correspondence

    • Letters
    • Notices
    • Invitations

  9. Education

    • Certificates
    • Transcripts
    • School correspondence

  10. Legal Documents

    • Contracts
    • Lease agreements
    • Wills or testaments

  11. Household

    • Home maintenance records
    • Appliance manuals and warranties

  12. Travel

    • Flight itineraries
    • Hotel reservations
    • Visa documents

  13. Work

    • Pay stubs
    • Employment contracts
    • Performance reviews

How to Customize Furtwher

  • Adapt the list to match your specific needs. For example, if you have a side business, you might add a "Business Documents" type.
  • Combine or split categories if one seems too broad or too specific.
  • Consider your future needs (e.g., maintaining tax-relevant documents for a few years).

These broad categories will help you maintain structure while staying flexible enough to accommodate most documents you encounter in daily life. Over time, you can refine your document types based on usage patterns.

Programming

How to have image with multiple builds:

Python example:

Use commands:

docker build --target development # build an image with both production and development dependencies while
docker build --target production # build an image with only the production dependencies.

Dockerfile:

# Stage 1: Build
FROM python:3.10 AS build

# Install 
RUN apt update && \
    apt install -y sudo 

# Add non-root user
ARG USERNAME=nonroot
RUN groupadd --gid 1000 $USERNAME && \
    useradd --uid 1000 --gid 1000 -m $USERNAME
## Make sure to reflect new user in PATH
ENV PATH="/home/${USERNAME}/.local/bin:${PATH}"
USER $USERNAME

## Pip dependencies
# Upgrade pip
RUN pip install --upgrade pip
# Install production dependencies
COPY --chown=nonroot:1000 requirements.txt /tmp/requirements.txt
RUN pip install -r /tmp/requirements.txt && \
    rm /tmp/requirements.txt

# Stage 2: Development
FROM build AS development
# Install development dependencies
COPY --chown=nonroot:1000 requirements-dev.txt /tmp/requirements-dev.txt
RUN pip install -r /tmp/requirements-dev.txt && \
    rm /tmp/requirements-dev.txt

# Stage 3: Production
FROM build AS production
# No additional steps are needed, as the production dependencies are already installed

Example 2:

devcontainer.json snippet:

{
    "build": {
        "dockerfile": "Dockerfile",
        "target": "development"
    }
}

Dockerfile:

FROM mcr.microsoft.com/vscode/devcontainers/typescript-node:12 AS development

# Build steps go here
FROM development as builder
WORKDIR /app
COPY src/ *.json ./
RUN yarn install \
    && yarn compile \
    #  Just install prod dependencies
    && yarn install --prod

# Actual production environment setup goes here
FROM node:12-slim AS production
WORKDIR /app
COPY --from=builder /app/out/ ./out/
COPY --from=builder /app/node_modules/ ./node_modules/
COPY --from=builder /app/package.json .
EXPOSE 3000
ENTRYPOINT [ "/bin/bash", "-c" ]
CMD [ "npm start" ]

Learning Resources

YouTube

When it comes to submodules, I like to use the following command:

git submodule update --init --recursive --remote

Other git commands:

git log --oneline

git log --stat # (files changed)

git log -p # (files diff)

git diff # shows the difference in files not commited

git log --oneline --decorate --graph --all # see all branchs at once

git reset HEAD~1 #( reset of local changes and the arguments is where to go when reset)

git revert HEAD # (revert commit to remote branches and the argument is the commit to be reverted)

git rebase -i start # rebase with interactive

git tag <tag_name> commit

git describe

Keil

Command line:

https://developer.arm.com/documentation/101407/0541/Command-Line

Debug functions:

https://developer.arm.com/documentation/101407/0541/Debug-Functions

Integration with VSCode:

https://gitlab.com/niciki/keil_integration_with_vscode/-/tree/master

Neovim

To access my Neovim config click here.

Execute normal mode commands using text:

We can execute commands using normal or norm for short:

:norm[al][!] {commands}

If the ! is given, mappings will not be used. Without it, when this command is called from a non-remappable mapping (|:noremap|), the argument can be mapped anyway.

:normal ! yyp
:norm ! itest

Once Vim enters insert mode with the i in itest<esc> all bets are off and printable characters lose their special functions. To get an <Esc> within your :normal, you need to either use <C-V><Esc> (literally type Ctrl+V followed by the Escape key) or alternatively use :execute plus backslash escaping:

:exe "norm itest\<esc>"
:exe "norm i\<cr>another\<cr>example\<esc>yipP"

Macros

Fun trick: we can add the macro call to the end of your recording macro to create a self calling recursive macro, that will just run until the end of the file, no need to guess how many times to run the macro!

Another common pattern is :g/pattern/norm! @q to execute once on each line that has pattern in it.

Go back in time (:earlier)

:earlier 1m

Insert commands with r(ead)

In command mode you can do :r ! terminal_command. r is the short version of the command read. For example, if you do r: ! ls It will append the ls content in the current cursor position or selection.

Motions

f(ind) - find forward F(ind) - find backwards Example: f, - f(ind) comma

t(il) - Til forward T(il) - Til backwards Example: yt, - yank t(il) comma

* - forward search of word under the cursor # - backwards search of word under the cursor

gv - starts visual mode with the previous visual selection. This is useful if you mess up some command, you just u to undo and gv to reselect and try again, or if you want to perform multiple operations on the same visual block

Regex pattern to register

You can do this with a substitute command.

:%s/regex/\=setreg('A', submatch(0))/n

This will append register a to whatever the regex matched. The n flag will run the command in a sandbox so nothing will actually get replaced but the side effects of the statement will happen.

You probably want to empty the register first with

:let @a=''

If you want to place a new line in-between each match:

:let @a='' | %s/regex/\=setreg('A', submatch(0) . "\n")/n

Delete all lines containing a pattern

The command g is very useful for acting on lines that match a pattern. You can use it with the d command, to delete all lines that contain a particular pattern, or all lines that do not contain a pattern.

For example, to delete all lines containing "profile" (remove the /d to show the lines that the command will delete):

:g/profile/d

More complex patterns can be used, such as deleting all lines that are empty or that contain only whitespace:

:g/^\s*$/d

To delete all lines that do not contain a pattern, use g!, like this command to delete all lines that are not comment lines in a Vim script:

:g!/^\s*"/d

Note that g! is equivalent to v, so you could also do the above with:

:v/^\s*"/d

The next example shows use of \| ("or") to delete all lines except those that contain "error" or "warn" or "fail" (:help pattern):

:v/error\|warn\|fail/d

g can also be combined with a range to restrict it to certain lines only. For example to delete all lines containing "profile" from the current line to the end of the file:

:.,$g/profile/d

Reference here.

CMake

Options variables:

cmake -Doption_variable_name=OFF -S . -B build_dir

Commands:

cmake -S source_dir -B build_dir

Get submodules:

find_package(Git QUIET)
if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
# Update submodules as needed
    option(GIT_SUBMODULE "Check submodules during build" ON)
    if(GIT_SUBMODULE)
        message(STATUS "Submodule update")
        execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
                        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
                        RESULT_VARIABLE GIT_SUBMOD_RESULT)
        if(NOT GIT_SUBMOD_RESULT EQUAL "0")
            message(FATAL_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodules")
        endif()
    endif()
endif()

if(NOT EXISTS "${PROJECT_SOURCE_DIR}/extern/repo/CMakeLists.txt")
    message(FATAL_ERROR "The submodules were not downloaded! GIT_SUBMODULE was turned off or failed. Please update submodules and try again.")
endif()

Versioning source code:

project(project_name VERSION "1.0.0")

configure_file(file_name.h.in file_name.h) 

add_executable(...)

target_include_directories(${PROJECT_NAME} PUBLIC ${PROJECT_BINARY_DIR})

file_name.h.in

#ifndef INCLUDE_GUARD
#define INCLUDE_GUARD

#define PROJECT_NAME "@PROJECT_NAME@"
#define PROJECT_VER  "@PROJECT_VERSION@"
#define PROJECT_VER_MAJOR "@PROJECT_VERSION_MAJOR@"
#define PROJECT_VER_MINOR "@PROJECT_VERSION_MINOR@"
#define PTOJECT_VER_PATCH "@PROJECT_VERSION_PATCH@"

#endif // INCLUDE_GUARD

#cmakedefine

# adder use logic
option(USE_ADDER "A simple library for adding 2 floats." ON)

if(USE_ADDER)
	add_subdirectory(Adder)

	list(APPEND EXTRA_LIB_DIRS "Adder")
	list(APPEND EXTRA_INCLUDE_DIRS "Adder")
	list(APPEND EXTRA_LINKS adder)

endif()

target_include_directories(${PROJECT_NAME} 
    PUBLIC external/glfw/include
	${EXTRA_INCLUDE_DIRS}
	${GLEW_INCLUDE_DIRS}
)

target_link_directories(${PROJECT_NAME} 
	PUBLIC external/glfw/src
	${EXTRA_LIB_DIRS}
)

target_link_libraries(${PROJECT_NAME} ${EXTRA_LINKS} glfw ${GLEW_LIBRARIES} GL GLU)

#cmakedefine USE_ADDER

Example of CMakeLists.txt:

cmake_minimum_required(VERSION 3.13.4)

project(PROJECT_NAME)

add_executable(${PROJECT_NAME} main.cpp)

add_subdirectort(Adder) // Adds paths

target_include_directories(${PROJECT_NAME} PUBLIC Adder)

target_link_directories(${PROJECT_NAME} PRIVATE Adder)

target_link_libraries(${PROJECT_NAME} PRIVATE adder)

Portuguese

Qual o animal com 3 patas?
R: O pato

Qual o animal com as patas acima da cabeça? 
R: O piolho 

"Olha que eu na vida só me enganei uma vez, uma vez em que pensei estar enganado."

Datetime: 18/02/2025

"Eu durmo quando for velha e já não tiver esta pedalada e curiosidade galopantes; até lá, vou viver."
- Cicatriz

Datetime: 26/12/2024

"O melhor presente é estar presente."

Datetime: 25/12/2024

"A ocasião faz o ladrão"

Datetime: 24/12/2024

“O lixo de uns é o tesouro de outros”

"Mas no fim só fazemos o melhor que sabemos e a vida segue"
-papillon na música Fé

Comprometido comigo mesmo é o estado civil.
-papillon

"P’ra trás só fica aquilo que não serviu."

Pedras no caminho, guardo-as todas. Um dia vou construir um castelo.

Não dá para ter mudança tendo as mesmas atitudes, pa subir na vida não dá para ter medo de altitudes
-papilon música Tenta. aos 5:00

Respeita o meu brain, porque se dependesse de sorte eu ia para o casino. 
-papillon em .Y

"Seja como a fonte que transborda, e não como o tanque, que contém a mesma água."
-Paulo Coelho

English

Datetime: 04/03/2025 11:00

"It’s okay to have feelings, you know. Things that aren’t logical. Science makes us understand how to stay alive longer. Feelings give us the reason to want to."

"Live your life as if there’s no tomorrow, and then you wake up and there is a tomorrow and you do it again."

"Women are better than men. And they never stop trying to bring us up to their standard."

"Happiness is amazing. It’s so amazing, it doesn’t matter if it’s yours or not."

"You can’t change the world, but you can change yourself."

"Life is precious because you can’t watch it again. I mean, you can believe in an afterlife if that makes you feel better. Doesn’t mean it’s true. But once you realize you’re not gonna be around forever, I think that’s what makes life so magical. One day you’ll eat your last meal, smell your last flower, hug your friend for the very last time. You might not know it’s the last time, so that’s why you should do everything you love with passion, you know? Treasure the few years you’ve got because that’s all there is."

"Nothing's as good if you don't share it."

"A society grows great when old men plant tree whose shade they know they shall never sit in."

"Hope is everything."

"My dad used to say:
Life is like a ride at the fair. Exciting, scary, fast. And you can only go round once. You have the best time till you can’t take any more. Then it slows down, and you see someone else waiting to get on. They need your seat."

"There are no bad dogs, just bad owners. If you treat a dog bad and show them no love, that’s what they act like. If you show them kindness and hope, they’re fine. It’s the same with people."

-After Life TV show

Datetime: 17/02/2025 21:30

"What you're not changing, you're choosing."

Datetime: 13/02/2025

"A person often meets his destiny on the road he took to avoid it"
- Hubslife

Datetime: 26/01/2025 21:45

"Curiority may have killed the cat, but I have that dog in me 🐺"
- TJ

Datetime: 26/12/2024 00:00

"You can't control the wind, but you can adjust your sails"

Meaning: In life, there are things we can't control, just like the wind. But here's the empowering part: we have the ability to adapt and change our course. It's like adjusting the sails of a boat—we can always find a way to navigate through challenges and rough waters.

"Comparison is the thief of joy"

There are two quotes about the marriage that I really like and I truly think they are wise and in some way helpful. Perhaps you'll like them as wel:

1."Love is not a feeling. It's a choice"

Meaning: if you truly want your marriage/relationship to be healthy, well-organised and fruitful then you literally have to make a choice to love someone.

It's not a wild feeling you can't control. A mature love is a way of life you both agreed upon and you both maintain. At least this is how I understand it.

2. "In relationship all the duties should not be divided 50/50. They should be divided 60/40, but both sides should try to be the 60% part"

this one is simple and lovely :) - https://youtu.be/uIW7nhUKiDc

“When you work, seek out challenging tasks. When you live with others, choose to be with those who are difficult. If a task is hard, approach it without hesitation. By doing so, you reveal your true strength and potential.”
-Budah

"I don't see failure as failure anymore. I see it as my first, second, third attempt." That's going stick in my head for a long time.
https://youtu.be/sA36RIv1A_k

"Perhaps sometimes the only way to experience the beauty of things, is to think about things in a beautiful way.” 
https://youtu.be/P6wH7bXG09k

“When nobody else celebrates you, learn to celebrate yourself. When nobody else compliments you, then compliment yourself. It’s not up to other people to keep you encouraged. It’s up to you. Encouragement should come from the inside.”
– Jay Shetty

"The only true test of intelligence is if you get what you want out of life."	

"Energy flows where the attention goes"

"Aim high & expect the best"

"Shoot for the moon if you miss, you’ll land among the stars."

"We notice a lot of dislikable people but we never seem to notice our disliking minds."
—Buddha

"People are in your life for a reason, season, or lifetime, the pain comes when we put them in the wrong category."

"We look at the world once, in childhood. The rest is memory."

C++

std::optional

#include <optional>

std::optional<std::string> ReadFileAsString(cibs std::string& filepath){
	std::ifstream steam(filepath)
	if(stream){
		std::string result;
		//read file
		stream.close();
		return result;
	}
	else{
		return {};
	}
}

int main(){
	std::optional<std::string> data = ReadFileAsString("data.txt");
	if(data){
		//exist
	}
	else{
		// does not exist
	}
}

	std::string value = data.value_or("String");

Standards

C++98

  1. Deterministic Object Lifetime
  2. RAII (Resource Acquisition Is Initialization)
    • https://youtu.be/7Qgd9B1KuMQ
  3. Templates 98 
    template<typename First, typename Second>
struct Pair{
	First i;
	Second j;
};

C++11

  • auto
  • ranged-for loops 
    std::vector<int> &vec;
for(const auto &elem : vec){}
  • lambdas 
    std::vector<int> &vec;
const auto count = std::count(begin(vec), end(vec),
							  [](int i){ return i < 3; }
					);
  • variadic templates 
    template<typename Func, typename ...T>
void call(const Func &function, const T& ... param){
	function(param...);
}
  • unique_ptr/shared_ptr 
    #include <memory>
void allocate_memory(){
	std::unique_ptr<int> ptr(new int(5));
} //ptr is destroyed, memory freed
  • constexpr 
    constexpr int get_value(){
	return 5 * 3;
}
constexpr auto value = get_value();

int main(){
	std:array<int, value> values;
}

C++14

  • Bug Fixes from C++11
  • auto - return type deduction → enables auto in function return type
  • Generic Lambdas 
    template<typename T>
void count_things_less_than_3(const T &vec, int value){
	const auto count = std::count(begin(vec), end(vec), [](const auto i){return i < 3;})
}
  • Generalized Capture expression 
    template<typename T>
void count_things_less_than_3(const T &vec, int value){
	const auto count = std::count(begin(vec), end(vec),
						[value=3](const auto i){return i < 3;})
}
  • make_unique/make_shared 
    #include <memory>
void allocate_memory(){
	auto ptr{std::make_unique<int>(5)};
} //ptr is destroyed, memory freed
  • constexpr is more flexible, loops, branches, multiple return statments

C++17

  • Guaranteed Copy / Move Elision 
    #include <memory>

auto factory(){
	return std::make_unique<int>();
}

int main()
{
	auto widget = factory(); // No copies
}
  • Beginning constexpr support in std library
  • constexpr lambdas
  • std::string_view 
    #include <string_view>
constexpr std::string_view name = "Hello";
  • Class Template Argument Deduction 
    #include <array>
std:array<int, 5> data{1,2,3,4,5}; //c++14
std:array data{1,2,3,4,5}; //c++17
  • Fold expressions 
    template<typename ...T>
auto add(const T& ...param){
	return (param + ...); 
}
 
int main(){
	return add(1,2,5,4,5,6,7);
}
  • Structured bindings 
    // Example 1
std::pair<int, int> values{1, 2};
auto [first, second] = values;

// Example 2
std::tupple<std::string, int> CreatePerson(){
return { "Cherno", 24};
}

int main(){
	auto[name, age] = CreatePerson();
}
  • if-init expressions 
    if(auto [first, second] = values; first > 5){}

RValues and LValues

R(ight) Values are values before the = L(eft) Values are values after the =

  • LValues values are variable that have king storage em them &
  • RValues values are temporary values &&
  • RValues can be used in the & if const &

The Rule of Three

If your class directly manages some kind of resource (such as a new'ed pointer), then you almost certainly need to hand-write three special member functions:

  • A destructor to free the resource
  • A copy constructor to copy the resource
  • A copy assignment operator to free the left-hand resource and copy the right-hand one
  • Use the copy-and-swap idiom to implement assignment.

The Rule of Zero

If your class does not directly manage any resource, but merely uses library components such as vector and string, then you should strive to write no special member functions.

Default them all

  • Let the compiler implicitly generate a default destructor
  • Let the compiler implicitly generate the copy constructor
  • Let the compiler implicitly generate the copy assignment operator
  • (But your own swap might improve performance)

Compiler Explorer

C++ for cortex m0+ flags:

	-mthumb -mcpu=cortex-m0plus -mfloat-abi=soft

Other falgs:

	-O3 -Wall -Wextra -Wpedantic -Wshadow

ffunction-sections, -fdata-sections, & --gc-sections

-fno-exceptions

-O3 -Wall -Wextra -Wpedantic -Wshadow -mthumb -mcpu=cortex-m0plus -mfloat-abi=soft -fdata-sections -ffunction-sections -fno-exceptions -fno-rtti

Exception handling and RTTI are difficult to provide without dynamic memory allocation (much more on that below), so you likely want to disable them with fno-exceptions, fno-non-call-exceptions, and fno-rtti.

CRTP (Curiously Recurring Template Pattern)

In short, CRTP (Curiously Recurring Template Pattern) is when a class A has a base class which is a template specialization for the class A itself. E.g.

	template <class T> 
	class X{...};
	class A : public X<A> {...};

It is curiously recurring, isn't it? :)

Now, what does this give you? This actually gives the X template the ability to be a base class for its specializations.

For example, you could make a generic singleton class (simplified version) like this

#include <iostream>

template <class T>
class Singleton
{
public:
     static T* GetInstance() {
         if ( p == nullptr ) p = new T();
         return p;
     }
protected:
     Singleton() = default;

     Singleton(Singleton const &) = delete;
     Singleton &operator=(const Singleton &) = delete;

private:
     static T *p;
};
template <class T>
T *Singleton<T>::p= nullptr;

Now, in order to make an arbitrary class A a singleton you should do this

class A : public Singleton<A> 
{ 
friend Singleton;
private:
    A() = default;
};
A *a0= A::GetInstance();

However, CRTP is not necessary in this case, see as follow:

class C 
{ 
friend Singleton<C>; 
private: C() = default;
};
C *c1= Singleton<C>::GetInstance();

So you see? The singleton template assumes that its specialization for any type X will be inherited from singleton<X> and thus will have all its (public, protected) members accessible, including the GetInstance! There are other useful uses of CRTP. For example, if you want to count all instances that currently exist for your class, but want to encapsulate this logic in a separate template (the idea for a concrete class is quite simple - have a static variable, increment in ctors, decrement in dtors). Try to do it as an exercise!

Yet another useful example, for Boost (I am not sure how they have implemented it, but CRTP will do too). Imagine you want to provide only operator < for your classes but automatically operator == for them!

you could do it like this:

template<class Derived>
class Equality
{
};

template <class Derived>
bool operator == (Equality<Derived> const& op1, Equality<Derived> const & op2)
{
    Derived const& d1 = static_cast<Derived const&>(op1);//you assume this works     
    //because you know that the dynamic type will actually be your template parameter.
    //wonderful, isn't it?
    Derived const& d2 = static_cast<Derived const&>(op2); 
    return !(d1 < d2) && !(d2 < d1);//assuming derived has operator <
}

or implement within the template scope without casting

template<class T>
class Equality
{
    friend bool operator == (const T& op1, const T& op2)
    { 
        return !(op1 < op2) && !(op2 < op1); 
    }
};

Now you can use it like this

struct Apple:public Equality<Apple> 
{
    int size;
};

bool operator < (Apple const & a1, Apple const& a2)
{
    return a1.size < a2.size;
}

Now, you haven't provided explicitly operator == for Apple? But you have it! You can write

int main()
{
    Apple a1;
    Apple a2; 

    a1.size = 10;
    a2.size = 10;
    if(a1 == a2) //the compiler won't complain! 
    {
    }
}

This could seem that you would write less if you just wrote operator == for Apple, but imagine that the Equality template would provide not only == but >, >=, <= etc. And you could use these definitions for multiple classes, reusing the code!

Here is another example: https://godbolt.org/z/fEhsGq6q3

#include <array>
#include <cstdint>

int square(int num) {
    return num * num;
}


//CRTP
template <class T> 
struct Figure
{
    int area()
    {
        return static_cast<T*>(this)->area_implementation();
    }

    static void static_func()
    {
        T::static_sub_func();
    }
};

struct Circle : Figure<Circle>
{
    uint32_t radius;
    
    Circle(uint32_t new_radius = 5) : radius(new_radius){};

    int area_implementation(){
        return 2 * 3 * square(this->radius);
    }
    static void static_sub_func();
};

struct Rectangle : Figure<Rectangle>
{
    uint32_t c, l;
    
    Rectangle(uint32_t new_c=5, uint32_t new_l=5) : c(new_c), l(new_l){};

    int area_implementation(){
        return c * l;
    }
    static void static_sub_func();
};

template<typename derived>
int callArea(Figure<derived> &fig){
    return fig.area();
}


// Virtual
struct FigureVirtual
{
    virtual int area();
};

struct CircleVirtual : FigureVirtual
{
    uint32_t radius;
    
    CircleVirtual(uint32_t new_radius = 5) : radius(new_radius){};

    int area(){
        return 2 * 3 * square(this->radius);
    }
};

struct RectangleVirtual : FigureVirtual
{
    uint32_t c, l;
    
    RectangleVirtual(uint32_t new_c=5, uint32_t new_l=5) : c(new_c), l(new_l){};

    int area(){
        return c * l;
    }
    static void static_sub_func();
};

int main(){
    Circle circ_crtp(5);
    Rectangle rec_ctrp(5, 2);

    CircleVirtual circ(5);
    RectangleVirtual rec(5, 2);

    std::array<FigureVirtual*, 2> figures{&circ, &rec};
    return figures[0]->area() + figures[1]->area();
    //return callArea(circ_crtp) + callArea(rec_ctrp);
}

Rust

How can we performe a cargo update for the cargo install command?

There is no such command in vanilla cargo (well, there's cargo install but that's for dependencies), but since cargo supports third-party subcommands there is an answer: the cargo-update crate.

Install as usual with:

cargo install cargo-update

then use

cargo install-update -a

To update all installed packages, for more usage information and examples see the cargo install-update man page.

How to flash and monitor:

espflash flash --monitor target/riscv32imc-unknown-none-elf/debug/test-esp3

Or use cargo run by adding to .cargo/ the file config.toml the following:

[target.riscv32imc-unknown-none-elf]
runner = "espflash flash --monitor"

An example of my fool config.toml is:

[target.riscv32imc-unknown-none-elf]
runner = "espflash flash --monitor"

[env]
ESP_LOG="INFO"

[build]
rustflags = [
  # Required to obtain backtraces (e.g. when using the "esp-backtrace" crate.)
  # NOTE: May negatively impact performance of produced code
  "-C", "force-frame-pointers",
]

target = "riscv32imc-unknown-none-elf"

[unstable]
build-std = ["core"]

Linux

How to get current script directory in bash

#!/usr/bin/env bash

SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )

is a useful one-liner which will give you the full directory name of the script no matter where it is being called from.

It will work as long as the last component of the path used to find the script is not a symlink (directory links are OK). If you also want to resolve any links to the script itself, you need a multi-line solution:

#!/usr/bin/env bash

# Resolve the script's directory, even if it's a symlink
SCRIPT_SOURCE=${BASH_SOURCE[0]}
while [ -L "$SCRIPT_SOURCE" ]; do
  DIR=$(cd -P "$(dirname "$SCRIPT_SOURCE")" >/dev/null 2>&1 && pwd)
  SCRIPT_SOURCE=$(readlink "$SCRIPT_SOURCE")
  [[ $SCRIPT_SOURCE != /* ]] && SCRIPT_SOURCE=$DIR/$SCRIPT_SOURCE
done
DIR=$(cd -P "$(dirname "$SCRIPT_SOURCE")" >/dev/null 2>&1 && pwd)

cd "$DIR" || {
  echo "Error: Failed to change directory to $DIR"
  exit 1
}

This last one will work with any combination of aliases, source, bash -c, symlinks, etc.

Beware: if you cd to a different directory before running this snippet, the result may be incorrect!

Also, watch out for $CDPATH gotchas, and stderr output side effects if the user has smartly overridden cd to redirect output to stderr instead (including escape sequences, such as when calling update_terminal_cwd >&2 on Mac). Adding >/dev/null 2>&1 at the end of your cd command will take care of both possibilities.

To understand how it works, try running this more verbose form:

#!/usr/bin/env bash

SOURCE=${BASH_SOURCE[0]}
while [ -L "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  TARGET=$(readlink "$SOURCE")
  if [[ $TARGET == /* ]]; then
    echo "SOURCE '$SOURCE' is an absolute symlink to '$TARGET'"
    SOURCE=$TARGET
  else
    DIR=$( dirname "$SOURCE" )
    echo "SOURCE '$SOURCE' is a relative symlink to '$TARGET' (relative to '$DIR')"
    SOURCE=$DIR/$TARGET # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
  fi
done
echo "SOURCE is '$SOURCE'"
RDIR=$( dirname "$SOURCE" )
DIR=$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )
if [ "$DIR" != "$RDIR" ]; then
  echo "DIR '$RDIR' resolves to '$DIR'"
fi
echo "DIR is '$DIR'"

And it will print something like:

SOURCE './scriptdir.sh' is a relative symlink to 'sym2/scriptdir.sh' (relative to '.')
SOURCE is './sym2/scriptdir.sh'
DIR './sym2' resolves to '/home/ubuntu/dotfiles/fo fo/real/real1/real2'
DIR is '/home/ubuntu/dotfiles/fo fo/real/real1/real2'

References

Cross-Compilation of Linux Kernel and Debug with QEMU and GDB

In the following tutorial it uses LLVM=1 because I wanted to use LLVM to compile because I was using rust for linux.

Kernel Build

make LLVM=1 ARCH=x86_64 menuconfig

Kernel hacking → Compile the Kernel with debug info Kernel hacking → Provide GDB scripts for Kernel debugging

make LLVM=1 ARCH=x86_64 CROSS_COMPILE=x86_64-unknown-linux-gnu -j$(nproc)

Buildroot

git clone https://github.com/buildroot/buildroot
cd buildroot
make LLVM=1 ARCH=x86_64 menuconfig

Target Options → Target Architecture → x86_64

Filesystem images → ext2/3/4 root file system → ext4

make LLVM=1 ARCH=x86_64 CROSS_COMPILE=x86_64-unknown-linux-gnu -j$(nproc)

QEMU

Installing

sudo apt install qemu qemu-system

To boot the kernel using the root filesystem generated by Buildroot, run the following command:

BUILDROOT_PATH=../buildroot
qemu-system-x86_64 \
    -kernel arch/x86/boot/bzImage \
    -boot c \
    -m 2049M \
    -drive file=$BUILDROOT_PATH/output/images/rootfs.ext4,format=raw \
    -append "root=/dev/sda rw console=ttyS0,115200 acpi=off nokaslr" \
    -serial stdio \
    -display none \
    -s -S
  • -s: Opens a GDB server on port 1234.
  • -S: Stops QEMU execution, allowing GDB to connect.

Debugging with gdb-multiarch

Installing:

sudo apt-get install gdb-multiarch

Add the following line to your ~/.gdbinit file to load the GDB scripts provided by the kernel for enhanced debugging:

add-auto-load-safe-path <replace_kernel_path>/scripts/gdb/vmlinux-gdb.py

This enables GDB helper scripts that are useful for kernel debugging.

Debugging Session:

Start QEMU in Debug Mode

Ensure QEMU is running with the -s -S options so that it waits for GDB to connect.

Lauch GDB

In another terminal, start gdb-multiarch and load the kernel symbols from vmlinux:

gdb-multiarch vmlinux

In GDB, connect to QEMU by running target remote :1234:

(gdb) target remote :1234
Remote debugging using :1234
0x000000000000fff0 in exception_stacks ()

Now you can debug the kernel:

(gdb) hb start_kernel
Hardware assisted breakpoint 1 at 0xffffffff834174c3: file init/main.c, line 905.
(gdb) c
Continuing.

Breakpoint 1, start_kernel () at init/main.c:905
905		char *command_line;

References

  • https://medium.com/@depressedcoder/m1-mac-linux-kernel-development-environment-setup-748637131f92

How to setup promox:

The following guide walks you through a bare metal installation of Proxmox, followed by deploying a Home Assistant OS (HAOS) VM. To be more specific I cover:

  • Why Proxmox VE for Home Assistant?
  • Proxmox Storage Recommendations
  • Creating Proxmox USB Boot Media
  • Installing Proxmox VE 8.3
  • Proxmox Post-Install Configuration
  • Intel Microcode Update (Optional)
  • Installing Home Assistant OS (HAOS) VM
  • Setting Static IP Address (Recommended)
  • USB Passthrough to HAOS (Optional)
  • Optimize CPU Power (Optional)
  • Check SMART Monitoring (Optional)
  • VLAN Enable Proxmox (Optional)
  • Proxmox Let’s Encrypt SSL Cert (Optional)
  • Proxmox Two Factor Setup (Optional)
  • Proxmox Notifications (Optional)
  • Glances Configuration (Optional)

Home Assistant: Proxmox VE 8.3 Quick Start Guide

i3wm

Created time: January 14, 2023 11:14 PM Last edited time: January 21, 2024 1:09 PM

vim ~/.config/i3/config

$mod refers to the modifier key (alt by default)

General

  • startx i3 start i3 from command line
  • $mod+<Enter> open a terminal
  • $mod+d open dmenu (text based program launcher)
  • $mod+r resize mode ( or to leave resize mode)
  • $mod+shift+e exit i3
  • $mod+shift+r restart i3 in place
  • $mod+shift+c reload config file
  • $mod+shift+q kill window (does normal close if application supports it)

Windows

  • $mod+w tabbed layout
  • $mod+e vertical and horizontal layout (switches to and between them)
  • $mod+s stacked layout
  • $mod+f fullscreen

Moving Windows

  • $mod+shift+<direction key> Move window in direction (depends on direction keys settings)

How to add screen brightness keys:

  1. sudo apt install light

  2. sudo chmod +s /usr/bin/light

  3. Add to i3 config:

    bindsym XF86MonBrightnessUp exec --no-startup-id light -A 1 # increase screen 
brightnessbindsym XF86MonBrightnessDown exec --no-startup-id light -U 1 # decrease screen brightness

rsync

Flags:

--progress -ar --info=progress2

Command Line

Go to the last directory

cd -

Save dir to directories stack and can be popd:

pushd dir
popd

Clear terminal without clean:

ctrl+l

Put it as a foreground/background process:

ctrl+z

Get the foreground process

fg

Repeat the last command:

!!

Search command in history:

ctrl + r

Execute command n of history:

!n

Deletes everything in that line:

ctrl+u

Go to the end of the line:

ctrl+e

Go to the beginning of the line:

ctrl+a

See in real time changes of a file:

tail -f directory

Put the output of the command in columns:

command | column -t

curl \
  --proto '=https' \
  --tlsv1.2 \
  -sSf \
  -L https://install.determinate.systems/nix \
  | sh -s -- install

NixOS

nixos-rebuild:

nixos-rebuild build --flake .#name

Switch:

nixos-rebuild switch --flake .#name

nix-shell

Example of setup shell with git and pre-commit:

nix-shell -p git pre-commit

Enable flakes permanently in NixOS

Add the following to the system configuration (flakes):

  nix.settings.experimental-features = [ "nix-command" "flakes" ];

Enable vmware guest

    virtualisation.vmware.guest.enable = true;

Home manager

Build:

home-manager build --flake .

Switch:

home-manager switch --flake .

Clean up

If you do the last command you should be able to clean it out for the boot

nix-env --list-generations

nix-collect-garbage  --delete-old

nix-collect-garbage  --delete-generations 1 2 3

# recommeneded to sometimes run as sudo to collect additional garbage
sudo nix-collect-garbage -d

# As a separation of concerns - you will need to run this command to clean out boot
sudo /run/current-system/bin/switch-to-configuration boot

NixGL

All the programs I have that require gpu acceleration have a module option for it, but I suppose if it doesnt, you could always just wrap the program with a script that runs it with nixGL for you XD Something like the below, then put someprogram in your packages list instead of the actual package

someprogram = pkgs.writeShellScriptBin "someprogram" ''
${nixGL} ${pkgs.someprogram}/bin/someprogram "$@"'';