GAURAV gauravssnl

What is this?

When you register a new domain and start hosting content there, people might not be able to view it if they're behind some kind of security software or hardware that filters by domain (e.g. web/content/DNS filters). This is because the domain is new and hasn't been categorized by the security filter, and filters commonly don't allow traffic to uncategorized domains.

Usually people can contact their security provider to request the domain to be unblocked, but:

this process can take a few days or longer
sometimes this has to be handled by IT internally and might not be escalated to the provider
- because of this, sometimes the domain will just be unblocked for a set of people (e.g. everyone at a company) and other companies have to repeat this
depending on how the filtering is implemented (e.g. how requests/responses are intercepted), websites might just appear broken instead of getting an explicit message about the website being blocked
usually this approach is reactionary, because

Zig Type System

Zig aims to be a simple language. It is not easy to define what simple exactly means, but zig is also a low-level programming language that aims for c-compatibility. To reach this goal, it needs good semantics in its type system so that developers have a complete toolbox to manipulate data.

So types in zig are composable, but this can become rapidly overwhelming. See those examples. Are you able to understand them at a glance, as soon as you read them?

*const ?u8
?*const u8
*const [2]u8

Here's a list of mildly interesting things about the C language that I learned mostly by consuming Clang's ASTs. Although surprises are getting sparser, I might continue to update this document over time.

There are many more mildly interesting features of C++, but the language is literally known for being weird, whereas C is usually considered smaller and simpler, so this is (almost) only about C.

1. Combined type and variable/field declaration, inside a struct scope [https://godbolt.org/g/Rh94Go]

struct foo {
   struct bar {
 int x;

#Unix Toolbox

This document is a collection of Unix/Linux/BSD commands and tasks which are useful for IT work or for advanced users. This is a practical guide with concise explanations, however the reader is supposed to know what s/he is doing.

##Unix Toolbox revision 14.4

The latest version of this document can be found at http://cb.vu/unixtoolbox.xhtml. Replace .xhtml on the link with .pdf for the PDF version and with .book.pdf for the booklet version. On a duplex printer the booklet will create a small book ready to bind. This XHTML page can be converted into a nice PDF document with a CSS3 compliant application (see the script example). See also the about page.
Error reports and comments are m

Moved to git repository: https://github.com/denji/golang-tls

Generate private key (.key)

# Key considerations for algorithm "RSA" ≥ 2048-bit
openssl genrsa -out server.key 2048

# Key considerations for algorithm "ECDSA" ≥ secp384r1
# List ECDSA the supported curves (openssl ecparam -list_curves)

What is a hash and how does it work

Let us start from a practical example. Imagine we are writing a traffic monitoring application. The purpose of application would be to calculate a number of bytes sent by each IP address. To do that, let create a structure that does that accounting:

struct ipstat {

uint32_t ip; /* Source IP address */

	use nix::sys::ptrace;
	use nix::sys::signal::Signal;
	use nix::sys::wait::{WaitStatus, wait};
	use nix::unistd::{fork, ForkResult, Pid};

	use std::collections::HashMap;
	use std::ffi::c_void;
	use std::os::unix::process::CommandExt;
	use std::process::{Command, exit};

	public static void main(String[] argv) throws InterruptedException {
	Executors.newVirtualThreadPerTaskExecutor().
	execute(() -> {
	System.out.print("StringList: " + stringList);
	});
	stringList = List.of("ZZ", "XX", "LL", "DDD");
	}

	// An example of implementing a method that accepts closures with different input arguments.
	// The trick to avoid Rust complaining about conflicting implementations is to specify
	// the arguments for each specialization in a separate type parameter.
	// See https://geo-ant.github.io/blog/2021/rust-traits-and-variadic-functions/

	fn main() {
	let mut foo = Foo::default();

	foo.add_fn(\|\| 0);
	foo.add_fn(\|a\| a);



	pub fn ParkingLot(comptime Config: type) type {
	return struct {
	pub const Lock: type = Config.Lock;

	pub const Event: type = Config.Event;

	pub const nanotime: fn() u64 = switch (@hasDecl(Config, "nanotime")) {
	true => Config.nanotime,