Ben Mezger

Maintaining a robust CV

Thu, 26 Mar 2026 17:52:00 +0100

Related pages
- A reproducible Org-Mode CV template

I’ve been investing in having a well structured CV for some time now. Maintaining a CV is hard, and you have to do it well, since this is your entry ticket for your first interview.

It doesn’t matter who you are, if your CV is badly written and unstructured, you are unlikely to receive that first call with the recruiter. It’s even harder nowadays due to AI. A lot of recruiters are using AI to triage many CVs they receive, so you have to make sure you pass through this automated triage, that means having a parsable and well linked content is important.

A reproducible Org-Mode CV template

Sun, 08 Feb 2026 14:27:00 +0100

I spent the weekend improving my Org-mode/LaTeX CV template and decided it was worth sharing publicly. Its modular, searchable, and designed for reproducibility. I’ve made it easy to maintain and updated the structure to be as ATS-friendly as possible.

I used AI to help document this. I tend to spend more time building than writing about what I built, so it was useful to have something that could map the full picture.

System Design - Databases, data models and indexing

Tue, 23 Dec 2025 16:09:00 +0100

Database#

What they are#

Abstracted organization of data
Software layer between the client and the storage
Considerations in a distributed system
Replication, Geo-Distribution and consistency
Implements some of the BASE and/or ACID models
Additional complexity due to architectural decisions
Different types of databases
- Databases NewSQL
- Non-relational databases
- Relational databases
- Timeseries databases
- Memory databases

Relational Databases (SQL)#

Tables, Tuples and columns
Rigid and declarative schema
- We define all restrictions, types, cohesion rules, foreign key constraints, etc.
- Column id(int) does not allow a string, for example
Strong consistency
ACID
Strong reference integrity
Transaction model
Focuses on integrity and durability
Attributes that they can relate to each other (FKs, etc)
Examples are:
- PostgreSQL
- MySQL / MariaDB
- Oracle
- SQLServer
- Etc.

Non Relational Databases (NoSQL)#

Flexible schemas
Eventual consistency
Different data formats
Documents, key-value, graphs, column
Optimized horizontal scaling
Generally higher write performance, geo distribution, etc. (in exchange of not so much consistency)
No guarantee of integrity and atomicity
Data semi-structured
Examples are:
- MongoDB
- MemcachedDB
- Cassandra
- Redis
- Elasticsearch
- Etc.
One of the characteristics is to prevent costly joins
- Non relational = not relation between the data
For example, in MongoDB, we can have relationship between the collections, but it is not recommended, given we have to make many queries to relate them
If we need to relate entities, use a related database

NewSQL Databases#

ACID + Horizontal scalability
Sharding and replication
RAFT/Paxos
New proposal that focuses on resolving the trade-offs of SQL and NoSQL regarding strong consistency, performance and horizontal scalability
Seek to provide some reliability in terms of transactions
Not yet super mature
Examples are:
- CockroachDB
- Google Cloud Spanner
- MemSQL
- VoltDB
- AltiBase

In-Memory Database#

Uses volatile memory – non-persistent in disk
Latency of nanoseconds in RAM
Key-value model
Non structured
Volatile and performance
Scales through consistent hash
Layer of cache and intensive reads
Data needs to be reconstructible
- Focuses on non-durable data
Useful for data that doesn’t change much, caching, etc
Trade-off of not having the most updated value
Important data is generally not stored in these databases
Examples are:
- MemcachedDB
- Redis
- Valkey
- Apache Ignite
- Aerospike

Time-Series Databases (TSDB)#

Append Only
- Generally we do not update data
Temporal indexing
High ingestion
Analytical queries
Used in metrics and logs
Automatic expurge
Supports high load of write operations
Mathematical operations
Sequential and segmented based on the collection time
Examples are:
- Timescale
- InfluxDB
- Prometheus
- VictoriaMetrics
- Graphite
- Grafana Mimir

Levels of consistency#

When discussing distributed systems, the choice of level of consistency of data is an important factor
Knowing when to choose eventual consistency or strong consistency can either elevate the scalability of the system, as well as generate scalability problems. Race-conditions problem, data loss, high-throughput reads/writes, data durability, etc.
Strong consistency vs Eventual consistency
Impact in client experience
Reliability vs performance
Integrity vs Scalability
Levels of integrity

Strong consistency#

Linearity
Synchronous Quorum
Paxos and Raft
Write latency
More reliability
Atomicity and transactions
Consistent state -> consistent state
Flow of synchronous commits
Critical and atomic operations
Examples of databases are:
- MySQL
- MariaDB
- PostgreSQL
- Oracle
- Cassandra (requires configuration)

Eventual consistency#

Asynchronous replication
High availability
Tolerance and partitions
Strategies to resolve conflicts
Last-Write-Wins, CRDT (Conflict-free Replicated Data Type)
- The last version of the data, is the one that stays (generally based on a timestamp)
High throughput and low latency
Requires time to reflect data in all nodes
Examples are:
- ScyllaDB
- DynamoDB
- CouchDB
- MongoDB
- Elasticsearch
- Etc.

Data Models#

Tuple (Row-Oriented)#

OLTP
Row = tuple, where each item in the tuple corresponds to the column
Cache of pages
- Page size
Low latency per row
Groups attributes of the same entity physically in the same block
We join different tables to query a particular data

Documents#

Flexible schemas
Autonomous entities
Not much rigid field verification
JSON/BSON
Inverted indexing
Full-Text search
Allows changing schema without complex migration
No relationship such as Row-Oriented
- Normally, the JSON contains all the needed data (i.e. single schema)
Examples of usage is to represent a product catalog, log aggregation, etc.

Column-Oriented#

Contigous columns
- Instead of being row (such as SQL), where the whole row is stored in a block, Column-Oriented is the same, but columns. So instead of a row such as (Ben, 31, Amsterdam) being sequentially stored, just the column is stored near each other.
Compression
Analytics, Big Data, Data Warehouse
Helps analyse a large amount of the same data, such as optimized queries on top of the same attribute
Heavy Scans of specific values
Examples of such DB:
- ClickHouse
- Amazon Redshift
- Google BigQuery
- SnowFlake
- MariaDB ColumnStore
Row-Oriented is useful when we need to retrieve the whole entity, and Column-Oriented is useful for when we need to perform analytical or math operation on top of the same attribute (column), regardless of the amount of rows we have.

Wide-Column#

Family of column per row
Flexible schema per row
Each row can have its own set of columns
Aggregated by family of column
Efficient for data that varies
Efficient for distributed data
Eventual Consistency
Supports atomicity and joins
Examples:
- Cassandra
- ScyllaDB
- HBase
- DynamoDB
- CosmosDB

Key-Value#

Direct lookup
Parity hashing
Key (unique identifier)
Value (unstructured)
Strings, numbers, booleans, JSON and Blobs
Easy to query and indexing
Examples:
- Redis
- Memcached
- Aerospike
- Etcd
- ZooKeeper

Graphs#

Relationship of data is as important as the data itself
Nodes (entity)
Edges (relationship)
Useful for recommendation feature
Unstructured model
Examples include:
- Neo4j
- CosmosDB
- OrientDB
- ArangoDB
- Neptune

TODO Indexing#

The way the DB engine manages the storage and the indexing of that data, it impacts the performance
Without indexing, even for a simple query, it would have to scan the whole database to find that data
Indexing is how the DB stores and queries the data
Concepts of: Page Size, Column Index, LSM-Tree, B-Tree, Hashing, Inverted Index

Page Size#

Organized blocks of fixed size (4kb, 8kb, etc) – configurable
- If we store data, that is indexed by the date, we store each row sequentially in a page, until we reach that page limit, then we proceed to another page
- If we are indexing by date, these blocks will be stored near each other
Block are rows (Tuple-Oriented) – Generally SQL databases
Large pages: reduces read I/O operations in large objects
- If we have a large set of data, larger page sizes reduces the need of the engine having to open and close different pages to read the data
- Increase the cost of data transfer
- Bad for simple queries, as we need to open a large page to query something simple
Smaller pages: Lower reads in irrelevant data on simple queries
- Increases I/O operations
- Minimizes opening large pages to query
For example, if we need to aggregate a lot of data in a table, larger pages might be better, if our data has smaller entities, straightforward queries, smaller pages might be better
Databases that uses page sizes are:
- MySQL
- PostgreSQL
- Oracle databases
- Apache Cassandra

Column-base Indexing#

Contigous segments of columns
Each column is stored in a segment
Compressed through a lookup table
High performance for aggregation
Reduces I/O with compression
Searches for specific attributes
Analytics workflow
Data compression is more efficient when we have less data diversity
Examples are:
- Amazon Redshift
- BigQuery
- SnowFlake
- DuckDB

System Design - CAP theorem, ACID, BASE and PACELC

Mon, 22 Dec 2025 18:16:00 +0100

Related pages
- System Design - RAID and Storage
- System Design - Network

Notes on CAP theorem, ACID, BASE and PACELC regarding system design.

ACID#

Focuses on precision/data reliability
Related to transactional models
Atomicity, Consistency, Isolation, Durability
Transactional databases
- SQL Databases
Atomic and reliable transactions
Prioritization of transaction and commits
Detriments performance and availability

Atomicity#

Ensures that each transaction is treated as an indivisible unit
- “All or nothing”
All operations within the transaction should be completed
- Otherwise, nothing will be applied
Strong consistency
Operations that require dependency
- i.e: create an order row of a particular product, while decrementing from the quantity of available product
- Financial market – persist the credit while decrementing the users balance

Consistency#

Guarantees that all transactions that happen, can only bring the current consistent state, to another consistent state
Ensures that we do not corrupt/invalidate the data – data integrity
Transaction validation
- Respects that all data restrictions are maintained: Types, Foreign Keys, Nullability, Triggers, etc.
- I.e. if we try to insert a string in a INT column
- If we try to insert a FK into a column, and that FK does not exist

Isolation#

Operates independently and simultaneously of other transactions
Transactions happening at the same moment do not interfere with others
Dirty Reads
- Reading data that was modified by another transaction which has not yet been applied
- Say we have 2 transactions reading the same table. One transaction can not continue, without the other transaction finishing.
Non-repeatable Reads
- A transaction reads the same row twice and gets different values each time. This happens because another transaction modified (and committed) that row in between the two reads.
Phantom Reads
- A transaction re-executes a query that returns a set of rows, and new rows appear or existing rows disappear in the result. Because another transaction inserted, deleted, or updated rows that match the query condition and committed in between.
- Unlike non-repeatable reads (which involve the same row changing), phantom reads involve changes to the set of rows.

Durability#

After the confirmation of a particular operation, the data will not be lost
- I.e.: after a COMMIT, the data is guaranteed to be stored
Confirmed, a transaction will exist permanently
Persistence of data in a non-volatile source

BASE and Eventual State#

Basic Availability, Soft-State and Eventual Consistency
Focuses on flexibility
Flexibility for more large-scale distributed systems
Partially contrary to ACID
Availability and fault-tolerance are a priority
Systems that have to deal with eventual consistency
Databases BASE are more towards performance and high availability, in exchange to not being so consistent
Mostly NoSQL databases
- Mongo, Cassandra, etc.

Basic Availability#

Maximizes availability
- Guarantees a total and uninterruptible availability, and offers mechanism to work in a degraded or partial state
- I.e. If we have a database with three nodes, and one node fails, it can show a partial number of data (not all)
Some data or functionality may not be available
Allows replication and partitioning (sharding)
Useful for large-scale and high-demand environments, where partial data is accepted
- Maintain consistent operation is more important than having an 100% up to date version of the data

Soft-State#

System can change over time
Data can expire (with a TTL) or updated by the database
- I.e.: memcached, Redis, etc.
- Ideal for cache systems
Volatile databases
There is no guarantee that the system maintains consistency

Eventual Consistency#

Non confirmation in all nodes
Write operation can happen in a single node and not be confirmed with the other nodes
Asynchronous replication
- For example, on a write operation, it may write in a single node and confirm, and later replicate this data to the other nodes
The data can be inconsistent in many nodes for a limited time
Performance oriented
High availability and scalable

CAP Theorem#

3 principles: Consistency, Availability and Partition Tolerance
Conceptual model
Helps classify distributed and non-distributed databases
Helps us consider scenarios and architectural choices that vary on Consistency, Availability and Partition Tolerance
Can choose 2 of the 3 principles (choose 2)
- CA, CP, AP, etc.
In a distributed system, we cannot achieve all three principles
Offers a base for us to identify the limitations of any database

Components of CAP (`C`, `A` and `P`)#

Consistency (`C`)#

Guarantee that all the nodes of a database with distributed data present the same data simultaneously
Regardless of the node queried, all of them return the most recent version of that data
Atomicity
Financial systems and hospital registration are examples of such systems that require consistency
Systems with Consistency are ACID with strong consistency

Availability (`A`)#

Ensures that any request to the system will get a response
Regardless whether the data is updated in a node
Presumes that the data returned can or cannot be the most recent. Even for read or write operations.
High performance, high volume and fast response time
Detriments the guarantee of the actual data
Mostly BASE systems

Partition Tolerance (`P`)#

Systems can work when the replicas of my system is partitioned into two different versions (not a table partition)
Distributed database capacity of maintaining an operational state
Even on a degraded state, it can offer system continuity
Databases geo-distributed, social networking, log aggregators, brokers, queues are all examples of such system
More related to BASE systems

Combination#

Consistency and Partition Tolerance (`CP`)#

Prioritizes the consistency and tolerance to partitioning
Sacrifices availability
Maintains consistency within all nodes that continue to operate in case of a network failure or partition
Allows disabling inconsistent nodes, makes them unavailable until consistency is restored
- “I rather be unavailable than inconsistent”
- “Inconsistency is non-negotiable”
Mix of BASE and ACID systems
We need to prioritize data precision, approximate transactional atomicity
Examples such as MongoDB, Cassandra, Couchbase, Etcd, Consul, etc.

Availability and Partition Tolerance (`AP`)#

Prioritizes high availability and partition tolerance
Sacrifices consistency
Every node stays available for querying, independently of its up to date state
During the synchronization process, all nodes will continue responding
More important than maintaining consistency
Examples of such databases are: DynamoDB, CouchDB, Cassandra (depending on its configuration), SimpleDB, etc.
Base systems

Consistency and Availability (`CA`)#

Prioritizes consistency and availability
Sensible to data partition
In cases of a network failure or partition, the system can stay completely inoperational
Centralized databases, traditional SQL databases, MySQL/MariaDB, PostgreSQL, Oracle, SQL Server, Redis Standalone, Memcached Standalone are all examples of such database
Leans towards ACID rather than BASE

CAP model today#

2/3 is not extremely exclusive
Excessive simplification is not real in modern technology
Consistency and availability (on/off)
- Layers of unavailability – not on or off
Level of Consistency is not binary
- We can have different levels of consistency
- There are moments where we are 100% consistent, while moments we are not

PACELC theorem#

Complementary to CAP – used as an “extension to CAP”
Helps us identify gaps that CAP does not cover (partition is not always available)
Mainly related to AP, CP models
Helps us understand the answer of:
- “What should the system prioritize when it’s not functioning correctly?”
- “What should it prioritize when a partitioning happens between the nodes?”
- “Is it possible to operate with more than one level of consistency?”
When a Partitioning of network (P) happens between the nodes of the system, it is necessary to choose between Consistency (C) or Availability (A)
If there is a partition (P), we should choose between Availability (A) and Consistency (C)
If there is no partition, we choose between Latency (L) and Consistency (C)

Even on normal conditions, we have to make hard decisions
More guarantee in exchange of response time
Response time in exchange of Consistency
Strong Consistency
Eventual Consistency
Both theorem are not mutually exclusive, but complementary to each other

Applying PACELC#

PA/EL
- On Partition, Availability; Else, Latency
- Normal: Prioritizes latency instead of consistency
- In partition: Prioritizes availability instead of strong consistency
- Model of pure eventual consistency
- High write performance
- Accept versions different of the data
PC/EL
- On Partition, Consistency; Else, Latency
- Normal: Prioritizes latency and high throughput in exchange of consistency
- In partition: Prioritizes consistency
- Can be unavailable until the cluster recovers and it comes back at operating
- Minimum consistency during failures is non-negotiable
- Accepts eventual consistency, but only when all nodes are available
PA/EC
- On Partition, Availability; Else, Consistency
- Normal: Prioritizes strong Consistency
- In Partition: Prioritizes availability
- Assumes eventual consistency as a last resort
- CRDTs - Conflict-Free Replicated Data Types
- Hybrid context in microservices
PC/EC
- On Partition, Consistency; Else, Consistency
- Normal: Prioritizes consistency instead of latency
- In partitions: Prioritizes consistency instead of availability
- Conservative model of consistency
- Data precision is the most important

System Design - RAID and Storage

Sat, 20 Dec 2025 15:59:00 +0100

Related pages
- System Design - Network

Notes on computer storage architecture regarding system design.

Storage#

Persisting data in a organized manner
- Even on system failure
Recovering and accessing when needed
Long-term storage
Security, performance, latency, scalability, redundancy, replication, availability, etc.
HDD, SSD, Network Systems, etc.
- Where to store the data, depending on our use-case
- Best storage model for cases where we write a lot, or read a lot
We want to expand the size in case we reach the maximum capacity

Metrics and dimensions#

Some metrics can help guide us based on our requirements, which storage to choose.

System Design - Network

Sat, 20 Dec 2025 12:05:00 +0100

Review of some computer networking concepts and architecture.

Network protocols#

Defines a communication pattern
- How one or more system can communicate with each other
Set of rules that define the format and sequence of messages
- How they should be sent, received, structured.
Ensures correct interpretation between different systems
Different protocol implementation, with different standards and rules.

OSI model#

Conceptual model of how these different protocols relate to each other. Works like a map of where each functionality of these protocols lie.

My journey in managing online services

Sun, 02 Feb 2025 20:22:00 +0100

Related pages
- My journey in managing dotfiles

As part of my journey to centralize and automate my computing life, one of my annoyances is having to configure services such as DNS or GitHub repositories every time I need to create or modify one.

I use Cloudflare to manage my domains and handle DNS configurations. Every time I got a new domain and/or DNS configuration, I had to go to Cloudflare and update the entries. Maybe a week later, I would realize I had made a mistake and had to track down what I had before to roll it back. Further, I use UptimeRobot to monitor some of my personal domains and get notified in case they become unavailable.

My journey in managing dotfiles

Sun, 02 Feb 2025 17:22:00 +0100

One of my biggest complaints when managing my dotfiles was having to deal with my scripts and secrets (tokens, passwords, etc.) to set up my machine. My ideal scenario was that when I made a fresh install of my system and ran my script, I could start working. But the reality was different. I always had to update a script or rework something to make it compatible with the new system because the system state was different than before.

NixOS important commands

Sun, 02 Feb 2025 13:08:00 +0100

After I distro hopped from Archlinux to NixOS, I’ve been having to learn the Nix ecosystem and package management commands. I’ve found the migration from Archlinux to NixOS OK, but I am still struggling remembering some important Nix commands.

Updating packages#

sudo nix-channel --update -vv to update to the latest nix channel. This will essentially pull nixos-unstable and nixpkgs-unstable.

nix flake update Will update my flake.lock file with the latest version.

Anbernic RG353V: configuring ArkOS

Sat, 13 Jul 2024 11:40:00 +0200

Last year I got myself the Anbernic RG353V handheld console so I could play Gameboy Advance and PSP games. At the end, I had little time to play and I had to leave it in the drawer.

This week I found some time to play with it, but I ended up formatting the SD with all my ROMs by mistake, so I had to download everything again 🫠. Given I had to restart from zero, I decided to install ArkOS instead, due to some of the nifty features it has.

New computer

Sun, 30 Jun 2024 18:14:00 +0200

Related pages
- Dell XPS 9510 and the linux experience

After years of using notebooks, I sold my personal XPS to build a custom computer. I thought about it for a long time about the hardware I needed. I knew I needed a powerful processor, but not a Threadripper, and took me good days of thinking to decide whether I would go with AMD or Intel. I decided to go with Intel i9, which is the one I am most familiar with.

Notes on TDD - chapter 4

Sun, 11 Feb 2024 01:57:00 +0100

Related pages
- Test driven development

This chapter is straightforward. The problem is that our amount is public. Anyone can change, and we don’t want to allow tests to access it. What happens if we delete that variable and move it somewhere else? We will have to update the test. Lets refactor it.

class DollarV5:
 _amount: int

 def __init__(self, amount: int):
 self._amount = amount

 def times(self, multipler: int) -> "DollarV5":
 return DollarV5(self._amount * multipler)

 def __eq__(self, value: "DollarV5") -> bool:
 return self._amount == value.amount

We should keep __eq__ as is. Yes, this will break our next test, but its fine for now.

Notes on TDD - chapter 3

Sun, 11 Feb 2024 01:53:00 +0100

Related pages
- Test driven development

We can use objects as values (similar to how we are using Dollar). This is called *Value Object*. The values of the instance variables of the object *never* changes once they have been set my the constructor. This is exactly the case with our current =Dollar implementation, where once we set the amount, it will stay as is. If we call times, it will return a new Value Object.

Notes on TDD - chapter 2

Sun, 11 Feb 2024 01:51:00 +0100

Related pages
- Test driven development

Below are notes/tests I made during my reading session of the Test Driven Development: By Example book, by Kent Beck.

When TDDing, for each step, think about:

Add a little test: think how I wish the interface would look like. Remember we are writing a story and include all the elements in the story I think will be necessary to reach the right answer.
Run all test: Make the bar go green quickly. If the solution is obvious, write it in, but if it takes 1min or more, then make a note about it and get back to main problem.
Make a little change: Remove all sins we left in the code, the duplication that we introduced and get back to making the test pass.

Our goal is to have clean code that works.

Notes on TDD - chapter 1

Sun, 11 Feb 2024 01:48:00 +0100

Related pages
- Test driven development

Below are notes/tests I made during my reading session of the Test Driven Development: By Example book, by Kent Beck.

The cycle we want to follow in TDD is as follows.

Add a little test
Run all tests and fail
Make a little change
Run the tests and succeed
Refactor to remove duplication

class Dollar:
 amount: int

 def __init__(self, amount: int):
 self.amount = amount

 def times(self, multipler: int) -> None:
 self.amount *= multipler

If dependency is the problem, duplication is the symptom

Test driven development

Mon, 05 Feb 2024 13:22:00 +0000

Related pages
- Python

Ending 2022 with Brazilian Jiu-Jitsu

Sat, 14 Jan 2023 20:07:00 +0100

… And starting 2023 with Brazilian Jiu-Jitsu (BJJ) as well. A few months before the global COVID-19 pandemic, I started swimming again. Still, then the lockdown began, and I had to cancel my swimming subscription. I never did any exercise since then.

When I moved back to The Netherlands, I promised myself I would start a new sport and maintain it weekly. I chose BJJ. The first reason I decided on BJJ was to keep up with a Brazilian sport, giving me the feeling of having Brazil nearby. The second reason is to exercise, improve my confidence, decrease anxiety and learn a martial art.

Hello again, Amsterdam

Sun, 25 Sep 2022 21:22:00 +0000

After moving around the world, I’ve decided to strike again and move back to Amsterdam with my wife. We planned this throughout the last couple of years and have initially planned to move at the end of 2020. The pandemic hit us hard, and we both decided it would be better to stay in Brazil and replan for a different year when things get back to normal.

And 2022 came, and here I am, writing my first blog post after moving to Amsterdam for three months. Many things I was familiar with have changed since I moved out from Amsterdam, some negatively and positively. Regardless, I still need more time to see how the city is doing and meet the new things around the city.

Moving forward with suckless dwm

Sun, 07 Aug 2022 21:50:00 +0000

Related pages
- Dell XPS 9510 and the linux experience

I decided to give suckless dwm another chance and spent my weekend configuring and applying some patches. Today (<2022-08-07 Sun>), I seem to have a usable configuration with which I can start working.

I’ve been using qtile till now, but with multiple monitors, qtile seemed not to work well. I’ve tried getting a unique qtile’s GroupBox for each screen to have 1-9 workspaces, but no luck. Maybe there is a way to fix this, but after a few tries, I gave up and took a chance at hearing my subconscious to give dwm another try.

Tabs vs. spaces in byte size

Sat, 26 Mar 2022 02:29:00 +0000

While during my daily housekeeping, I got intrigued by how much of a the difference would a tab-based repository be in size in comparison to a space-based version. To check the difference, I’ve used the Linux kernel for comparing the size when converting all tabs to spaces and Python’s Pytest library when converting all spaces to tabs.

Using Python and C repositories was ideal, given Linux uses 8 tabs by default and the Python community generally sticks with 4 spaces.

Thoughts of changing nicks

Sat, 19 Mar 2022 16:24:00 +0000

I’ve been thinking of changing my nick from seds to something else. The annoying part about this nick is that it is taken almost everywhere.

I will still keep using benmezger when available, but y’know, I like the idea of using a nickname online – it makes it feel like the beginning of the Internet.

Now I have to think of something other than seds 💔.

Dell XPS 9510 and the linux experience

Sun, 06 Feb 2022 00:29:00 +0100

I do not own this notebook anymore. I recently sold this notebook, so I am unaware of any recent improvements/updates.

I’ve recently decided to migrate back to Linux after some years of using a MacBook. I haven’t distanced myself from Linux while using the Mac, as I had a Thinkpad x320 by my side all the time running Archlinux.

I wanted something much more powerful than the Macbook, along with a lightweight design and something that would last for the next five years.

Impact on software failures

Sun, 10 Oct 2021 20:16:00 +0200

Related pages
- Software Engineering
- Laws of Program Evolution

Software failures can also cause serious consequences in an automobile. Toyota had to recall almost 2 million Prius hybrid vehicles, in order to fix a software glitch along with its engine control units (ECUs) in February 2014 (COMPUT- ERWORLD 2020). A malfunction within the car’s hybrid drive system caused by a software glitch could, in certain circumstances, cut the system’s power and cause the car to an unscheduled halt. A software glitch affecting the ECUs controlling the motor/generator and the hybrid system could put extra thermal stress on certain transistors under certain conditions. The same software issue recurred in July 2015, which has resulted in the recall of 625,000 Prius cars globally. Software failures have affected the healthcare system as well. Emergency services were unavailable for around six hours across seven U.S. states in April 2014 (COMPUTERWORLD 2020). The incident had a major impact on 81 call centers, meaning about 6,000 people who made 911 calls that were not able to connect in these seven states. There is a study announced by the Federal Communications Commission found that the cause of service unavailable was an entirely preventable software error.

Laws of Program Evolution

Sun, 10 Oct 2021 20:03:00 +0200

Related pages
- Software Engineering

In 1980, Lehman (1980) summarized the Laws of Program Evolution. The first law, Continuing Change, expressed the universally observed fact that large programs are never completed. They just continue to evolve until the more cost-effective updated version replaces the systems. The second law, Increasing Complexity, could also be viewed as an instance of the second law of thermodynamics. As an evolving program is continually changed, its complexity, reflecting deteriorating structure, increases as well, unless the mission is done, or maintenance is needed. The third law, The Fundamental Law of Program Evolution, is subject to dynamics that make the programming process, measures system attributes and collaborative projects, and self-regulating with statistically proven trends and invariances. The fourth law, Conservation of Organizational Stability (Invariant Work Rate), and the fifth law, Conservation of familiarity, both lead to the third law. The fourth law more focuses on the steadiness of multiloop self-stabilizing systems. A well-established organization is good at avoiding dramatic change and particularly discontinuities in the increasing growth of an organization. Especially in the past two decades, the complexity of the task that the software system performs has grown dramatically, faster than hardware due to the fast-paced high technology development (Catelani et al. 2011).

Handling database migration with Pytest and SQLAlchemy

Fri, 24 Sep 2021 21:01:00 +0000

Related pages
- Python
- Python’s name mangling

Recently I wanted to get pytest to work the same way pytest-django handles migrations and database fixtures. As a bonus, I wanted to add some custom =pytest=flags to control the database during tests.

import pytest

from sqlalchemy import MetaData, create_engine
from sqlalchemy import orm
from sqlalchemy_utils import create_database, database_exists, drop_database

from app import config as app_config
from app.db.session import SessionLocal

# we keep SessionLocal as default, but
# we later overwrite it if we use the testing
# db
TestingSessionLocal = SessionLocal


# see https://docs.pytest.org/en/stable/reference.html
# about pytest_addoption
def pytest_addoption(parser):
 # NOTE: when adding or removing an option,
 # remove to remove/add from app/conftest.py:addoption_params
 parser.addoption(
 "--no-db", default=False, action="store_true", help="Disable testing database"
 )
 parser.addoption(
 "--drop-db",
 default=False,
 action="store_true",
 help="Drop test database after running tests",
 )
 parser.addoption(
 "--reuse-db", default=False, action="store_true", help="Reuse previous database"
 )
 parser.addoption(
 "--echo-db",
 default=False,
 action="store_true",
 help="Echo database queries to stdout",
 )
 parser.addoption(
 "--database-uri",
 default=str(config.TEST_DATABASE_URL),
 action="store",
 help="Provice custom database url",
 )


def addoption_params(config):
 # NOTE: Params are defined pytest_addoption
 return {
 "drop-db": config.getoption("--drop-db"),
 "no-db": config.getoption("--no-db"),
 "reuse-db": config.getoption("--reuse-db"),
 "echo-db": config.getoption("--echo-db"),
 "database-uri": config.getoption("--database-uri"),
 }


def pytest_configure(config):
 global TestingSessionLocal

 # check if we should ovewrite the database and
 # skip it if set
 params = addoption_params(config)
 if params.get("no-db"):
 return

 database_uri = params.get("database-uri")
 echo_db = params.get("echo-db")

 if database_exists(database_uri):
 # if reuse-db is set, don't drop the database
 # as we want to use the previous database
 if not params.get("reuse-db"):
 drop_database(database_uri)
 create_database(database_uri)
 else:
 create_database(database_uri)

 engine = create_engine(database_uri, echo=echo_db)

 # dont drop and create the database if reuse-db is set
 if not params.get("reuse-db"):
 DBBase.metadata.drop_all(engine)
 DBBase.metadata.create_all(engine)
 engine.execute("create extension pg_trgm;")

 # overwrite TestingSessionLocal with the testing database
 TestingSessionLocal = orm.sessionmaker(bind=engine, autocommit=True, autoflush=True)


def pytest_unconfigure(config):
 params = addoption_params(config)
 # nothing to do if no-db is set
 if params.get("no-db"):
 return

 database_uri = params.get("database-uri")

 # don't drop the database if drop-db is set.
 if params.get("drop-db") and database_exists(database_uri):
 drop_database(database_uri)


@pytest.fixture
def params(request):
 return addoption_params(request.config)


@pytest.fixture(autouse=True, scope="session")
def truncate_db(pytestconfig):
 params = addoption_params(pytestconfig)
 # don't truncate if no-db is set
 if params.get("no-db"):
 return

 database_uri = params.get("database-uri")
 echo_db = params.get("echo-db")

 engine = create_engine(database_uri, echo=echo_db)
 meta = MetaData(bind=engine, reflect=True)

 con = engine.connect()
 trans = con.begin()

 # truncate all tables
 for table in meta.sorted_tables:
 con.execute(f'ALTER TABLE "{table.name}" DISABLE TRIGGER ALL;')
 con.execute(table.delete())
 con.execute(f'ALTER TABLE "{table.name}" ENABLE TRIGGER ALL;')

 trans.commit()


@pytest.fixture
def db(mocker):
 # just to ensure.
 # Patch sqlalchemy's Session with TestingSessionLocal
 patched_session = mocker.patch(
 "sqlalchemy.orm.session.Session", return_value=TestingSessionLocal
 )

 return patched_session

@pytest.fixture
def db_session():
 try:
 db = TestingSessionLocal()
 yield db
 finally:
 db.close()

I am unsure whether using pytest_configure to initialize the database and overwrite the TestingSessionLocal is the recommended or correct approach, but it works well.

Python's name mangling

Sat, 18 Sep 2021 20:30:00 +0000

Related pages
- Python
- Programming

Python’s convention of prefixing a name with an underscore (_handle_error()) is treated as a non-public part of the API by the community, but we can still access it if we want. This Python convention also eases the work when unit-testing these methods.

class Account:
 def name(self):
 return self._name

 @property
 def _name(self):
 return "Anonymous"

acc = Account()

print(acc.name())
print(acc._name)

Anonymous
Anonymous

But what happens when we use two underscores (__handle_error())?

Asynchronous vs synchronous bus

Mon, 13 Sep 2021 21:27:00 +0000

Related pages
- Computer Architecture

In an asynchronous bus, each bus cycle is sequenced by request and acknowledgment signals. To perform a bus cycle, the transmitter drives the data onto the bus and then asserts the request signal Req. Upon seeing the request signal, the receiver samples the data off the bus and asserts an acknowledge signal Ack to indicate that the data transfer is complete. Upon receiving the acknowledge signal, the transmitter turns its driver off, freeing the bus for the next transfer .

Chezmoi and Emacs

Sat, 11 Sep 2021 19:48:00 +0000

Related pages
- Emacs
- Automating and testing dotfiles

I’ve recently wanted to integrate Chezmoi with Emacs, so I can avoid switching to the terminal or eshell whenever I needed Chezmoi. I’ve searched for a few Emacs and Chezmoi integration and I found this. However, I wanted to play a bit with Elisp, so I decided to write my own.

The code is still a work-in-progress, but I already have the basic functionality set up.

Locking Python scripts with flock

Sun, 22 Aug 2021 01:42:00 +0000

The problem#

I wanted to make a Python script that synchronized my emails and indexed them with mu. The script would run on systemd and/or launchd every 5 minutes, however, I would like to run the script manually too. I needed a solution similar to a mutex, but file-like, nothing too complex neither 100%.

UNIX’s `flock`#

Unix flock enables one to lock a file while the file is open by the executing command.

RISC-V Instruction Format

Fri, 13 Aug 2021 19:28:00 +0000

The base ISA has six instruction formats: (i) the R-format for register operations, (ii) I-format for immediate short and loads values, (iii) S-format for stores, (iv) B-format for conditional branches, (v) U-format for instructions with upper immediate, and (vi) J-format for unconditional jumps. Given that the ISA has six instruction formats, the simplification and decoding of instructions are much more straightforward compared to ARM or x86 architectures. RISC-V provides three register operands at the same position in all formats, simplifying the decoding process. In addition, the specified registers to be read or written are always in the same place in all instructions, enabling register access to start before the instruction decoding phase <patterson2017RiscvAtlas,Waterman14therisc-v>.

Notes on fault tolerant software

Fri, 28 May 2021 20:14:00 +0000

tags: Software Engineering

Software-based fault tolerance must support appropriate redundancy for error detection and error recovery. Software redundancy is not a replication of programs but rather a redundancy of design .

Synchronization

Sun, 04 Apr 2021 19:25:00 +0000

Notes from the Little book of Semaphores .

Shared variables#

Many applications enforce the constraint that the reader should not read until after the writer writes, this is because the reader may read an old value if the writer hasn’t written to the variable yet
A thread may also interact as concurrent writes (two or more writers) and concurrent updates (two or more threads performing a read followed by a write)
Think about what paths (execution paths) are possible and what are the possible effects. Ask yourself if you can you prove that a given (desirable) effect is necessary or that a undesirable effect is impossible

Semaphores#

A semaphore is like an integer, with three differences
- A semaphore can have its value initialized to any number, but after that only an increment and decrement operation is allowed, and you are not allowed to read the current value of the semaphore
- When a thread decrements the semaphore, if the result is negative, the thread blocks itself and cannot continue until another thread increments the semaphore
- When a thread increments the semaphore, if there are other threads waiting, one of the waiting threads gets unblocked
If the value of the semaphore is positive, it representes the number of threads that can decrement without blocking. If it is negative, it represents the number of threads that have blocked and are waiting. If the value is zero, it means there are no threads waiting.

Quizzes and exercises#

Shared variables#

Imagine that you and your friend Bob live in different cities, and one day, around dinner time, you start to wonder who ate lunch first that day, you or Bob. How would you find out?

Export org-roam backlinks with Gohugo

Sun, 07 Mar 2021 14:40:00 +0000

tags: Org-mode Emacs Org-roam

Since Org-roam export backlinks on Hugo no longer works, I found a solution to handle backlinks in Hugo itself.

The following Hugo partial template will add backlinks to a note if any.

{{ $re := $.File.BaseFileName }}
{{ $backlinks := slice }}
{{ range .Site.AllPages }}
 {{ if and (findRE $re .RawContent) (not (eq $re .File.BaseFileName)) }}
 {{ $backlinks = $backlinks | append . }}
 {{ end }}
{{ end }}

<hr>
{{ if gt (len $backlinks) 0 }}
 <div class="bl-section">
 <h4>Links to this note</h4>
 <div class="backlinks">
 <ul>
 {{ range $backlinks }}
 <li><a href="{{ .RelPermalink }}">{{ .Title }}</a></li>
 {{ end }}
 </ul>
 </div>
 </div>
{{ else }}
 <div class="bl-section">
 <h4>No notes link to this note</h4>
 </div>
{{ end }}

Then, include the previous partial to your single.html. For example, this page is created with a single.html template, with the following content:

Symbol format 'elf64-littleriscv' unknown

Mon, 01 Mar 2021 22:43:00 +0100

tags: RISCV Compiler

After an hour of compiling RISC-V’s toolchain, I ran riscv64-unknown-elf-gdb remotely against my Rust kernel running in Qemu. This happened.

riscv64-unknown-elf-gdb \
 -q \
 -ex 'file target/riscv64gc-unknown-none-elf/debug/strail-rs' \
 -ex 'target remote localhost:3333' \
 -ex "b main"
Reading symbols from target/riscv64gc-unknown-none-elf/debug/strail-rs...
I'm sorry, Dave, I can't do that. Symbol format `elf64-littleriscv' unknown.
Remote debugging using localhost:3333
make: *** [gdb] Abort trap: 6

What the hell. I immediately started to investigate what is going on, is it my build system? Is Rust compiling my binary in a wrong format (although it seems correct from the output)?

C pointers

Fri, 12 Feb 2021 23:50:00 +0000

Related pages
- Programming
- Computer Science

For understanding how pointers work, consider the following simplified memory layout. the memory address starts in 0x1 and goes up to address 0xA. The value row holds the current data stored in that memory cell. Address 0x1 holds a pointer to address 0x6, which in turn 0x6 holds the value s.

Address	0x1	0x2	0x3	0x4	0x5	0x6	0x7	0x8	0x9	0xA
Value	`0x6`					s	e	d	s	\0
Variable name	`hostname`					`hostname`	`hostname + 1`	`hostname + 2`	`hostname + 3`	`hostname +4`

.. which we can translate to:

Awesome Operating Systems

Tue, 09 Feb 2021 12:28:00 +0000

Related pages
- Operating Systems
- Computer Architecture

Another awesome list of available Operating System. This is an ongoing list and gets updated from time to time.

Unix-like#

Microkernel#

Minix 3: MINIX 3 is a free, open-source, operating system designed to be highly reliable, flexible, and secure. It is based on a tiny microkernel running in kernel mode with the rest of the operating system running as a number of isolated, protected, processes in user mode. It runs on x86 and ARM CPUs, is compatible with NetBSD, and runs thousands of NetBSD packages.
Redox OS: Redox is a Unix-like Operating System written in Rust, aiming to bring the innovations of Rust to a modern microkernel and full set of applications.

Monolithic#

Linux Kernel: The Linux kernel is a free and open-source, monolithic, modular, multitasking, Unix-like operating system kernel. It was conceived and created in 1991 by Linus Torvalds for his i386-based PC, and it was soon adopted as the kernel for the GNU operating system.
illumos: illumos is a Unix operating system which provides next-generation features for downstream distributions, including advanced system debugging, next generation filesystem, networking, and virtualization options.
SmartOS: SmartOS is a specialized Type 1 Hypervisor platform based on illumos.
Xv6: Xv6 is a teaching operating system developed in the summer of 2006, which was ported to RISC-V for a new undergraduate class 6.S081.
SerenityOS: The goal is a marriage between the aesthetic of late-1990s productivity software and the power-user accessibility of late-2000s *nix.
XFree86: Provides a client/server interface between the display hardware (those physical things like the mouse, keyboard, and video displays) and the desktop environment, (this is typically called a window manager as it deals with how X is displayed i.e. the overall appearance). Yet X it goes beyond that and also gives the infrastructure and a standardized application interface (API).

Embedded OS#

Microkernel#

Contiki-NG: Contiki-NG is an open-source, cross-platform operating system for Next-Generation IoT devices. It focuses on dependable (secure and reliable) low-power communication and standard protocols, such as IPv6/6LoWPAN, 6TiSCH, RPL, and CoAP. Contiki-NG comes with extensive documentation, tutorials, a roadmap, release cycle, and well-defined development flow for smooth integration of community contributions.
FreeRTOS: FreeRTOS is a real-time operating system kernel for embedded devices that has been ported to 35 microcontroller platforms.
Riot OS: RIOT is a small operating system for networked, memory-constrained systems with a focus on low-power wireless Internet of Things devices.
Mbed: Mbed is a platform and operating system for internet-connected devices based on 32-bit ARM Cortex-M microcontrollers.
μT-Kernel 3.0: Real-time OS for Small-scale Embedded Systems and IoT Edge nodes. It is compliant with IEEE Standard 2050-2018 and has high compatibility with μT-Kernel 2.0.
Hubris: Hubris is a microcontroller operating environment designed for deeply-embedded systems with reliability requirements. Its design was initially proposed in RFD41, but has evolved considerably since then. Hubris provides preemptive multitasking, memory isolation between separately-compiled components, the ability to isolate crashing drivers and restart them without affecting the rest of the system, and flexible inter-component messaging that eliminates the need for most syscalls — in about 2000 lines of Rust. The Hubris debugger, Humility, allows us to walk up to a running system and inspect the interaction of all tasks, or capture a dump for offline debugging.

Monolithic#

Zephyr: Zephyr is a small real-time operating system[3] for connected, resource-constrained and embedded devices (with an emphasis on microcontrollers) supporting multiple architectures

Megalithic Kernel#

TinyOS: TinyOS is an open source, BSD-licensed operating system designed for low-power wireless devices, such as those used in sensor networks, ubiquitous computing, personal area networks, smart buildings, and smart meters.

Software and Hardware Single Event Effect mitigation

Sat, 06 Feb 2021 15:28:00 +0000

This work aims at characterizing the types of see and the state-of-the-art that has been accomplished to mitigate these issues at the circuit- and software-level.

Notes on OS memory management

Fri, 27 Nov 2020 22:08:00 +0000

Related pages
- Operating Systems
- Computer Science

Memory management requirements#

Some the requirements that memory management is intended to satisfy are:

Relocation
Protection
Sharing
Logical organization
Physical organization

Bit shifting

Sat, 21 Nov 2020 14:52:00 +0000

The operators#

Operator	Meaning
`>>`	Arithmetic (signed) right shift operator
`>>>`	Logical (unsigned) right shift operator
`<<`	Left shift operator, meets the needs of logical and arithmetic shifts

Left shift `<<`#

Integers are stored, in memory, as a series of bits. For example, the number 6 is:

6	0000 0110	0x6

Shifting the bit pattern to 1 (6 << 1) results in 12

	 6	0000 0110	0x6
<<1	12	0000 1100	0xc

Shifting the bit pattern to 2 (6 << 2) results in 24

Translating Virtual addresses

Sat, 21 Nov 2020 14:09:00 +0000

Related pages
- Computer Architecture
- Operating Systems

Translating virtual address space in RISCV in Sv39

Virtual address: 0x7d_beef_cafe Virtual address in binary: 0b0111_1101_1011_1110_1110_1111_1100_1010_1111_1110

VPN[2]	VPN[1]	VPN[0]	12-bit offset
`1_1111_0110`	`1_1111_0111`	`0_1111_1100`	`1010_1111_1110`
502	503	252

Bibliography

Sat, 21 Nov 2020 00:04:00 +0100

Some of these bibliographies I’ve been reading for my research and some I find it interesting to keep around my library.

Operating Systems#

Introductory#

Modern Operating Systems#

Bibtex

@book{tanenbaum2014ModenOS,
 author = {Tanenbaum, Andrew S. and Bos, Herbert},
 title = {Modern Operating Systems},
 year = 2014,
 isbn = {013359162X},
 publisher = {Prentice Hall Press},
 address = {USA},
 edition = {4th},
 abstract = { Modern Operating Systems, Fourth Edition, is intended for
 introductory courses in Operating Systems in Computer Science,
 Computer Engineering, and Electrical Engineering programs. It
 also serves as a useful reference for OS professionals The
 widely anticipated revision of this worldwide best-seller
 incorporates the latest developments in operating systems (OS)
 technologies. The Fourth Edition includes up-to-date materials
 on relevantOS. Tanenbaum also provides information on current
 research based on his experience as an operating systems
 researcher. Modern Operating Systems, Third Editionwas the
 recipient of the 2010 McGuffey Longevity Award. The McGuffey
 Longevity Award recognizes textbooks whose excellence has been
 demonstrated over time.http://taaonline.net/index.html
 Teaching and Learning Experience This program will provide a
 better teaching and learning experiencefor you and your
 students. It will help: Provide Practical Detail on the Big
 Picture Concepts: A clear and entertaining writing style
 outlines the concepts every OS designer needs to master. Keep
 Your Course Current: This edition includes information on the
 latest OS technologies and developments Enhance Learning with
 Student and Instructor Resources: Students will gain hands-on
 experience using the simulation exercises and lab experiments.
 }
}

Operating Systems: Internals and Design Principle#

Bibtex

@book{stallings2018OperatingSysInternalAndDesign,
 author = {Stallings, William},
 title = {Operating Systems: Internals and Design Principles, 9/e},
 year = 2018,
 isbn = 9352866711,
 publisher = {Pearson IT Certification},
 address = {Indianapolis, Indiana, USA},
 edition = {9th},
 abstract = {Please Read Notes: Brand New, International Softcover
 Edition, Printed in black and white pages, minor self wear on
 the cover or pages, Sale restriction may be printed on the
 book, but Book name, contents, and author are exactly same as
 Hardcover Edition. Fast delivery through DHL/FedEx express.}
}

Operating Systems Design and Implementation (3rd Edition)#

Bibtex

@book{tanenbaum2005OperatingSysImplementation,
 author = {Tanenbaum, Andrew S and Woodhull, Albert S},
 title = {Operating Systems Design and Implementation (3rd Edition)},
 year = 2005,
 isbn = 0131429388,
 publisher = {Prentice-Hall, Inc.},
 address = {USA}
}

RTOS#

Operating Systems for Low-End Devices in the Internet of Things: A Survey#

Bibtex

@article{Hahm2015OSForLowEndDevice,
 author = {O. {Hahm} and E. {Baccelli} and H. {Petersen} and N.
 {Tsiftes}},
 journal = {IEEE Internet of Things Journal},
 title = {Operating Systems for Low-End Devices in the Internet of
 Things: A Survey},
 year = 2016,
 volume = 3,
 number = 5,
 pages = {720-734},
 abstract = {The Internet of Things (IoT) is projected to soon
 interconnect tens of billions of new devices, in large part
 also connected to the Internet. IoT devices include both
 high-end devices which can use traditional go-to operating
 systems (OSs) such as Linux, and low-end devices which cannot,
 due to stringent resource constraints, e.g., very limited
 memory, computational power, and power supply. However,
 large-scale IoT software development, deployment, and
 maintenance requires an appropriate OS to build upon. In this
 paper, we thus analyze in detail the specific requirements
 that an OS should satisfy to run on low-end IoT devices, and
 we survey applicable OSs, focusing on candidates that could
 become an equivalent of Linux for such devices, i.e., a
 one-size-fits-most, open source OS for low-end IoT devices.},
 keywords = {Internet of Things;mobile computing;operating systems
 (computers);software maintenance;software maintenance;software
 deployment;software development;IoT;Internet of Things;low-end
 device;OS;operating system;Random access
 memory;Hardware;Internet of things;Operating
 systems;Standards;Embedded software;Internet of Things
 (IoT);low-power electronics;operating system (OS)},
 doi = {10.1109/JIOT.2015.2505901},
 ISSN = {2327-4662},
 month = {Oct},
}

Synchronization#

Little book of semaphores#

Bibtex

@book{LittleBookOfSemaphores,
 title = {The little book of semaphores},
 author = {Downey, Allen},
 volume = 2,
 number = 2,
 year = 2008,
 publisher = {Green Tea Press},
 url = "https://github.com/AllenDowney/LittleBookOfSemaphores",
}

Computer Architecture#

Network-On-Chip (NoC)#

Redes-em-Chip: arquiteturas e modelos para avaliação de área e desempenho#

Bibtex

@phdthesis{RedesEmChipArquiteturasEmodelosParaAvaliacaoDeAreaEdesempenho,
 author = {Cesar Albenes Zeferino},
 title = {Redes-em-Chip: arquiteturas e modelos para avaliação de
 área e desempenho},
 year = 2003,
 school = {Universidade Federal do Rio Grande do Sul},
 address = {Porto Alegre, RS, Brasil},
 abstract = {Com o advento dos processos submicrônicos, a capacidade de
 integração de transistores tem atingido níveis que
 possibilitam a construção de um sistema completo em uma única
 pastilha de silício. Esses sistemas, denominados sistemas
 integrados, baseiam-se no reuso de blocos previamente
 projetados e verificados, os quais são chamados de núcleos ou
 blocos de propriedade intelectual. Os sistemas integrados
 atuais incluem algumas poucas dezenas de núcleos, os quais são
 interconectados por meio de arquiteturas de comunicação
 baseadas em estruturas dedicadas de canais ponto-a-ponto ou em
 estruturas reutilizáveis constituídas por canais multiponto,
 denominadas barramentos. Os futuros sistemas integrados irão
 incluir de dezenas a centenas de núcleos em um mesmo chip com
 até alguns bilhões de transistores, sendo que, para atender às
 pressões do mercado e amortizar os custos de projeto entre
 vários sistemas, é importante que todos os seus componentes
 sejam reutilizáveis, incluindo a arquitetura de comunicação.
 Das arquiteturas utilizadas atualmente, o barramento é a única
 que oferece reusabilidade. Porém, o seu desempenho em
 comunicação e o seu consumo de energia degradam com o
 crescimento do sistema. Para atender aos requisitos dos
 futuros sistemas integrados, uma nova alternativa de
 arquitetura de comunicação tem sido proposta na comunidade
 acadêmica. Essa arquitetura, denominada rede-em-chip,
 baseia-se nos conceitos utilizados nas redes de interconexão
 para computadores paralelos. Esta tese se situa nesse contexto
 e apresenta uma arquitetura de rede-em-chip e um conjunto de
 modelos para a avaliação de área e desempenho de arquiteturas
 de comunicação para sistemas integrados. A arquitetura
 apresentada é denominada SoCIN (System-on-Chip Interconnection
 Network) e apresenta como diferencial o fato de poder ser
 dimensionada de modo a atender a requisitos de custo e
 desempenho da aplicação alvo. Os modelos desenvolvidos
 permitem a estimativa em alto nível da área em silício e do
 desempenho de arquiteturas de comunicação do tipo barramento e
 rede-em-chip. São apresentados resultados que demonstram a
 efetividade das redes-em-chip e indicam as condições que
 definem a aplicabilidade das mesmas.},
}

Principles and Practices of Interconnection Network#

Bibtex

@book{principelsAndPracticesOfInterconnectionNetworks,
 author = {Dally, William James and Towles, Brian Patrick},
 title = {Principles and Practices of Interconnection Networks},
 year = 2004,
 isbn = 9780080497808,
 publisher = {Morgan Kaufmann Publishers Inc.},
 address = {San Francisco, CA, USA},
 abstract = {One of the greatest challenges faced by designers of
 digital systems is optimizing the communication and
 interconnection between system components. Interconnection
 networks offer an attractive and economical solution to this
 communication crisis and are fast becoming pervasive in
 digital systems. Current trends suggest that this
 communication bottleneck will be even more problematic when
 designing future generations of machines. Consequently, the
 anatomy of an interconnection network router and science of
 interconnection network design will only grow in importance in
 the coming years. This book offers a detailed and
 comprehensive presentation of the basic principles of
 interconnection network design, clearly illustrating them with
 numerous examples, chapter exercises, and case studies. It
 incorporates hardware-level descriptions of concepts, allowing
 a designer to see all the steps of the process from abstract
 design to concrete implementation. ·Case studies throughout
 the book draw on extensive author experience in designing
 interconnection networks over a period of more than twenty
 years, providing real world examples of what works, and what
 doesn't. ·Tightly couples concepts with implementation costs
 to facilitate a deeper understanding of the tradeoffs in the
 design of a practical network. ·A set of examples and
 exercises in every chapter help the reader to fully understand
 all the implications of every design decision. Table of
 Contents Chapter 1 Introduction to Interconnection Networks
 1.1 Three Questions About Interconnection Networks 1.2 Uses of
 Interconnection Networks 1.3 Network Basics 1.4 History 1.5
 Organization of this Book Chapter 2 A Simple Interconnection
 Network 2.1 Network Specifications and Constraints 2.2
 Topology 2.3 Routing 2.4 Flow Control 2.5 Router Design 2.6
 Performance Analysis 2.7 Exercises Chapter 3 Topology Basics
 3.1 Nomenclature 3.2 Traffic Patterns 3.3 Performance 3.4
 Packaging Cost 3.5 Case Study: The SGI Origin 2000 3.6
 Bibliographic Notes 3.7 Exercises Chapter 4 Butterfly Networks
 4.1 The Structure of Butterfly Networks 4.2 Isomorphic
 Butterflies 4.3 Performance and Packaging Cost 4.4 Path
 Diversity and Extra Stages 4.5 Case Study: The BBN Butterfly
 4.6 Bibliographic Notes 4.7 Exercises Chapter 5 Torus Networks
 5.1 The Structure of Torus Networks 5.2 Performance 5.3
 Building Mesh and Torus Networks 5.4 Express Cubes 5.5 Case
 Study: The MIT J-Machine 5.6 Bibliographic Notes 5.7 Exercises
 Chapter 6 Non-Blocking Networks 6.1 Non-Blocking vs.
 Non-Interfering Networks 6.2 Crossbar Networks 6.3 Clos
 Networks 6.4 Benes Networks 6.5 Sorting Networks 6.6 Case
 Study: The Velio VC2002 (Zeus) Grooming Switch 6.7
 Bibliographic Notes 6.8 Exercises Chapter 7 Slicing and Dicing
 7.1 Concentrators and Distributors 7.2 Slicing and Dicing 7.3
 Slicing Multistage Networks 7.4 Case Study: Bit Slicing in the
 Tiny Tera 7.5 Bibliographic Notes 7.6 Exercises Chapter 8
 Routing Basics 8.1 A Routing Example 8.2 Taxonomy of Routing
 Algorithms 8.3 The Routing Relation 8.4 Deterministic Routing
 8.5 Case Study: Dimension-Order Routing in the Cray T3D 8.6
 Bibliographic Notes 8.7 Exercises Chapter 9 Oblivious Routing
 9.1 Valiant's Randomized Routing Algorithm 9.2 Minimal
 Oblivious Routing 9.3 Load-Balanced Oblivious Routing 9.4
 Analysis of Oblivious Routing 9.5 Case Study: Oblivious
 Routing in the Avici Terabit Switch Router(TSR) 9.6
 Bibliographic Notes 9.7 Exercises Chapter 10 Adaptive Routing
 10.1 Adaptive Routing Basics 10.2 Minimal Adaptive Routing
 10.3 Fully Adaptive Routing 10.4 Load-Balanced Adaptive
 Routing 10.5 Search-Based Routing 10.6 Case Study: Adaptive
 Routing in the Thinking Machines CM-5 10.7 Bibliographic Notes
 10.8 Exercises Chapter 11 Routing Mechanics 11.1 Table-Based
 Routing 11.2 Algorithmic Routing 11.3 Case Study: Oblivious
 Source Routing in the IBM Vulcan Network 11.4 Bibliographic
 Notes 11.5 Exercises Chapter 12 Flow Control Basics 12.1
 Resources and Allocation Units 12.2 Bufferless Flow Control
 12.3 Circuit Switching 12.4 Bibliographic Notes 12.5 Exercises
 Chapter 13 Buffered Flow Control 13.1 Packet-Buffer Flow
 Control 13.2 Flit-Buffer Flow Control 13.3 Buffer Management
 and Backpressure 13.4 Flit-Reservation Flow Control 13.5
 Bibliographic Notes 13.6 Exercises Chapter 14 Deadlock and
 Livelock 14.1 Deadlock 14.2 Deadlock Avoidance 14.3 Adaptive
 Routing 14.4 Deadlock Recovery 14.5 Livelock 14.6 Case Study:
 Deadlock Avoidance in the Cray T3E 14.7 Bibliographic Notes
 14.8 Exercises Chapter 15 Quality of Service 15.1 Service
 Classes and Service Contracts 15.2 Burstiness and Network
 Delays 15.3 Implementation of Guaranteed Services 15.4
 Implementation of Best-Effort Services 15.5 Separation of
 Resources 15.6 Case Study: ATM Service Classes 15.7 Case
 Study: Virtual Networks in the Avici TSR 15.8 Bibliographic
 Notes 15.9 Exercises Chapter 16 Router Architecture 16.1 Basic
 Router Architecture 16.2 Stalls 16.3 Closing the Loop with
 Credits 16.4 Reallocating a Channel 16.5 Speculation and
 Lookahead 16.6 Flit and Credit Encoding 16.7 Case Study: The
 Alpha 21364 Router 16.8 Bibliographic Notes 16.9 Exercises
 Chapter 17 Router Datapath Components 17.1 Input Buffer
 Organization 17.2 Switches 17.3 Output Organization 17.4 Case
 Study: The Datapath of the IBM Colony Router 17.5
 Bibliographic Notes 17.6 Exercises Chapter 18 Arbitration 18.1
 Arbitration Timing 18.2 Fairness 18.3 Fixed Priority Arbiter
 18.4 Variable Priority Iterative Arbiters 18.5 Matrix Arbiter
 18.6 Queuing Arbiter 18.7 Exercises Chapter 19 Allocation 19.1
 Representations 19.2 Exact Algorithms 19.3 Separable
 Allocators 19.4 Wavefront Allocator 19.5 Incremental vs. Batch
 Allocation 19.6 Multistage Allocation 19.7 Performance of
 Allocators 19.8 Case Study: The Tiny Tera Allocator 19.9
 Bibliographic Notes 19.10 Exercises Chapter 20 Network
 Interfaces 20.1 Processor-Network Interface 20.2 Shared-Memory
 Interface 20.3 Line-Fabric Interface 20.4 Case Study: The MIT
 M-Machine Network Interface 20.5 Bibliographic Notes 20.6
 Exercises Chapter 21 Error Control 411 21.1 Know Thy Enemy:
 Failure Modes and Fault Models 21.2 The Error Control Process:
 Detection, Containment, and Recovery 21.3 Link Level Error
 Control 21.4 Router Error Control 21.5 Network-Level Error
 Control 21.6 End-to-end Error Control 21.7 Bibliographic Notes
 21.8 Exercises Chapter 22 Buses 22.1 Bus Basics 22.2 Bus
 Arbitration 22.3 High Performance Bus Protocol 22.4 From Buses
 to Networks 22.5 Case Study: The PCI Bus 22.6 Bibliographic
 Notes 22.7 Exercises Chapter 23 Performance Analysis 23.1
 Measures of Interconnection Network Performance 23.2 Analysis
 23.3 Validation 23.4 Case Study: Efficiency and Loss in the
 BBN Monarch Network 23.5 Bibliographic Notes 23.6 Exercises
 Chapter 24 Simulation 24.1 Levels of Detail 24.2 Network
 Workloads 24.3 Simulation Measurements 24.4 Simulator Design
 24.5 Bibliographic Notes 24.6 Exercises Chapter 25 Simulation
 Examples 495 25.1 Routing 25.2 Flow Control Performance 25.3
 Fault Tolerance Appendix A Nomenclature Appendix B Glossary
 Appendix C Network Simulator}
}

Fault tolerance#

Fault Tolerant Computer Architecture (Synthesis Lectures on Computer Architecture)#

Bibtex

@book{Sorin2009FaultTolerantComputerArchitecture,
 author = {Sorin, Daniel J.},
 title = {Fault Tolerant Computer Architecture},
 year = 2009,
 isbn = 1598299530,
 publisher = {Morgan and Claypool Publishers},
 abstract = {For many years, most computer architects have pursued one
 primary goal: performance. Architects have translated the
 ever-increasing abundance of ever-faster transistors provided
 by Moore's law into remarkable increases in performance.
 Recently, however, the bounty provided by Moore's law has been
 accompanied by several challenges that have arisen as devices
 have become smaller, including a decrease in dependability due
 to physical faults. In this book, we focus on the
 dependability challenge and the fault tolerance solutions that
 architects are developing to overcome it. The two main
 purposes of this book are to explore the key ideas in
 fault-tolerant computer architecture and to present the
 current state-of-the-art - over approximately the past 10
 years - in academia and industry. Table of Contents:
 Introduction / Error Detection / Error Recovery / Diagnosis /
 Self-Repair / The Future}
}

Single event effects in aerospace#

Bibtex

@book{Petersen2011SingleEventEfefctsInAerospace,
 author = {Petersen, Edward},
 address = {Piscataway, N.J.?},
 booktitle = {Single event effects in aerospace},
 isbn = 9780470767498,
 publisher = {IEEE Press},
 keywords = {Astrionics -- Protection},
 language = {eng},
 lccn = 2011002191,
 title = {Single event effects in aerospace / Edward Petersen.},
}

Overview of single event effects#

Bibtex

@book{buchner2015overview,
 title = {Overview of single event effects},
 author = {Buchner, S},
 booktitle = {Proc. 11th Int. School Effects Radiation Embedded Syst.
 Space Appl.(SERESSA)},
 pages = {62--69},
 year = 2015
}

Draft - Single Event Effects Specification#

Bibtex

@online{NASARadEff,
 title = {Draft - Single Event Effects Specification},
 author = {{The Radiation Effects and Analysis Group (REAG)}},
 shortauthor = {REAG},
 organization = {{National Aeronautics and Space Administration (NASA)}},
 year = 2017,
 url = "https://radhome.gsfc.nasa.gov/radhome/papers/seespec.htm",
 note = {last accessed on 24/01/2021},
}

Single event effects mitigation techniques report#

Bibtex

@article{mutuel2016single,
 title = {Single event effects mitigation techniques report},
 author = {Mutuel, LH},
 journal = {Federal Aviation Administration, William J. Hughes
 Technical Center, Aviation Research Division, Atlantic City
 International Airport, Final report DOT/FAA/TC-15/62},
 year = 2016
}

Circuit Level Design Methods to Mitigate Soft Errors#

Bibtex

@inproceedings{reis2020CircutLevelDesignmethods,
 author = {R. {Reis} and C. {Meinhardt} and A. L. {Zimpeck} and L. H.
 {Brendler} and L. {Moraes}},
 booktitle = {2020 IEEE Latin-American Test Symposium (LATS)},
 title = {Circuit Level Design Methods to Mitigate Soft Errors},
 year = 2020,
 pages = {1-3},
 doi = {10.1109/LATS49555.2020.9093683}
}

SWIFT: software implemented fault tolerance#

Bibtex

@INPROCEEDINGS{reis2005SwitfSoftware,
 author = {G. A. {Reis} and J. {Chang} and N. {Vachharajani} and R.
 {Rangan} and D. I. {August}},
 booktitle = {International Symposium on Code Generation and
 Optimization},
 title = {SWIFT: software implemented fault tolerance},
 year = 2005,
 pages = {243-254},
 doi = {10.1109/CGO.2005.34}
}

Applying Compiler-Automated Software Fault Tolerance to Multiple Processor Platforms#

Bibtex

@article{james2019applying,
 title = {Applying Compiler-Automated Software Fault Tolerance to
 Multiple Processor Platforms},
 author = {James, Benjamin and Quinn, Heather and Wirthlin, Michael
 and Goeders, Jeffrey},
 journal = {IEEE Transactions on Nuclear Science},
 volume = 67,
 number = 1,
 pages = {321--327},
 year = 2019,
 publisher = {IEEE}
}

CDFEDT: Comparison of Data Flow Error Detection Techniques in Embedded Systems: An Empirical Study#

Bibtex

@inproceedings{thati2018ComparisonOfDataFlowError,
 author = {Thati, Venu Babu and Vankeirsbilck, Jens and Penneman,
 Niels and Pissoort, Davy and Boydens, Jeroen},
 title = {CDFEDT: Comparison of Data Flow Error Detection Techniques
 in Embedded Systems: An Empirical Study},
 year = 2018,
 isbn = 9781450364485,
 publisher = {Association for Computing Machinery},
 address = {New York, NY, USA},
 url = {https://doi.org/10.1145/3230833.3230854},
 doi = {10.1145/3230833.3230854},
 abstract = {Embedded systems used in harsh environments are susceptible
 to bit-flips, which can cause data flow errors. In order to
 increase the reliability of embedded systems, numerous data
 flow error detection techniques have already been developed.
 It is, however, difficult to identify the best technique to
 apply, due to differences in the way they are evaluated in
 current literature.This paper presents an empirical
 comparative study of seven existing techniques. We measured
 fault coverage, execution time overhead, and code size
 overhead. We conclude that soft error detection using software
 redundancy (SEDSR) and error detection by duplicated
 instructions (EDDI) have a better trade-off between fault
 coverage and overheads than software-implemented fault
 tolerance (SWIFT), critical block duplication (CBD), and
 overhead reduction (VAR3+). Error detection by diverse data
 and duplicated instructions (ED4I or EDDDDI) and software
 approach (SA) had better fault coverage at the expense of
 execution time and code size usage.},
 booktitle = {Proceedings of the 13th International Conference on
 Availability, Reliability and Security},
 articleno = 23,
 numpages = 9,
 keywords = {Fault tolerance, Fault coverage, Bit-flips, Data flow error
 detection, Comparison},
 location = {Hamburg, Germany},
 series = {ARES 2018}
}

Introductory#

Structured Computer Organization (5th Edition)#

Bibtex

@book{tanenbaum2005structuredorg,
 author = {Tanenbaum, Andrew S.},
 title = {Structured Computer Organization (5th Edition)},
 year = 2005,
 isbn = 0131485210,
 publisher = {Prentice-Hall, Inc.},
 address = {USA}
}

Computer Organization and Design, Fifth Edition: The Hardware/Software Interface#

Bibtex

@book{patterson2013ComputerOrg,
 author = {Patterson, David A. and Hennessy, John L.},
 title = {Computer Organization and Design, Fifth Edition: The
 Hardware/Software Interface},
 year = 2013,
 isbn = 0124077269,
 publisher = {Morgan Kaufmann Publishers Inc.},
 address = {San Francisco, CA, USA},
 edition = {5th},
 abstract = {The 5th edition of Computer Organization and Design moves
 forward into the post-PC era with new examples, exercises, and
 material highlighting the emergence of mobile computing and
 the cloud. This generational change is emphasized and explored
 with updated content featuring tablet computers, cloud
 infrastructure, and the ARM (mobile computing devices) and x86
 (cloud computing) architectures. Because an understanding of
 modern hardware is essential to achieving good performance and
 energy efficiency, this edition adds a new concrete example,
 "Going Faster," used throughout the text to demonstrate
 extremely effective optimization techniques. Also new to this
 edition is discussion of the "Eight Great Ideas" of computer
 architecture. As with previous editions, a MIPS processor is
 the core used to present the fundamentals of hardware
 technologies, assembly language, computer arithmetic,
 pipelining, memory hierarchies and I/O. Instructors looking
 for4th Edition teaching materials should e-mail
 textbook@elsevier.com. Includes new examples, exercises, and
 material highlighting the emergence of mobile computing and
 the Cloud. Covers parallelism in depth with examples and
 content highlighting parallel hardware and software topics
 Features the Intel Core i7, ARM Cortex-A8 and NVIDIA Fermi GPU
 as real-world examples throughout the book Adds a new concrete
 example, "Going Faster," to demonstrate how understanding
 hardware can inspire software optimizations that improve
 performance by 200 times. Discusses and highlights the "Eight
 Great Ideas" of computer architecture: Performance via
 Parallelism; Performance via Pipelining; Performance via
 Prediction; Design for Moore's Law; Hierarchy of Memories;
 Abstraction to Simplify Design; Make the Common Case Fast; and
 Dependability via Redundancy. Includes a full set of updated
 and improved exercises.}
}

Computer Organization and Architecture: Designing for Performance#

Bibtex

@book{stallings2009ComputerOrgPerf,
 author = {Stallings, William},
 title = {Computer Organization and Architecture: Designing for
 Performance},
 year = 2009,
 isbn = 9780136073734,
 publisher = {Prentice Hall Press},
 address = {USA},
 edition = {8th},
 abstract = {KEY BENEFIT: Learn the fundamentals of processor and
 computer design from the newest edition of this award winning
 text. KEY TOPICS: Introduction; Computer Evolution and
 Performance; A Top-Level View of Computer Function and
 Interconnection; Cache Memory; Internal Memory Technology;
 External Memory; I/O; Operating System Support; Computer
 Arithmetic; Instruction Sets: Characteristics and Functions;
 Instruction Sets: Addressing Modes and Formats; CPU Structure
 and Function; RISCs; Instruction-Level Parallelism and
 Superscalar Processors; Control Unit Operation;
 Microprogrammed Control; Parallel Processing; Multicore
 Architecture. Online Chapters: Number Systems; Digital Logic;
 Assembly Language, Assemblers, and Compilers; The IA-64
 Architecture. MARKET: Ideal for professionals in computer
 science, computer engineering, and electrical engineering.}
}

RISC-V#

The RISC-V Instruction Set Manual Volume II: Privileged Architecture Version v.20190608#

Bibtex

@techreport{riscv2019PrivilegeArchitecture,
 Author = {Waterman, Andrew and Lee, Yunsup and Avizienis, Rimas and Patterson, David A. and Asanović, Krste},
 Title = {The RISC-V Instruction Set Manual Volume II: Privileged Architecture Ratified Version 1.11},
 Institution = {EECS Department, University of California, Berkeley},
 Year = {2019},
 Month = {Jun},
 URL = {https://github.com/riscv/riscv-isa-manual/releases/download/Ratified-IMFDQC-and-Priv-v1.11/riscv-privileged-20190608.pdf},
 Number = {v.20190608}
}

The Case for RISC-V in Space#

Bibtex

@inproceedings{ottavi2019TheCaseForRiscvInSpace,
 author = "Di Mascio, Stefano and Menicucci, Alessandra and Furano,
 Gianluca and Monteleone, Claudio and Ottavi, Marco",
 editor = "Saponara, Sergio and De Gloria, Alessandro",
 title = "The Case for RISC-V in Space",
 booktitle = "Applications in Electronics Pervading Industry, Environment
 and Society",
 year = 2019,
 publisher = "Springer International Publishing",
 address = "Cham",
 pages = "319--325",
 abstract = "This paper presentsDi Mascio, Stefano preliminary position
 on theMenicucci, Alessandra use of the novel, free and open
 RISC-V Instruction Set Architecture (ISA) for on-boardFurano,
 Gianluca electronics in space. The modular nature of this ISA,
 the availability of a rich software ecosystem, a rapidly
 growing communityMonteleone, Claudio and a pool of open-source
 IP cores will allow Space Industry to spin-in developments
 from terrestrial fields (in terms of security, artificial
 intelligence, support forOttavi, Marco operating systems,
 hardware acceleration etc.) while focusing its efforts mainly
 on aspects related to the specific needs of on-board
 electronics for space applications (e.g. fault tolerance,
 observability, error signaling, etc.). This will improve reuse
 and avoid the necessity of developments from scratch when not
 strategically needed, eventually increasing productivity and
 reducing costs. The use of an open, non proprietary ISA will
 allow ad-hoc design of microarchitecture-level soft error
 countermeasures that can greatly increase the robustness of
 Application Specific Standard Products (ASSP) and FPGA
 implementations.",
 isbn = "978-3-030-11973-7"
}

The RISC-V Reader: An Open Architecture Atlas#

Bibtex

@book{patterson2017RiscvAtlas,
 author = {Patterson, David and Waterman, Andrew},
 title = {The RISC-V Reader: An Open Architecture Atlas},
 year = 2017,
 isbn = 0999249118,
 publisher = {Strawberry Canyon},
 edition = {1st},
 abstract = {The RISC-V Reader is a concise introduction and reference
 for embedded systems programmers, students, and the curious to
 a modern, popular, open architecture. RISC-V spans from the
 cheapest 32-bit embedded microcontroller to the fastest 64-bit
 cloud computer. The text shows how RISC-V followed the good
 ideas of past architectures while avoiding their mistake.
 Highlights include: Introduces the RISC-V instruction set in
 only 100 pages, including 75 figures An Instruction Translator
 Guide to help translate assembly language programs from ARM-32
 and x86-32 instruction sets to RISC-V 2-page RISC-V Reference
 Card that summarizes all instructions 50-page Instruction
 Glossary that defines every instruction in detail 75
 spotlights of good architecture design using margin icons 50
 sidebars with interesting commentary and RISC-V history 25
 quotes to pass along wisdom of noted scientists and engineers
 Ten chapters introduce each component of the modular RISC-V
 instruction set--often contrasting code compiled from C to
 RISC-V versus the older ARM, Intel, and MIPS
 architectures--but readers can start programming after Chapter
 2. Praise for The RISC-V Reader: This timely book concisely
 describes the simple, free and open RISC-V ISA that is
 experiencing rapid uptake in many different computing sectors.
 Krste Asanovic, University of California, Berkeley, one of the
 four architects of RISC-V I like RISC-V and this book as they
 are elegantbrief, to the point, and complete. C. Gordon Bell,
 a computer architecture pioneer This handy little book
 effortlessly summarizes all the essential elements of the
 RISC-V Instruction Set Architecture, a perfect reference guide
 for students and practitioners alike. Professor Randy Katz,
 University of California, Berkeley, one of the inventors of
 RAID storage systems This clearly-written book offers a good
 introduction to RISC-V, augmented with insightful comments on
 its evolutionary history and comparisons with other familiar
 architectures. John Mashey, one of the designers of the MIPS
 architecture This book tells what RISC-V can do and why its
 designers chose to endow it with those abilities. Ivan
 Sutherland, the father of computer graphics RISC-V will change
 the world, and this book will help you become part of that
 change. Professor Michael B. Taylor, University of Washington
 This book will be an invaluable reference for anyone working
 with the RISC-V ISA. Megan Wachs, PhD, SiFive Engineer}
}

The RISC-V Instruction Set Manual (2014)#

Bibtex

@misc{Waterman14therisc-v,
 author = {Andrew Waterman and Yunsup Lee and David A. Patterson and
 Krste Asanovic and Volume I User-level Isa and Andrew Waterman
 and Yunsup Lee and David Patterson},
 title = {The RISC-V Instruction Set Manual},
 year = 2014
}

Computer Organization and Design RISC-V Edition: The Hardware Software Interface#

Bibtex

@book{patterson2017ComputerOrgRiscvEdition,
 author = {Patterson, David A. and Hennessy, John L.},
 title = {Computer Organization and Design RISC-V Edition: The
 Hardware Software Interface},
 year = 2017,
 isbn = 0128122757,
 publisher = {Morgan Kaufmann Publishers Inc.},
 address = {San Francisco, CA, USA},
 edition = {1st},
 abstract = {The new RISC-V Edition of Computer Organization and Design
 features the RISC-V open source instruction set architecture,
 the first open source architecture designed to be used in
 modern computing environments such as cloud computing, mobile
 devices, and other embedded systems. With the post-PC era now
 upon us, Computer Organization and Design moves forward to
 explore this generational change with examples, exercises, and
 material highlighting the emergence of mobile computing and
 the Cloud. Updated content featuring tablet computers, Cloud
 infrastructure, and the x86 (cloud computing) and ARM (mobile
 computing devices) architectures is included. An online
 companion Web site provides advanced content for further
 study, appendices, glossary, references, and recommended
 reading. Features RISC-V, the first such architecture designed
 to be used in modern computing environments, such as cloud
 computing, mobile devices, and other embedded systems Includes
 relevant examples, exercises, and material highlighting the
 emergence of mobile computing and the cloud}
}

Software Engineering#

Embedded systems#

Modeling C-based embedded system using UML design#

Bibtex

@inproceedings{wang2009modeling,
 author = { {Guoping Wang}},
 booktitle = {2009 International Conference on Mechatronics and
 Automation},
 title = {Modeling C-based embedded system using UML design},
 year = 2009,
 pages = {2973-2977},
 abstract = {Unified Modeling Language (UML) 2.0 is emerging in the area
 of modeling the design of embedded system. The most common
 implementation for the embedded-system models has been C++. On
 one hand, the most common programming language for embedded
 system overall by far is the functional language C. On the
 other hand, the UML is used almost exclusively for
 object-oriented systems development. This paper present an
 approach of applying UML in the functionally-oriented embedded
 systems design. This approach is illustrated using a stopwatch
 design example.},
 keywords = {C++ language;embedded systems;functional languages;Unified
 Modeling Language;modeling C-based embedded system;UML
 design;Unified Modeling Language;UML 2.0;C++;programming
 language;functional language C;object-oriented systems
 development;functionally-oriented embedded systems
 design;stopwatch design;Embedded system;Unified modeling
 language;Object oriented modeling;Computer languages;Embedded
 computing;Real time systems;Costs;Energy
 consumption;Mechatronics;Design automation;UML
 modeling;embedded system
 design;object-oriented;function-oriented},
 doi = {10.1109/ICMA.2009.5246023},
 ISSN = {2152-744X},
 month = {Aug},
}

Fault tolerant#

Basic concepts and taxonomy of dependable and secure computing#

Bibtex

@article{avizienis2004ConceptsOfSecureComputing,
 author = {A. {Avizienis} and J. -. {Laprie} and B. {Randell} and C.
 {Landwehr}},
 journal = {IEEE Transactions on Dependable and Secure Computing},
 title = {Basic concepts and taxonomy of dependable and secure
 computing},
 year = 2004,
 volume = 1,
 number = 1,
 pages = {11-33},
 abstract = {This paper gives the main definitions relating to
 dependability, a generic concept including a special case of
 such attributes as reliability, availability, safety,
 integrity, maintainability, etc. Security brings in concerns
 for confidentiality, in addition to availability and
 integrity. Basic definitions are given first. They are then
 commented upon, and supplemented by additional definitions,
 which address the threats to dependability and security
 (faults, errors, failures), their attributes, and the means
 for their achievement (fault prevention, fault tolerance,
 fault removal, fault forecasting). The aim is to explicate a
 set of general concepts, of relevance across a wide range of
 situations and, therefore, helping communication and
 cooperation among a number of scientific and technical
 communities, including ones that are concentrating on
 particular types of system, of system failures, or of causes
 of system failures.},
 keywords = {fault tolerant computing;data privacy;security of
 data;system recovery;software reliability;taxonomy;dependable
 computing;secure computing;system reliability;system
 availability;system safety;system integrity;system
 maintainability;fault prevention;fault tolerance;fault
 removal;fault forecasting;system security;system
 failures;system vulnerabilities;system
 attacks;Taxonomy;Availability;Fault
 tolerance;Safety;Maintenance;Communication system
 security;Uncertainty;Standardization;Books;Index Terms-
 Dependability;security;trust;faults;errors;failures;vulnerabilities;attacks;fault
 tolerance;fault removal;fault forecasting.},
 doi = {10.1109/TDSC.2004.2},
 ISSN = {1941-0018},
 month = {Jan},
}

System structure for Software Fault Tolerance#

Bibtex

@ARTICLE{RandellSysStructureForSoftwareFaultTolerance,
 author = {Randell, Brian},
 journal = {IEEE Transactions on Software Engineering},
 title = {System structure for software fault tolerance},
 year = 1975,
 volume = {SE-1},
 number = 2,
 pages = {220-232},
 abstract = {Presents and discusses the rationale behind a method for
 structuring complex computing systems by the use of what is
 termed `recovery blocks,' `conversations,' and `fault-tolerant
 interfaces.' The aim is to facilitate the provision of
 dependable error detection and recovery facilities which can
 cope with errors caused by residual design inadequacies,
 particularly in the system software, rather than merely the
 occasional malfunctioning of hardware components.},
 doi = {10.1109/TSE.1975.6312842},
 ISSN = {1939-3520},
 month = {June},
}

Mathematics#

Binary#

Bit Twiddling Hacks#

Bibtex

@misc{sean2005BitTwiddlingHacks,
 title = { Bit Twiddling Hacks },
 url = {https://graphics.stanford.edu/~seander/bithacks.html},
 journal = {Bit Twiddling Hacks},
 author = {Sean Eron Anderson}
}

Binary number representation#

Bibtex

@misc{binaryNumberRepresentation,
 title = {Unsigned Binary Integer},
 url =
 {https://www.mathcs.emory.edu/~cheung/Courses/255/others/BinNumReps.html},
 journal = {Binary Number Representations}
}

What are bitwise shift (bit-shift) operators and how do they work?#

Bibtex

@misc{derekpark2008WhatAreBitwiseShift,
 title = {What are bitwise shift (bit-shift) operators and how do
 they work?},
 url = {https://stackoverflow.com/a/141873},
 journal = {What are bitwise shift (bit-shift) operators and how do
 they work},
 publisher = {Stackoverflow},
 author = {Derek Park},
 year = 2008,
 month = {Sep}
}

Database#

SQL databases v. NoSQL databases#

Bibtex

@article{stonerbraker2020SQLDatabasesvNoSQLDatabases,
 author = {Stonebraker, Michael},
 title = {SQL Databases v. NoSQL Databases},
 year = 2010,
 issue_date = {April 2010},
 publisher = {Association for Computing Machinery},
 address = {New York, NY, USA},
 volume = 53,
 number = 4,
 issn = {0001-0782},
 url = {https://doi.org/10.1145/1721654.1721659},
 doi = {10.1145/1721654.1721659},
 abstract = {The Communications Web site, http://cacm.acm.org, features
 more than a dozen bloggers in the BLOG@CACM community. In each
 issue of Communications, we'll publish excerpts from selected
 posts.twitterFollow us on Twitter at
 http://twitter.com/blogCACMMichael Stonebraker considers
 several performance arguments in favor of NoSQL
 databases---and finds them insufficient.},
 journal = {Commun. ACM},
 month = apr,
 pages = {10–11},
 numpages = 2
}

Algorithms#

Lock-Free Red-Black Trees Using CAS#

Bibtex

@inproceedings{Kim2011LockFreeRT,
 title={Lock-Free Red-Black Trees Using CAS},
 author={Jong Ho Kim and Helen Cameron and Peter C. J. Graham},
 year={2011}
}

Parallel algorithms for red–black trees#

Bibtex

@article{park2001ParallelAlgorithms,
 title = {Parallel algorithms for red–black trees},
 journal = {Theoretical Computer Science},
 volume = 262,
 number = 1,
 pages = {415-435},
 year = 2001,
 issn = {0304-3975},
 doi = {https://doi.org/10.1016/S0304-3975(00)00287-5},
 url = {https://www.sciencedirect.com/science/article/pii/S0304397500002875},
 author = {Heejin Park and Kunsoo Park},
 keywords = {Red–black trees, Balanced search trees, Parallel
 algorithms, Dictionary operations},
 abstract = {We present parallel algorithms for the following four
 operations on red–black trees: construction, search,
 insertion, and deletion. Our parallel algorithm for
 constructing a red–black tree from a sorted list of n items
 runs in O(1) time with n processors on the CRCW PRAM and runs
 in O(loglogn) time with n/loglogn processors on the EREW PRAM.
 Our construction algorithm does not require the assumptions
 that previous construction algorithms used. Each of our
 parallel algorithms for search, insertion, and deletion in
 red–black trees runs in O(logn+logk) time with k processors on
 the EREW PRAM, where k is the number of unsorted items to
 search for, insert, or delete and n is the number of nodes in
 a red–black tree.}
}

Introduction to algorithms#

Bibtex

@book{introToAlgorithms2009,
 author = {Cormen, Thomas H. and Leiserson, Charles E. and Rivest,
 Ronald L. and Stein, Clifford},
 title = {Introduction to Algorithms, Third Edition},
 year = 2009,
 isbn = 0262033844,
 publisher = {The MIT Press},
 edition = {3rd},
 abstract = {If you had to buy just one text on algorithms, Introduction
 to Algorithms is a magnificent choice. The book begins by
 considering the mathematical foundations of the analysis of
 algorithms and maintains this mathematical rigor throughout
 the work. The tools developed in these opening sections are
 then applied to sorting, data structures, graphs, and a
 variety of selected algorithms including computational
 geometry, string algorithms, parallel models of computation,
 fast Fourier transforms (FFTs), and more. This book's strength
 lies in its encyclopedic range, clear exposition, and powerful
 analysis. Pseudo-code explanation of the algorithms coupled
 with proof of their accuracy makes this book is a great
 resource on the basic tools used to analyze the performance of
 algorithms.}
}

Toward a Unique Representation for AVL and Red-Black Trees#

Bibtex

@article{BOUNIF2019,
 title = {{Toward a Unique Representation for AVL and Red-Black
 Trees}},
 journal = {{Computaci\~A\textthreesuperiorn y Sistemas}},
 author = {Bounif, Lynda AND Zegour, Djamel Eddine},
 ISSN = {1405-5546},
 language = {en},
 URL = {http://www.scielo.org.mx/scielo.php?script=sci_arttext&pid=S1405-55462019000200435&nrm=iso},
 volume = 23,
 year = 2019,
 month = 06,
 pages = {435 - 450},
 publisher = {scielomx},
 crossref = {10.13053/cys-23-2-2840},
}

Problemas Dinâmicos de Coleta e Entrega Com Janelas de Tempo#

Bibtex

@inproceedings{problemasDinamicosDeColetaEEntregaComJanelasDeTempo,
 author = {Eccel, Renan and Carlson, Rodrigo},
 year = 2019,
 month = 11,
 title = {PROBLEMAS DINÂMICOS DE COLETA E ENTREGA COM JANELAS DE
 TEMPO: ANÁLISE DAS INSTÂNCIAS DE BENCHMARK}
}

Concurrent, lock-free insertion in red-black trees#

Bibtex

@article{ma2004concurrent,
 title = {Concurrent, lock-free insertion in red-black trees},
 author = {Ma, Jianwen},
 year = 2004
}

Notes on RISC-V CPU HARD IP Cores enter SoC FPGAs

Mon, 16 Nov 2020 22:49:00 +0000

Notes on RISC-V CPU HARD IP Cores enter SoC FPGAs presentation

Frozen base ISA
Consolidation in the semiconductor industry
RISC-V is not owned by anyone
Custom instruction extension to extend the virtuous cycle of semiconductor innovation

PolarFire SoC - RISC-V enabled innocation platform#

Mixed critically RTOS + Linux support
Defence grade security
Exceptional reliability
Designed for low-power
L2 memory subsystem
- Can be made to be deterministic
- Not all L2 are deterministic

Modeling C-based systems with UML

Sat, 14 Nov 2020 12:54:00 +0000

Related pages
- Software Engineering
- Methodologies

Introduction#

The Unified Modeling Language (UML) is used almost exclusively for Object Oriented Programming (OOP). Since embedded system design has become increasingly more complex, designers have been searching for new methodologies to manage these complexities and allowing higher productivity. Due to the exclusivity of UML for OOP, it makes it difficult for functional programmers to integrate UML concepts into the modeling because the transformation of many UML concepts to C is difficult and confusing .

Technical challenge checklist

Fri, 16 Oct 2020 07:43:00 +0000

tags: Programming Software Engineering

Having done quiet a lot of technical challenges, and having forgotten some details when submitting, I came up with a good checklist of things to check before submitting the technical test.

Must do checklist#

Keep commit readable, check if the company has any commit format of their own in their public GitHub organization or their wiki page (if any), otherwise, use conventional commits
Structure your commits so we can revert in case of any bug. Make your git history ready for production, see Personal git workflow
Use well stable, known libraries
Document your decisions of why, where and how
Write tests for everything your write
Run static code analysers and make sure there aren’t any undefined variables
Benchmark what you wrote for validating algorithms/project
Configure and use a linter

Technical project#

Use environment variables for secrets, api urls, debugging and general configuration
Enable application logging where needed
Document reusable API functions
Lock dependency versions
Take some time to think of the project structure, create diagrams, check out related project’s structure
Read and re-read the requirements, if you have any doubts, do ask the developers/human resources
HTTP API? Run a stress test against your API
Containerize your application
Last but not least, have fun learning

Algorithms#

Document algorithm decisions and steps
Make algorithm comparison if possible
Don’t over complicate. It’s not because it’s an algorithm that it requires to be unreadable
Make sure the algorithm you are applying is well suited for the task
Don’t panic, you are not supposed to know all algorithms out there, but you are supposed to know where to search and implement your findings

Bonus#

Add CI integration (CircleCI, Travis, GitHub Workflow, etc)

Emacs - Search and replacing versioned controled files

Sat, 26 Sep 2020 01:53:00 +0000

I had to search and replace many files in a git repository, for some reason dired-do-find-regexp-and-replace, but I found using counsel-git-grep with wgre much easier. Here is on you do it:

M-x counsel-git-grep Search for the string
Press ivy-occur key on ivy’s search prompt result, which is set to C-c C-o by default. This will open the search results in a new buffer
On your new buffer, run wgrep-change-to-wgrep-mode (C-c C-p) and do your editing.
C-c C-c to apply your changes

I still have to figure out why isn’t dired-do-find-regexp-and-replace working properly on strings without any regular expression, for example name_to_change. It might be a bug on my end or upstream, but this might seem a bit related.

Adopting conventional commits in a codebase

Wed, 16 Sep 2020 00:00:00 +0200

Recently, it came to my attention that conventional commits don’t fit all codebases; in fact, they can annoy more than they can help in some situations.

Go binary search tree

Mon, 07 Sep 2020 18:52:00 +0000

tags: Go Programming Software Engineering

Requirements#

Sorted array of lenght N

Performance#

Say an array contains N (search space o N) elements, and we divide N/2, getting a search space of N/2, how many steps do we need until we get down to just one an array of 1 element.
O(log2 n) problem.

Implementation#

Can be implemented recursively or non-recursively.
An array of N elements.

Code#

Go Context package

Thu, 03 Sep 2020 17:08:00 +0000

tags: Programming Go Programming

Keywords#

Cancellation: is when you are requesting some services, and you cancel this request
Propagation: means that if we asked someone for a service then you tell that person to cancel

Git change commit author

Sat, 22 Aug 2020 14:09:00 +0000

tags: Programming Software Engineering

The following scripts changes all repository commits from an specific author to a new author. This is specially handy if you mess up your git config at somepoint without knowing and start commiting with a random author or you change your email/name.

#!/bin/sh

git filter-branch --env-filter '

OLD_EMAIL="your-old-email@example.com"
CORRECT_NAME="Your Correct Name"
CORRECT_EMAIL="your-correct-email@example.com"

if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
export GIT_COMMITTER_NAME="$CORRECT_NAME"
export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
export GIT_AUTHOR_NAME="$CORRECT_NAME"
export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags

Automating and testing dotfiles

Sun, 09 Aug 2020 13:06:00 +0200

I run multiple Archlinux machines at home and an OSX machine for work, so I need to keep my system configuration in sync. This is how I do it.

Personal git workflow

Tue, 04 Aug 2020 11:06:00 +0000

tags: Git Programming Workflow

As of today, this is currently my git flow for most of my projects.

Commit messages#

From: https://chris.beams.io/posts/git-commit/

Feat: Any code that contains only a new feature, whether a new model field, a new API flag, etc
Refactor: Any general code refactoring that does not contain anything new nor fixes anything.
Chore: Anything related to the build configuration, dependency updates
Docs: Anything related to documentation. This could be a function/class doc, READMEs, etc.
Fix: Anything that fixes a bug or any bad business logic

Don’t commit unrelated code, it’s easy for us to quickly change a function name and commit together with the new feature. Don’t do that. Separate your commits nicely, it will be much easier to revert commits, view logs and understand the development flow of a project.

Kommunistische Partei Deutschlands (KPD)

Mon, 03 Aug 2020 15:10:00 +0000

Related pages
- Politics

KPD election poster, 1932. The caption at the bottom reads ‘An end to this system!’.

Figure 1: KPD election poster, 1932. The caption at the bottom reads ‘An end to this system!’.

https://en.wikipedia.org/wiki/Communist%5FParty%5Fof%5FGermany

Python temporary file

Sun, 02 Aug 2020 16:44:00 +0000

tags: Python Programming

Python’s tempfile standard library is pretty neat when we need to create a temporary file and/or directories. Instead of having a much of code like this:

import pathlib

def create_file(filename):
 if pathlib.Path(filename).exists():
 # handle path removal/rewrite/backup
 pass
 with open(filename, "w") as f:
 # write to file
 pass

We can ask Python to take care of handling this type of tasks for us. tempfile handles most of the OS API, so we can focus on writting the logic instead.

Python Async

Thu, 30 Jul 2020 22:38:00 +0000

Important keywords#

Asynchronous IO (async IO) Language-agnostic paradigm (model)
coroutine A Python (sort of generator function)
async/await Python keywords used to defined a coroutine
asyncio Python package that provides an API for running/managing coroutines

Coroutine#

A coroutine allows a function to pause before returning or indirectly call another coroutine for some time, for example:

import asyncio
import time

async def count(n):
 print(f"n is {n}")
 await asyncio.sleep(n)
 print(f"Returning from {n}")


async def main():
 await asyncio.gather(count(1), count(2), count(3))


m = time.perf_counter()
asyncio.run(main())
elapsed = time.perf_counter() - m

print(f"Executed in {elapsed:0.2f} seconds.")

n is 1
n is 2
n is 3
Returning from 1
Returning from 2
Returning from 3
Executed in 3.00 seconds.

Using macros in Emacs

Wed, 29 Jul 2020 08:51:00 +0000

Related pages
- Emacs

Emacs macros allows us to record sequence of keyboard keystrokes, mouse actions, menu actions that is bound to an Emacs command. It allows us to record these actions and repeat them when needed.

Creating a new macro#

C-x ( starts recording a macro
C-x ) stops recording a macro
C-x e executes the macro
C-u 37 C-x e executes the macro 37 times
C-u 0 C-x e executes the macro an infinite number of times until EOF.

Testing#

Create a macro to remove the - from the following fruit list and replace it with an + (org-mode has still already setup, but for learning purpose, let’s do it with a macro).

Data and Reality: A Timeless Perspective on Perceiving and Managing Information in Our Imprecise World

Mon, 13 Jul 2020 07:28:00 +0000

Related pages
- Database
- Computer Science

READING Data and Reality: A Timeless Perspective on Perceiving and Managing Information in Our Imprecise World#

Table 1: Clock summary at [2020-07-13 Mon 08:05]

Headline	Time
Total time	1:01
Data and Reality: A Timeless…	1:01

:BOOK_CATEGORY: Database, software architecture, software engineering :BOOK_AUTHORS: William Kent :START_DATE:<2020-07-12 Sun> :END_DATE: nil :URL: https://www.goodreads.com/book/show/19305264-data-and-reality

Methodologies

Tue, 23 Jun 2020 09:50:00 +0000

Software Engineering

Tue, 23 Jun 2020 09:50:00 +0000

tags: Programming Computer Science

Use case template

Tue, 23 Jun 2020 09:49:00 +0000

tags: Computer Science Programming Methodologies Software Engineering

The following is a requirements template developed by Alistair Cockburn. This template may or may not have all or more fields related to the requirements itself.

USE CASE #N
Goal in context
Scope
Level	<one of: Summary, Primary task, Subfunction>
Preconditions
Success end condition
Failed end condition
Primary actor	<a role name for the primary actor, or description>
Trigger	<the action upon the system that starts the use case, may be time event>
Priority	<how critical to your system/organization>
Frequency

Go interfaces

Mon, 22 Jun 2020 20:26:00 +0000

tags: Go Programming Programming Code snippets

The following implements a DataModel, like Django’s Model class which requires Validate and Save methods be implemented by whoever uses that Interface. The problem is the Model. m object will be nil, because Model cannot access the User due to the embedded Model struct within the User struct.

package main

import "fmt"

type DataModel interface {
	Validate()
	Save()
}

type Model struct {
	DataModel
}

func (m *Model) Validate(){
	fmt.Println("Validating..", m)
}

func (m *Model) Save(){
	fmt.Println("Saving..", m)
}

type User struct {
	name string
	Model
}

func main(){
	user := &User{name: "Benjamin"}
	fmt.Println(user)
	user.Validate()
	user.Save()
}

&{Benjamin {<nil>}}
Validating.. &{<nil>}
Saving.. &{<nil>}

Database

Sun, 21 Jun 2020 03:24:00 +0000

Notes from Data and Reality: A Timeless Perspective on Perceiving and Managing Information in Our Imprecise World

William tries to approach data towards how we perceive the world. The following key concepts can be considered in data modeling as to our inner domain.

Existence: To what extend are you really present and engaged in the process of life around yourself? How real are the physical things around you?
Identity: Who are you? What is the true nature that identifies you?
Attributes: What kind of person are you? What are your values, assets and so on.
Relationships: What are the qualities of your interactions with parents, friends, lovers, etc? What are your connection with things material, social, and otherwise? What are your needs? What are the issues and problems?
Behavior: What should you plan to do in various situations? What might be the consequences, both indented and not indented?
Modeling: How useful and accurate are the constructs you use to explain all these things? How effective are these kinds of explanation in helping you change what needs to be changed?

Postgres

Sun, 21 Jun 2020 03:22:00 +0000

List Foreign key constrants defined in a database

Sun, 21 Jun 2020 03:20:00 +0000

tags: Programming Code snippets Postgres Postgres

View foreign key constrants defined in all databases

select kcu.table_schema || '.' ||kcu.table_name as foreign_table,
 '>-' as rel,
 rel_tco.table_schema || '.' || rel_tco.table_name as primary_table,
 string_agg(kcu.column_name, ', ') as fk_columns,
 kcu.constraint_name
from information_schema.table_constraints tco
join information_schema.key_column_usage kcu
 on tco.constraint_schema = kcu.constraint_schema
 and tco.constraint_name = kcu.constraint_name
join information_schema.referential_constraints rco
 on tco.constraint_schema = rco.constraint_schema
 and tco.constraint_name = rco.constraint_name
join information_schema.table_constraints rel_tco
 on rco.unique_constraint_schema = rel_tco.constraint_schema
 and rco.unique_constraint_name = rel_tco.constraint_name
where tco.constraint_type = 'FOREIGN KEY'
group by kcu.table_schema,
 kcu.table_name,
 rel_tco.table_name,
 rel_tco.table_schema,
 kcu.constraint_name
order by kcu.table_schema,
 kcu.table_name;

Returns

Go reading struct tag

Sun, 21 Jun 2020 03:02:00 +0000

The following code reads a specific struct Tag by name.

import (
	"reflect"
	"strings"
	"fmt"
)

type Profile struct {
	Id int `validate:"numeric" json:"id"`
	First string `validate:"required" json:"first"`
	Last string `validate:"required" json:"last"`
	Birth string `validate:"required" json:"birth"`
	Sex string `validate:"required" json:"sex"`
	MaritalStatus string `validate:"required" json:"marital_status"`
	Children int `validate:"numeric" json:"children"`
}

func GetStructFieldValidators(data interface{}) map[string][]string {
	v := reflect.ValueOf(data)
	t := reflect.TypeOf(data)

	validators := make(map[string][]string)
	for i := 0; i < v.NumField(); i++ {
		validators[strings.ToLower(v.Type().Field(i).Name)] = []string{t.Field(i).Tag.Get("validate")}
	}
	return validators
}

func main() {
	for k, v := range GetStructFieldValidators(Profile{}){
		fmt.Println(k, v)
	}
}

id [numeric]
first [required]
last [required]
birth [required]
sex [required]
maritalstatus [required]
children [numeric]

Go defer

Fri, 19 Jun 2020 09:47:00 +0000

tags: Go Programming Programming

import "fmt"

func trace(name string) string {
	fmt.Println("Entering ", name)
	return name
}

func un(name string) string {
	fmt.Println("Exiting", name)
	return name
}

func a() {
	defer un(trace("a"))
	fmt.Println("Hello, world")
}

func b(){
	defer un(trace("b"))
	fmt.Println("Before i < 10 loop")
	for i:=0 ; i < 10; i++{
		defer fmt.Println("i =", i)
	}

	fmt.Println("After i < 10 loop")
}

func main(){
	a()
	b()
}

Entering a
Hello, world
Exiting a
Entering b
Before i < 10 loop
After i < 10 loop
i = 9
i = 8
i = 7
i = 6
i = 5
i = 4
i = 3
i = 2
i = 1
i = 0
Exiting b

Antifa

Mon, 15 Jun 2020 09:09:00 +0000

tags: Politics

HOLD Antifa: The Anti-Fascist Handbook#

Table 1: Clock summary at [2020-06-15 Mon 09:11]

Headline	Time
Total time	0:00

:BOOK_CATEGORY: politics :BOOK_AUTHORS: Mark Bray :START_DATE: nil :END_DATE: nil :URL: https://www.amazon.com.br/Antifa-Anti-Fascist-Handbook-Mark-Bray/dp/1612197035

Weed

Sat, 06 Jun 2020 04:21:00 +0000

tags: Politics

Selling weed literally went from major felony to essential business (open during pandemic) in much of America & yet many are still in prison. Doesn’t make sense, isn’t right.
— Elon Musk (@elonmusk) June 6, 2020

Org-roam

Thu, 04 Jun 2020 08:51:00 +0000

Ox-hugo export all roam to Hugo

Thu, 04 Jun 2020 08:39:00 +0000

Export all org-roam files to Hugo markdown (this might take some time)

From: jethrokuan/dots

(defun benmezger/org-roam-export-all ()
 "Re-exports all Org-roam files to Hugo markdown."
 (interactive)
 (dolist (f (org-roam--list-all-files))
 (with-current-buffer (find-file f)
 (when (s-contains? "SETUPFILE" (buffer-string))
 (org-hugo-export-wim-to-md)))))

Adding an empty #+SETUPFILE: forces benmezger/org-roam-export-all to export the file.

Emacs

Thu, 04 Jun 2020 08:36:00 +0000

Org-mode

Thu, 04 Jun 2020 08:35:00 +0000

Org-roam export backlinks on Hugo

Thu, 04 Jun 2020 08:29:00 +0000

❗️*Note:* This no longer applies (probably due to an upstream update). See the following note for another approach: Export org-roam backlinks with Gohugo

Insert roam backlinks URL when exporting orgmode to HTML

From: jethrokuan/dots

 (defun benmezger/org-roam-export-all ()
 "Re-exports all Org-roam files to Hugo markdown."
 (interactive)
 (dolist (f (org-roam--list-all-files))
 (with-current-buffer (find-file f)
 (when (s-contains? "SETUPFILE" (buffer-string))
 (org-hugo-export-wim-to-md)))))
 (defun benmezger/org-roam--backlinks-list (file)
 (when (org-roam--org-roam-file-p file)
 (mapcar #'car (org-roam-db-query [:select :distinct [from]
 :from links
 :where (= to $s1)
 :and from :not :like $s2] file "%private%"))))
 (defun benmezger/org-export-preprocessor (_backend)
 (when-let ((links (benmezger/org-roam--backlinks-list (buffer-file-name))))
 (insert "\n** Backlinks\n")
 (dolist (link links)
 (insert (format "- [[file:%s][%s]]\n"
 (file-relative-name link org-roam-directory)
 (org-roam--get-title-or-slug link))))))
 (add-hook 'org-export-before-processing-hook #benmezger/org-export-preprocessor))

Communication

Tue, 02 Jun 2020 08:55:00 +0000

Politics

Tue, 02 Jun 2020 08:52:00 +0000

Coding Theory

Sun, 31 May 2020 16:10:00 +0000

Source encoding#

Say Alice and Bob want to communicate with each other over some cable. They both live far from each other, so they decided to run a wire between both of their houses. Their communication has been working fine until winter. When winter arrived, lots wind noise started to happen and they are unable to communicate with each other over their cable communication system. With the wind, it becomes impossible to hear the signal over the noise.

Code snippets

Sun, 31 May 2020 14:28:00 +0000

Python run HTTP server locally#

1

python -m http.server 8000 --bind 127.0.0.1

Binary calculation

Sun, 31 May 2020 13:06:00 +0000

The b before the code blocks mean binary number, to avoid confusion

Binary Addition#

Possibilities#

A	OP	B	\=
1	+	1	10
1	+	0	1
0	+	1	1
0	+	0	0
1	+	1+1	11

Carry is involved whenever we have a result larger than bin 1

Binary multiplication#

Possibilities#

A	OP	B	\=
0	*	0	0
1	*	0	0
1	**	1	1

Binary subtraction#

Possibilities#

A	OP	B	\=
0	-	0	0
1	-	0	1
1	-	1	0
0	-	1	(borrow 1 from the next column 10 - 1) = 1)

Math

Sun, 31 May 2020 13:06:00 +0000

Python

Sun, 31 May 2020 13:04:00 +0000

tags: Computer Science Programming

Compiler

Sun, 31 May 2020 13:03:00 +0000

Syntax Analysis#

Syntax analysis happens after the Lexical phase, and it is responsible for detecting syntax errors.

Grammar#

Be design, computer languages have defined structure of what constitutes a valid program. in Python, a program is made up of functions/classes/imports, a function requires declarations and/or statements and so on. In C, a valid program needs to have a least a function called main, otherwise the GNU’s linker is unable to link the program.

Computer Architecture

Sun, 31 May 2020 13:01:00 +0000

RISCV

Sun, 31 May 2020 12:37:00 +0000

Understanding RISCV stack pointer#

L06 RISCV Functions(6up).pdf #

Exceptions#

Exception are unusual condition occurring at run time associated with an instruction in the current RISCV thread. Exceptions may be converted to traps, but that all depends on the execution environment.

Traps#

Trap refers to the synchronous transfer control to a trap handler caused by an exceptional condition occurring within a RISC thread. Trap handlers normally execute in a more privilege environment.

Thesis

Sun, 31 May 2020 12:35:00 +0000

C programming

Sun, 31 May 2020 12:33:00 +0000

Tags: Computer Science Programming

C project architecture guidelines#

Functions exposed in the header are like public methods#

Think of each module like a class. The functions you expose in the header are like public methods. Only put a function in the header if it part of the module’s needed interface.

Avoiding circular module dependencies#

Avoid circular module dependencies. Module A and module B should not call each other. You can refactor something into a module C to avoid that.

Programming

Sun, 31 May 2020 12:33:00 +0000

Go Programming

Sun, 31 May 2020 12:31:00 +0000

tags: Programming Computer Science

Related notes: Interesting Golang libraries

Packages#

In Go, programs start running in package main. Package names are defined by the last element of the import path: import math/rand has files which begin with the package rand. Packages consists of a bunch of .go files.

Package identifiers (functions, variables, struct and other data), may be used in other packages, with a few exceptions. Go allows only exported identifiers to be called after the package import. An exported identifier is any identifier which the first character starts in UPPER CASE. Any identifier which starts with a lower case letter is not exported.

Computer Science

Sun, 31 May 2020 12:29:00 +0000

Operating Systems

Sun, 31 May 2020 12:29:00 +0000

OS Kit#

The OSKit is a framework and a set of 34 component libraries oriented to operating systems, together with extensive documentation. By providing in a modular way not only most of the infrastructure “grunge” needed by an OS, but also many higher-level components, the OSKit’s goal is to lower the barrier to entry to OS R&D and to lower its costs. The OSKit makes it vastly easier to create a new OS, port an existing OS to the x86 (or in the future, to other architectures supported by the OSkit), or enhance an OS to support a wider range of devices, file system formats, executable formats, or network services. The OSKit also works well for constructing OS-related programs, such as boot loaders or OS-level servers atop a microkernel

Integral Calculus

Sun, 31 May 2020 13:05:00 +0200

tags: Math

These are the two ways we commonly think about definite integrals: they describe an accumulation of a quantity, so the entire definite integral gives us the net change in that quantity.¹

Why Integral Calculus#

Figure represents 2 graphs of y = cos(x). Let’s say we would like to calculate the area of $( x_1 )$ . We could calculate the area by aproximation, for example, Graph B is filled with the area we would like to calculate, so we could divide this area by equal sections of $\Delta x_n$ from a to b rectangles, then we could calculate the area of these rectangles by $f(x_i) * \Delta x_n$ where $f$ is the area of each of the rectangles. We do this for each rectangle then sum them up: $\sum_{i=1}^n f(x_i) * \Delta x_n$. This will give us an approximation of our area, we could have a better approximation by having our $\Delta x_n$ smaller, but this implies that our n becomes bigger and bigger. The smaller $\Delta x_n$ gets, the more n approaches infinity.

Socratic questioning

Sun, 31 May 2020 10:16:00 +0000

tags: Thinking methods Mindset Mental models Learning

Socratic questioning is one of many Mental models allows us to pursue thoughts in many directions and establish first principles through strict analysis. It allows us to establish truth and separate knowledge from ignorance by reveling underlying assumptions. The method allows us to explore complex ideas and find the truth out of things while opening up issues and problems.

Key principles of the method#

Identifying principles of thinking and cut through dogma and shared belief
Open up issues and problems
Explore complex ideas and find the truth out of things
Reveals underlying assumptions
Separates knowledge from ignorance
Uses to establish truth
Establish first principles through strict analysis
Pursue thoughts in many direction

Using the process#

Clarify your thinking and explaining the origins of your idea
- Why do I think this?
- What exactly do I think?
Questioning the original question
- Why did I think that?
- Was I correct?
- What conclusions can I draw from the reasoning process?
Challenging assumptions
- How do I know this is true?
- What if you think the other way around?
Looking for evidence
- How can I back this up?
- Is there any research made on this?
- What are the sources?
Consider alternative perspectives
- What might others think?
- How do I know I am correct?
Examining consequences and implications
- What if I am wrong?
- What are the implications and consequences if I am wrong?

Mental models

Sun, 31 May 2020 01:30:00 +0000

« You only think you know, as a matter of fact. And most of your actions are based on incomplete knowledge and you really don’t know what it is all about, or what the purpose of the world is, or know a great deal of other things. It is possible to live and not know. »

– Richard Feynman

Parrish, Shane. The Great Mental Models Volume 1: General Thinking Concepts (p. 12). Latticework Publishing Inc.. Kindle Edition.

Mindset

Sun, 31 May 2020 01:24:00 +0000

Learning

Sun, 31 May 2020 01:23:00 +0000

Thinking methods

Sun, 31 May 2020 01:19:00 +0000

tags: Learning Mindset Mental models

Thinking methods are techniques where we can get better at solving complex problems and having a clearer view of the problem. It allows us to thought experience and running towards reality instead of away from. Understanding must constantly be tested against reality and updated accordingly. We can break problems into sub-problems so we can better view reality.

Prevents failure from interacting with reality

Figure 1: Mindmap of thinking methods

Interesting Golang libraries

Sat, 30 May 2020 20:33:00 +0000

Related pages
- Go Programming

Entered on [2020-05-27 Wed 21:36]

<~/workspace/commit-validator/requirements.txt>

Abortion

Sat, 30 May 2020 20:09:00 +0000

Related pages
- Politics

Abortion should be legal, safe and rare

Media

Sat, 30 May 2020 20:08:00 +0000

Related pages
- Politics

Mídia - Noam Chomsky#

Duas concepções diferentes de democracia#

Uma sociedade democrática é aquela em que o povo dispõe de

condições de participar de maneira significativa na condução de seus assuntos pessoais e na qual os canais de informação são acessíveis e livres

O povo deve ser impedido de conduzir seus assuntos pessoais e os

canais de informação devem ser estreita e rigidamente controlados

Essa é a concepção predominante
Primeiras revoluções democráticas na Inglaterra do século XVII (17) expressam em grande medida esse ponto de vista

Primeira operação de propaganda governamental#

Governo de Woodrow Wilson #

Presidente dos Estados Unidos em 1916#

Plataforma “Paz sem Vitória”

Na batalha contra o coronavirus, faltam lideres a humanidade

Sat, 30 May 2020 20:06:00 +0000

Related paged
- Politics

<2020-04-01 Wed 22:23>#

O verdadeiro antídoto para epidemias não é a segregação, mas a cooperação.

<2020-04-01 Wed 22:28>#

Isso porque a melhor defesa que os humanos têm contra os patógenos não é o isolamento, mas a informação. A humanidade tem vencido a guerra contra as epidemias porque, na corrida armamentista entre patógenos e médicos, os patógenos dependem de mutações cegas, ao passo que os médicos se apoiam na análise científica da informação.

Alice in wonderland: The complete collection

Sat, 30 May 2020 20:05:00 +0000

<2020-03-07 Sat 03:33>#

Why, there’s hardly enough of me left to make one respectable person!”

<2020-03-13 Fri 01:10>#

at least I know who I was when I got up this morning, but I think I must have been changed several times since then.’

<2020-03-14 Sat 00:29>#

‘they’re sure to kill it in a day or two: wouldn’t it be murder to leave it behind?’

<2020-03-25 Wed 00:39>#

‘In most gardens,’ the Tiger-lily said, ‘they make the beds too soft — so that the flowers are always asleep.’

Nonviolent communication: A language for life

Sat, 30 May 2020 20:04:00 +0000

READ Nonviolent Communication: A language for life#

Table 1: Clock summary at [2020-06-06 Sat 03:49]

Headline	Time
Total time	8:12
Nonviolent Communication: A language…	8:12

CLOSED: [2020-05-14 Thu 09:18]

:BOOK_CATEGORY: psychology :BOOK_AUTHORS: Marshall B. Rosenberg :START_DATE: <2020-04-14 Tue> :END_DATE: <2020-05-14 Thu> :URL: https://www.goodreads.com/book/show/560861.Non%5FViolent%5FCommunication

The great mental models: General thinking concepts

Sat, 30 May 2020 20:03:00 +0000

READ The Great Mental Models: General Thinking Concepts#

Clean code

Sat, 30 May 2020 20:01:00 +0000

NEXT Clean Code#

Clean architecture

Sat, 30 May 2020 20:00:00 +0000

HOLD Clean Architecture#

Operating systems: Internals and design principles (9th edition)

Sat, 30 May 2020 19:58:00 +0000

Related pages
- Computer Science
- Operating Systems

READING Operating Systems: Internals and Design Principles (9th Edition)#

Table 1: Clock summary at [2020-06-06 Sat 03:47]

Headline	Time
Total time	3:24
Operating Systems: Internals and…	3:24

Exercises#

1.1. CPU: Takes care of processing data Main memory: Volatile memory for storing data and program instructions Secondary storage: Non-volatile for permantely storing data. I/O: External peripherals such as USB drive, printer and etc.

1.2. Memory address register (MAR): specifies the memory address for the next read or write. Memory buffer register (MBR): contains data to be written to memory or receives data read from memory.

The Pragmatic programmer: from journeyman to master

Sat, 30 May 2020 19:57:00 +0000

READING The Pragmatic Programmer: From Journeyman to Master#

Table 1: Clock summary at [2020-06-23 Tue 09:01]

Headline	Time
Total time	10:04
The Pragmatic Programmer: From…	10:04

:BOOK_CATEGORY: Computer science, software architecture, software engineering :BOOK_AUTHORS: Andy Hunt, David Thomas :START_DATE: <2020-05-25 Mon> :END_DATE: nil :URL: https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X

Org-roam Firefox bookmark

Sat, 30 May 2020 19:30:00 +0000

tags: Org-mode Emacs Org-roam

Org-roam has roam-protocol, which we can call throughout the system just like Org-mode Firefox bookmarks.

Org-roam protocol supports specifying the roam template to use. Template is the template key for a template in org-roam-capture-ref-templates. More documentation on the templating system can be found here.

These templates should contain a #+ROAM_KEY: ${ref} in it.

`Roam-ref` protocol#

Find and creates from with a specific ROAM_KEY

javascript:location.href =
'org-protocol://roam-ref?template=r&ref='
+ encodeURIComponent(location.href)
+ '&title='
+ encodeURIComponent(document.title)

Org-mode Firefox bookmarks

Sat, 30 May 2020 19:22:00 +0000

tags: Org-mode Emacs

Add the following scripts to call org-capture from Firefox

Call capture template#

The following calls capture template key n

javascript:location.href='org-protocol://capture?template=n'+'&url='+encodeURIComponent(window.location.href)+'&title='+encodeURIComponent(document.title)+'&body='+encodeURIComponent(window.getSelection());

Without a capture template#

If unspecified, the template key is set in the variable org-protocol-default-template-key. The following template placeholders are available:

%:link The URL
%:description The webpage title
%:annotation Equivalent to [[%:link][%:description]]
%i The selected text

See: https:orgmode.org/manual/The-capture-protocol.html#The-capture-protocol

List of Spotify artists

Sat, 30 May 2020 18:56:00 +0000

Artists
Lana Del Rey
Slipknot
CocoRosie
Papir
Jungbluth
Winds of Plague
Billy Talent
Russian Circles
Neversleep
Serj Tankian
Annotations Of An Autopsy
Circular
Hollywood Undead
Ocean of Grief
Rosetta
Darude
Mos Def
Amenra
The Game
POWERS
Keny Arkana
Cartola
The Stranglers
Armin van Buuren
Sting
Kavinsky
Snowmine
Linde Schöne
Molotov Solution
Skazi
Grave Miasma
Pathology
CHO
Klint
Mc João
Alpinist, Masakari
Mässmörd
Mano Brown
Passenger
Seu Jorge
Oliver Schories
Wolfbrigade
Tim Maia
Machine Head
La Gossa Sorda
Shpongle
Paul Kalkbrenner
Carpathian Forest
Impending Doom
Jonas Mantey
After The Burial
Calle 13
Opeth
Black Label Society
Ufomammut
Cássia Eller
Buena Vista Social Club
Muse
Weval
A$AP Rocky
Zero 7
Parkway Drive
XXXTENTACION
Uncle Acid & The Deadbeats
Gramatik
Hatebreed
CCCP – Fedeli Alla Linea
O Rappa
Tom Rosenthal
Johnny Preston
Emmure
Audialist
Motörhead
Ott
The Faceless
Bring Me The Horizon
The Kooks
Lady Gaga
Scann-Tec
Slayer
Lee DeWyze
Behemoth
Frank Sinatra
SBTRKT
RJD2
Air
Archive
Cigarettes After Sex
Aeuria
Kid Loco
Grupo Fundo De Quintal
Devendra Banhart
Dödsrit
2Pac
The Mamas & The Papas
The Blues Brothers
Alesana
Milky Chance
Dvne
DOWN
Mr. Catra
Mani
Tipper
Altarage
Sex Pistols
ZSK
Marcelo D2
Peter Joseph
YTCracker
Tribo da Periferia
Jpod
Suffokate
Dark Funeral
The Doors
Brokencyde
Post Malone
Arsonists Get All The Girls
Sarabante
Supercommuter
Thievery Corporation
Cage The Elephant
Yes-R
Britney Spears
Scorpions
Vintage Culture
DARKSIDE
Racionais MC’s
S.L.A.B.
Against Me!
Scars On Broadway
Keizer
Oasis
Bilderbuch
Deicide
Blind Witness
Miss May I
Nick Murphy / Chet Faker
Bob Marley & The Wailers
Cacife Clandestino
STRFKR
Marilyn Manson
Soviet Suprem
Kleerup
Downfall Of Gaia
Luiz Gonzaga
Extortion
Aspencat
Rage Against The Machine
Emicida
iwrestledabearonce
Esham
Moderat
Ska-P
Orishas
His Hero Is Gone
John Coltrane
See You Next Tuesday
Modeselektor
Marduk
Immortal
Zero Cult
Novos Baianos
Neutral Milk Hotel
1200 Micrograms
Dead by April
Puscifer
Kings of Leon
Mike Love
Tom Odell
DECASIA
SOJA
As I Lay Dying
Irie Révoltés
TOOL
Bad Religion
Metallica
Decibel
Wu-Tang Clan
Yung Buda
De Leve
Criolo
Carbon Based Lifeforms
Conjurer
Auroch
Nancy Sinatra
Burning The Masses
Lamb of God
Izah
Thriftworks
Despised Icon
Moby
Damian Marley
The Clash
Morrow
Lo-Pan
Mac DeMarco
Disturbed
Howling
Oranssi Pazuzu
alt-J
Heaven In Her Arms / Aussitot Mort
Intifada
Bezerra Da Silva
Sonic Boom Six
leon chang
Alaskan
Thy Art Is Murder
MC Guime
Kevcody
The xx
Weezer
Marconi Union
Planet Hemp
Kick Bong
Clear Conscience
Ultraje a Rigor
Kings of Convenience
Joy Division
Ação Direta
Angus MacRae
Louise Attaque
A Perfect Circle
laCasta
I Declare War
Big Brother & The Holding Company
Disfiguring The Goddess
As Blood Runs Black
Iron & Wine
Hymn
Ir Sais
Janis Joplin
Martyrdöd
NOFX
Chelsea Grin
Attila
Lost in Kiev
Fatboy Slim
King Conquer
Cruciamentum
Elza Soares
Hol Baumann
Adele
Deaf Radio
Abominable Putridity
Coldplay
Electric Wizard
De Dijk
The Prodigy
AWOLNATION
Carnifex
Mv Bill
Body Void
Oi Polloi
Queens of the Stone Age
Darvin
MC Cidinho
Nightmares On Wax
Daft Punk
DuvelDuvel
The Black Dahlia Murder
Insane Clown Posse
Fall Of Efrafa
Younger Brother
Glass Animals
Think of One
Joe Byrd & The Field Hippies
U2
Whitechapel
James Blake
Telefon Tel Aviv
Imagine Dragons
Haikaiss
Alceu Valença
Deep Purple
Bijou
Ratatat
René Osmanczyk
Gabriel O Pensador
Optimus Rhyme
Noorvik
Scott Bradlee’s Postmodern Jukebox
Lange Frans
Eiffel
Light Bearer
Job For A Cowboy
Areski Belkacem
Hallucinogen
The Offspring
Black Sabbath
The Police
Phaeleh
Asura
Art Of Burning Water
Victims
Stick Figure
Sonic Youth
Anopheli
Hundred Year Old Man
Bleed From Within
Jonna Fraser
Sabotage
System Of A Down
Fever Ray
Stromae
Hemelbestormer
Tycho
August Burns Red
Ali B
Gentleman
Rose Funeral
B.B. King
Bluetech
Ancst
Sacha Robotti
Martin Garrix
Soulfly
Young And In The Way
Animals As Leaders
Vomitory
The Who
Foals
Massive Attack
James Murray
Tragedy
Emancipator
Suicide Silence
Sepultura
Ventania.records
Hogni
Eric Clapton
Otto
Infected Mushroom
O Surto
Exaltasamba
Atomikylä
Rise Against
Toots & The Maytals
Chelsea Wolfe
Ozzy Osbourne
Dimmu Borgir
Black Pumas
The Digital Connection
Paul Jebanasam
Mano Negra
20syl
AES DANA
Cell
Lykke Li
Abstracter
Beirut
Falamansa
Chinese Man
Manu Chao
Rammstein
Rancid
AC/DC
Animosity
Childish Gambino
Motivés
Grift
Tom Day
Phantom Winter
MASTER BOOT RECORD
Oceano
Easily Embarrassed
Matt Corby
Cult Of Luna
1000mods
Ventania Banda Hippie
We Lost The Sea
All Shall Perish
Solar Fields
Decasia
Zefanio
Burzum
Arctic Monkeys
Zeca Baleiro
And Hell Followed With
Putridity
Blockhead
Juventude Maldita
Rappin’ Hood
Stevie Nicks
Hef
Snoop Dogg
Bullet For My Valentine
Black Merda!
Buried Inside
Epic Mountain
Los Fastidios
Flux Pavilion
Alpinist
Johnny Hooker
blessthefall
Steinsopp
Sync24
Grupo Revelação
In The Hearts Of Emperors

Information Theory

Sat, 30 May 2020 16:14:00 +0000

Related pages
- Computer Science
- Compiler

Humans express themselves using a variations of communication, such as language, physical gestures, drawing and etc. Language allows us to take a thought and break it down to a series of chunks. These chunks are externalized using a series of signals or symbols. Informally we can think of information as some message, stored or transmitted using some medium.

Information is a collection of possible symbols. For example, the alphabet allows us to choose between symbols to create words within the current context. Everyday, we look for faster and efficient ways to transporting information across spaces.

Attaching Jira issues to commit

Sun, 24 May 2020 02:39:00 +0200

Related pages
- Git change commit author
- Programming

TLDR

Dynamically attach Jira attributes to commit body using git-hook. Check the project’s README.

The place I work at requires Jira story ID and task ID attached to the commit body. Initially, I was attaching the ID to the commit body manually, by checking either my previous commit or opening up the Jira board, however, after working some hours I was easily forgetting to attach the IDs to the commit and getting annoying having to either reword them and perhaps having to lookup Jira again.

Patching requests HTTP hooks with custom arguments

Thu, 07 May 2020 00:00:00 +0000

I am working on a project where we have lots of functions integrated with external APIs. Functions where HTTP requests get dispatched, we log the current caller’s name, headers, and data (if any) in case we need to debug anything. For example:

import logging
import requests
LOGGER = logging.getLogger("external")

def create_external_services():
 ...
 LOGGER.info(f"[func] | Request {data}")
 response = requests.post("..")
 LOGGER.info(f"[func] | Response {response.status_code} {response.text}")
 ...

def delete_external_services():
 LOGGER.info(f"[func] | Request {data}")
 response = requests.delete("..")
 LOGGER.info(f"[func] | Response {response.status_code} {response.text}")

So far so good, but it gets ugly when you have a bunch of functions logging HTTP one or multiple requests and responses.

Hello, org-mode and hugo

Sat, 25 Apr 2020 00:00:00 -0300

Hello, world! This is my first post here. This blog is created using Hugo and Emacs org-mode. I am still busy migrating my posts from Asciidoc to org-mode, so this should take a bit of time.

Finding exposed .git repositories

Mon, 30 Oct 2017 00:00:00 +0000

Developers use git to version control their source code. We all do, in fact, this blog is currently versioned by git. However, we not only use git to version control, but also to deploy applications. Usually we push new code to a remote server, where the server takes care of testing the code and then deploying the application. There are different ways of deploying an application, but this is one of them.

Notes on Linux's printk

Thu, 09 Mar 2017 00:00:00 +0000

Some of the content might be incorrect, since I am still trying to understand it thoroughly.

So I started studying the Linux Kernel more in depth, so I decided it would be nice for me to document my findings, so I can read it from time to time. I will be daily updating this post, as I am studying it everyday.

Keep in mind that I am using the x86 architecture.

Higiene e bons hábitos online

Mon, 12 Dec 2016 00:00:00 +0000

❗️*Observação:* Esse guia provavelmente se encontra defasado

Aqui se encontra bons hábitos e higiene online para manter sua privacidade e segurança online.

Gerenciando seus dados online#

Procure todos os serviços de Data Brokers (Pipl.com, e etc), e selecione opt-out (excluir).
Mantenha consciência e pense duas vezes antes de postar algo online (principalmente em serviços como Facebook, Twitter, Google e outros).
Não use o Google.com para pesquisas, como alternativa, use StartPage, DuckDuckGo, etc.
Não faça check in no Facebook/Foursquare e etc.
Verifique e ajuste suas configurações de privacidade do Facebook.
Ajuste suas configurações de privacidade da sua conta do Google.

Senhas#

Nao use senhas do tipo Constantinople, yellowtiger, etc.

Mantendo sua privacidade

Sun, 11 Dec 2016 00:00:00 +0000

❗️*Observação:* Esse guia provavelmente se encontra defasado

O intuido desse guia manter uma coleção de guias, links e pensamentos sobre a privacidade e segurança online. Nós temos em foco criar ferramentas antifascistas, contra regimes autoritários para ajudar comunidades, organizações e ativistas.

Andamos observando que muitos grupos antifascistas/ativistas, usam ferramentas como o Facebook, WhatsApp e outros para organizar seus protestos, se comunicar com amigos e familiares, porém, essas ferramentas de comunicação são apenas uma arma contra sua privacidade e não estão no seu lado.

A brief introduction to Emacs Lisp for people with programming background | lgmoneda

Mon, 01 Jan 0001 00:00:00 +0000

dots/config.el at master · jethrokuan/dots

Mon, 01 Jan 0001 00:00:00 +0000

Source: https://github.com/jethrokuan/dots/blob/0064ea2aab667f115a14ce48292731db46302c53/.doom.d/config.el#L488

The following exports all roam files to Hugo and includes backlinks pre-processor.

 (defun jethro/org-roam-export-all ()
 "Re-exports all Org-roam files to Hugo markdown."
 (interactive)
 (dolist (f (org-roam--list-all-files))
 (with-current-buffer (find-file f)
 (when (s-contains? "SETUPFILE" (buffer-string))
 (org-hugo-export-wim-to-md)))))
 (defun jethro/org-roam--backlinks-list (file)
 (when (org-roam--org-roam-file-p file)
 (mapcar #'car (org-roam-db-query [:select :distinct [from]
 :from links
 :where (= to $s1)
 :and from :not :like $s2] file "%private%"))))
 (defun jethro/org-export-preprocessor (_backend)
 (when-let ((links (jethro/org-roam--backlinks-list (buffer-file-name))))
 (insert "\n** Backlinks\n")
 (dolist (link links)
 (insert (format "- [[file:%s][%s]]\n"
 (file-relative-name link org-roam-directory)
 (org-roam--get-title-or-slug link))))))
 (add-hook 'org-export-before-processing-hook #'jethro/org-export-preprocessor))

The Go Programming Language Specification - The Go Programming Language

Mon, 01 Jan 0001 00:00:00 +0000

For an operand x of type T, the address operation &x generates a pointer of type *T to x. The operand must be addressable, that is, either a variable, pointer indirection, or slice indexing operation; or a field selector of an addressable struct operand; or an array indexing operation of an addressable array. As an exception to the addressability requirement, x may also be a (possibly parenthesized) composite literal. If the evaluation of x would cause a run-time panic, then the evaluation of &x does too.

Ben Mezger

Maintaining a robust CV

A reproducible Org-Mode CV template

System Design - Databases, data models and indexing

Database#

What they are#

Relational Databases (SQL)#

Non Relational Databases (NoSQL)#

NewSQL Databases#

In-Memory Database#

Time-Series Databases (TSDB)#

Levels of consistency#

Strong consistency#

Eventual consistency#

Data Models#

Tuple (Row-Oriented)#

Documents#

Column-Oriented#

Wide-Column#

Key-Value#

Graphs#

TODO Indexing#

Page Size#

Column-base Indexing#

System Design - CAP theorem, ACID, BASE and PACELC

ACID#

Atomicity#

Consistency#

Isolation#

Durability#

BASE and Eventual State#

Basic Availability#

Soft-State#

Eventual Consistency#

CAP Theorem#

Components of CAP (C, A and P)#

Consistency (C)#

Availability (A)#

Partition Tolerance (P)#

Combination#

Consistency and Partition Tolerance (CP)#

Availability and Partition Tolerance (AP)#

Consistency and Availability (CA)#

CAP model today#

PACELC theorem#

Applying PACELC#

System Design - RAID and Storage

Storage#

Metrics and dimensions#

System Design - Network

Network protocols#

OSI model#

My journey in managing online services

My journey in managing dotfiles

NixOS important commands

Updating packages#

Anbernic RG353V: configuring ArkOS

New computer

Notes on TDD - chapter 4

Notes on TDD - chapter 3

Notes on TDD - chapter 2

Notes on TDD - chapter 1

Test driven development

Ending 2022 with Brazilian Jiu-Jitsu

Hello again, Amsterdam

Moving forward with suckless dwm

Tabs vs. spaces in byte size

Thoughts of changing nicks

Dell XPS 9510 and the linux experience

Impact on software failures

Laws of Program Evolution

Handling database migration with Pytest and SQLAlchemy

Python's name mangling

Asynchronous vs synchronous bus

Chezmoi and Emacs

Locking Python scripts with flock

The problem#

UNIX’s flock#

RISC-V Instruction Format

Notes on fault tolerant software

Components of CAP (`C`, `A` and `P`)#

Consistency (`C`)#

Availability (`A`)#

Partition Tolerance (`P`)#

Consistency and Partition Tolerance (`CP`)#

Availability and Partition Tolerance (`AP`)#

Consistency and Availability (`CA`)#

UNIX’s `flock`#

Left shift `<<`#