O HTML adere à norma WHATWG. Como é uma linguagem de marcação, um erro em HTML não faz com que a página web deixe de funcionar, mas o navegador apresenta-a o melhor que pode.

Ter erros em HTML é problemático, pois pode produzir falhas inesperadas e difíceis de reproduzir, especialmente quando estas ocorrem apenas num navegador. É portanto vital escrever HTML válido.

No entanto, é muito fácil cometer erros e ignorá-los. É por isso que é aconselhável validar o código HTML, ou seja, encontrar os erros e corrigi-los. Para este fim, existem validadores, que normalmente simplesmente exibem os erros. O mais actualizado e recomendado é The Nu Html Checker. O W3C mantém uma instância deste validador que nos permite validar documentos HTML a partir do navegador, quer introduzindo um URL, carregando um ficheiro ou introduzindo o código HTML num formulário. Como este validador é livre, podes instalá-lo facilmente no teu computador.

O validador em linha funciona bem se precisar de validar apenas algumas páginas web de vez em quando, mas não é adequado para validar um sítio web inteiro. Para isso recomendo a utilização da versão terminal do Nu Html Checker. Isto pode ser encontrado no ficheiro vnu.jar (Java deve ser instalado).

No meu caso, utilizo o pacote html5validator, uma vez que trabalho principalmente com Python e não requer qualquer dependência adicional. Para instalar este pacote numa distribuição GNU/Linux baseada em Debian, só precisas de correr...

sudo apt install default-jre
sudo pip3 install html5validator

Quando a instalação estiver concluída, temos um programa chamado html5validator que podemos executar a partir do terminal:

html5validator index.html

Um argumento super útil é --root, que nos permite validar todos os ficheiros de um directório, e o directório dentro do directório..., até ter validado tudo. Utilizo-o especificando o directório raiz do meu sítio web, validando todo o sítio web em poucos segundos.

html5validator --root sítio-web/

Idealmente, deverás utilizar algum tipo de integração contínua para que não tenhas de executar manualmente o comando acima sempre que mudar alguma coisa na página web. Eu utilizo o GitLab CI para isto. Desta forma, mantenho este sítio web e muitos outros livres de erros HTML, e quando quebro algo, o descubro cedo.

FFmpeg tem filtros que podem criar ruído de vídeo de forma aleatória. O filtro geq pode criar ruído de vídeo (com nullsrc como fundo branco), enquanto que o filtro aevalsrc pode criar ruído de áudio.

Assim, podemos criar um vídeo a preto e branco de 1280x720 pixels com o seguinte comando:

ffmpeg -f lavfi -i nullsrc=s=1280x720 -filter_complex \
"geq=random(1)*255:128:128;aevalsrc=-2+random(0)" \
-t 10 ruído.mkv

As linhas (ou encadeamento) de execução permitem-nos executar tarefas em simultâneo. Em Python podemos usar o módulo threading, embora existam muitos outros.

Vamos criar várias linhas de execução (threads):

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import threading
import time
import random

def sleeper(name, s_time):
    print('{} começado às {}.'.format(
        name, time.strftime('%H:%M:%S', time.gmtime())))

    time.sleep(s_time)

    print('{} terminado às {}.'.format(
        name, time.strftime('%H:%M:%S', time.gmtime())))


for i in range(5):
    thread = threading.Thread(target=sleeper, args=(
        'Linha ' + str(i + 1), random.randint(1, 9)))

    thread.start()

print('Já terminei, mas as outras linhas de execução não.')

Em primeiro lugar, importamos os módulos necessários: time, random e threading. Para criar threads só precisamos do último. Usamos time para simular uma tarefa e obter o seu tempo de início e fim; random, para fazer com que o nossa linha tenha uma duração aleatória.

A função sleeper «dorme» (não faz nada) durante o tempo que especificamos, diz-nos quando começou a «dormir» e quando acabou de «dormir». Como argumentos, passamos o nome que queremos dar à linha e o tempo que a função vai «dormir».

Depois, criamos um loop que cria 5 fios que executam a função sleeper. No threading.Thread devemos indicar a função a executar (target=sleeper) e os argumentos que queremos passar-lhe, args=('Linha ' + str(i + 1), random.randint(1, 9).

O resultado da execução é aleatório: não sabemos qual o processo que irá terminar primeiro:

Linha 1 começado às 09:16:14.
Linha 2 começado às 09:16:14.
Linha 3 começado às 09:16:14.
Linha 4 começado às 09:16:14.
Linha 5 começado às 09:16:14.
Já terminei, mas as outras linhas de execução não.
Linha 2 terminado às 09:16:17.
Linha 5 terminado às 09:16:20.
Linha 3 terminado às 09:16:21.
Linha 4 terminado às 09:16:21.
Linha 1 terminado às 09:16:22.