Technical-eBooks is a free, openly shared collection of technical eBooks for learning new technologies. It is one of the most popular repositories in the Computer Tips organization, and it gathers programming and computer-science PDFs in one place so you can browse and download what you need.
What it is
The repository collects materials for learning new technologies, with individual books ranging from about 1 MB to 25 MB. Everything is shared under the GPL-3.0 license.
VaultBox is a header-only C++ library for forward-secure, replicated, randomized, and rate-less storage and transmission of data. It builds on the Crypto++ library and is designed for highly adversarial channels where an attacker may eavesdrop on or delete messages.
At rest: the VaultBox buffer is secured with Authenticated Encryption.
In transit: data is protected with Falcon (fountain/rate-less) encoding.
Hardware (optional): secure chips such as TPM/TEE and secure memory such as ECC-RAM or persistent memory can add an extra layer (hardware API support is not implemented in the library itself).
The secure data structure
The core is a fixed-size secure buffer (DS) of size T = k x n, holding k replicas of n messages. The sender transmits it every x minutes; if the receiver does not get it in that window, that itself signals an attack or crash. Replicas are stored at random locations from a PRNG, and the buffer is initialized with noise so that occupied and empty slots are indistinguishable. To send it, the sealed buffer is split into blocks, LT-encoded, and wrapped with Authenticated Encryption; the receiver collects enough symbols to regenerate and decrypt the buffer. This gives two encryption layers: one per message (inner) and one over the whole buffer (outer).
Components
Integrity Checker: maintains a running hash of the buffer and raises an alert if the stored hash and the computed hash diverge.
Encoder / Decoder: convert buffer messages to and from Falcon symbols without changing the transmission channel.
Verifier: alerts on failed authenticated decryption, on sequence-number gaps (SequenceChecker), on mismatched replicas of the same sequence number when the replication factor is greater than one (IdentityChecker), and on failed re-verification of messages carried over from prior sessions.
Forward-secure key evolution
The outer-layer symbol key K_S is hashed forward each session, generating a nonce (via PRNG) and the inner-layer message key K_M via KeyGen(K_S). Each message derives its own encryption and HMAC keys, so compromising one session's keys does not expose earlier sessions:
For every session
K_S <- Hash(K_S)
Nonce <- PRNG(K_S)
K_M <- KeyGen(K_S)
For every message M
K_M <- Hash(K_M)
k_ENC, k_HMAC <- K_M {inner layer key}
M_AE <- AuthEnc(M, k_ENC, k_HMAC)
End For
k_ENC, k_HMAC <- K_S {outer layer key}
For every symbol S
S_AE <- AuthEnc(S, k_ENC, k_HMAC)
End For
End For
SEO-Analysis is a small open-source Python script that gathers SEO insights for a set of domains and keywords. It is spreadsheet-driven, so you do not have to touch the code: you list what you want to check in an Excel file, run the script, and it writes the insights back into the spreadsheet.
How to use it
Open Test.xlsx.
Add your keywords and domains, one pair per row. You can repeat the same domain on multiple rows with a different keyword each time.
Save Test.xlsx.
Run the Python script.
The script fills the spreadsheet with the insights for each keyword and domain.
Pair it with Links-Extractor
For SEO work it pairs well with Links-Extractor, which pulls all the internal and external links from a URL.
MP3-Stereo-Analyzer is a Python tool that checks whether your MP3 files are correctly formatted to play in both earbuds. It is published on PyPI and catches a frustrating, common problem: a track where one earbud plays only the music and the other only the vocals, or where the channels are phase-inverted and cancel out.
Installation
pip install mp3-stereo-analyzer
It needs FFmpeg for audio decoding:
brew install ffmpeg # macOS
Usage
# Analyze a single file
mp3-stereo-analyzer your_file.mp3
# Analyze every MP3 in a folder
mp3-stereo-analyzer *.mp3
# Detect AND fix files that play different audio in each ear
mp3-stereo-analyzer --fix your_file.mp3
# Compare versions and pick the best one
mp3-stereo-analyzer --compare old.mp3 new.mp3
What it checks
The analyzer reports the format (channels, sample rate, bit depth, bitrate) and runs five tests:
Channel count: the file actually contains audio channels.
Left channel signal: the left channel is not silent.
Right channel signal: the right channel is not silent.
Stereo balance: the left and right RMS levels are within range (not heavily panned).
Channel content match: both channels carry the same material, using cross-channel correlation to catch the case where each ear hears different or phase-inverted audio that earlier per-channel checks could not detect.
Fixing a problem file
If a file fails the channel content test, run it with --fix. The tool writes a corrected copy named your_file (fixed-bothears).mp3 in which both channels carry the full left-plus-right mix, so voice and music play in both earbuds. The original is left untouched and the bitrate is preserved.
Comparing two versions
With --compare, the tool prints a side-by-side table and an overall score, then recommends the best version. The score weighs bitrate, audio bandwidth, loudness, sample rate, bit depth, healthy stereo, and a clipping penalty, treating differences below a just-noticeable threshold as ties.
Troubleshooting
If the analyzer returns PASS but you still hear only one ear on an iPhone, check iOS Settings > Accessibility > Audio/Visual > Balance (centered at 0.00), and that your adapter or Bluetooth buds are properly paired and seated.
Perf_Plotter is an open-source tool for benchmarking and visualizing the runtime performance of your application. It has two parts that work together: a logging component written in C# and a plotting utility written in R.
How it works
The workflow is simple: a Windows Forms application (C#) launches your program and records its performance metrics into a CSV file. You then upload that CSV into an R Shiny web app, which reads the data and plots it so you can see how your application behaved over the run.
What is in the project
The repository (and the Perf_Plotter.zip bundle) contains two folders and one file:
perfloggengui - the C# solution that generates the logs from your application.
Uploads - sample log files so you can try the plotter immediately.
app.R - the Shiny app you run in R to read a CSV and plot it.
Using it
Open the perfloggengui C# solution, run your application through the Windows Forms front end, and let it log metrics to a CSV.
Run app.R in R (the Shiny app starts a local web page).
Upload your CSV in the Shiny app to render the performance plots; the Uploads folder has sample CSVs to start with.
