Como fazer hash de senhas de forma segura?

Question: Se eu fizer o hash de senhas antes de armazená-las em meu banco de dados é suficiente para evitar que elas sejam recuperadas por alguém?
Estou falando apenas da recuperação diretamente do banco de dados e não qualquer outro tipo de ataque, como força bruta na página de login da aplicação, keylogger no cliente e criptoanálise rubberhose. Qualquer forma de hash não vai impedir esses ataques.
Tenho preocupação em dificultar ou até impossibilitar a obtenção das senhas originais caso o banco de dados seja comprometido. Como dar maior garantia de segurança neste aspecto?
Quais preocupações adicionais evitariam o acesso às senhas? Existem formas melhores de fazer esse hash?
Comment: Se possível utilize o Argon2, ele foi o vencedor do PHC, possui mais opções de ajustes, se comparado ao PBKDF e ao BCrypt.
Comment: Senhas em geral são curtas, o que facilita ataques de força bruta. A função hash tem como característica ter tamanho fixo. Isso torna possível gerar todas as possíveis senhas e encontrar colisões de hash. A prática comum é aumentar a senha (com algum padding) antes de calcular o hash, assim seu mapa de hash fica assimétrico, e terá mais possibilidades em caso de ataque força-bruta. Esse padding é armazenado em outro banco de dados (separado fisica e logicamente).
Comment: Uma única vez eu fiz uma coisa assim: O usuário insere a senha no sistema, o sistema calcula o hash, após isso aplica uma criptografia baseada na cifra de Feistel com muitas rodadas (o suficiente para demorar 2~3 segundos) e armazena no banco de dados o hash criptografado. Um ataque força-bruta reversa demoraria os 2~3 segundos por tentativa, isso se o "atacante" souber sua cifra. O problema é que a validação de senha demora esses 2~3 segundos, mas o que são 2~3 segundos em troca de mais segurança.
Answer: Teoria
Hash de senhas é sempre uma defesa secundária. Um servidor que faça autenticação precisa de alguma informação para poder validar uma senha.
Um sistema simples armazena as próprias senhas literalmente, e a validação neste caso é mera comparação de strings. Neste caso, se alguém der uma mera espiada no arquivo da base de dados, já verá informação demais.
Este tipo de brecha acontece na prática. Um backup em lugar errado, um HD trocado e não apagado corretamente, uma injeção SQL, e assim vai. Veja uma discussão detalhada neste blog.
Mesmo assim, como o conteúdo de um servidor que valide senhas necessariamente inclui os dados para esta validação, alguém que tenha mera cópia destes pode fazer um ataque de dicionário offline,
tentando senhas em potencial até que alguma coincida, e este tipo de ataque é inevitável. Em sendo assim o que podemos é tentar deixar este ataque o mais difícil possível, e para isto, temos estas ferramentas:

Funções criptográficas de hash: são funções matemáticas que ao mesmo tempo que são eficientes, ninguém sabe como reverter. O servidor pode manter um hash de uma senha;
quando for fazer a comparação, basta usar o mesmo hash no segundo valor e ver se coincidem; de qualquer forma, olhando o hash não dá pra saber qual é a senha original.

Salts: uma das vantagens do atacante é o paralelismo. O atacante pega um monte de senhas protegidas com hash e quer descobrir o máximo que puder delas. Ele pode simplesmente
fazer um hash de uma senha em potencial e comparar esse mesmo hash com centenas de registros diferentes. Pode também usar tabelas de hashes pré-calculadas, incluindo as rainbow tables;
A característica de ataques com paralelismo é atuar sobre várias senhas com a mesmíssima função de hash. Usar o salt não se trata de ter uma função de hash, mas uma porção delas. Idealmente cada senha deveria usar sua própria função de hash. Um salt é um modo de selecionar uma solução específica de hash entre uma grande família de funções. Se propriamente usado, pode acabar totalmente com o paralelismo.

Lentidão: computadores são cada vez mais rápidos, como teorizou Gordon Moore, co-fundador da Intel. Cérebros humanos não. A cada ano os atacantes podem testar mais e mais senhas no mesmo tempo, enquanto usuários não lembram senhas mais complexas (ou se recusam a lembrar). Para isso, podemos fazer com que hashes fiquem extremamente lentas usando funções que demandem muitas iterações.

Nós temos algumas funções criptográficas bem comuns, como MD5 e a família SHA. Construir uma função de hash usando operações elementares não é uma tarefa fácil.
Quando criptógrafos querem fazer isso, pensam profundamente, e organizam torneios onde as funções "brigam entre si violentamente".
Depois de centenas deles virando, mexendo, cutucando uma função por vários anos e não acham nada ruim pra falar dela, eles começam a admitir que, talvez, aquela função possa ser considerada mais ou menos segura.
Foi o que aconteceu na competição SHA-3. Nós temos que usar este meio de construir estas funções por não conhecermos jeito melhor.
Matematicamente não sabemos se funções seguras de hash realmente existem, o que temos são candidatas (esta é a diferença entre "não pode ser quebrada" e "ninguém sabe como quebrar").
Uma função básica de hash, mesmo segura como função de hash não é apropriada para senhas, pelo seguinte:

não usa salt, permitindo ataques paralelos (rainbow tables pra MD5 e SHA-1 podem ser obtidas gratuitamente, você não precisa nem ter o trabalho de calcular);
são muito rápidas e ficam mais e mais com o tempo. Com uma GPU razoável de mercado, a taxa de hashing é de bilhões de senhas por segundo.

Então, precisamos de coisa melhor. E mais, juntar adequadamente uma função de hash, salt e ficar iterando, não é mais simples do que projetar uma função de hash -- ao menos se você quiser um resultado seguro.
Novamente você depende de construções padrão que sobreviveram ao massacre contínuo de criptógrafos vingativos.
Funções de hash boas para senhas
PBKDF2
O PBKDF2 vem da PKCS#5. É parametrizado com contador de iterações que iniciando por 1 e não tem limite superior, um salt arbitrário sem restrição de tamanho, e o tamanho requerido de saída.
(O PBKDF2 gera uma saída de tamanho configurável), e um PRF. Na prática o PBKDF2 é sempre usado com HMAC, que é construído por sua vez sobre uma função de hash também. Quando dizemos "PBKDF2 com SHA-1", na verdade significa "PBKDF2 com HMAC com SHA-1".
Vantagens:

Já foi definido há bastante tempo, e ainda está "ileso".
Já está presente em vários frameworks (como .NET, por exemplo).
Altamente configurável (apesar de algumas implementações não permitirem a escolha do hash, como o .NET que usa apenas SHA-1).
Aprovado pelo NIST (observar a diferença entre hashing e derivação de chave; leia a seguir).
Tamanho de saída configurável (leia a seguir).

Desvantagens:

É intensivo somente pra CPU, e bem mais acessível para a GPU (o servidor é um pc normal usualmente, para tarefas usuais, enquanto o atacante pode investir mais em hardware especializado e ter vantagem com isso).
Você tem que ajustar os parâmetros por sua conta (gerar e gerenciar o salt, número de iterações etc). Há um encoding padrão para os parâmetros do PBKDF2 mas ele usa ASN.1, então as pessoas evitam sempre que podem (ASN.1 é complicado para não-experts).

bcrypt
O bcrypt foi desenvolvido reusando e expandindo elementos de um block cipher chamado Blowfish.
A contagem de iterações é uma potência de dois, que é bem menos configurável que a da PBKDF2, mas suficiente pro uso normal. Esse é o núcleo do mecanismo de hash de senhas do OpenBSD.
Vantagens:

Implementação disponível para várias linguagens (veja os links no rodapé da página da Wikipedia)
Mais "resistente" à GPU; isso graças a detalhes do seu design interno. Os autores do bcrypt fizeram desta forma voluntariamente.
Reusaram o Blowfish por este ser baseado numa tabela RAM interna que é constantemente modificada durante o processamento. Isso complica muito a vida de quem quiser acelerar o bcrypt com GPUs, pois GPUs não são boas para acessar memória em paralelo.
A saída padrão inclui o salt e contagem de iterações, simplificando em muito a armazenagem, que é de apenas uma string.

Desvantagens:

Tamanho fixo de saída: 192 bits.
Apesar de forçar as GPUs, pode ser otimizado com FPGA: Chips FPGA modernos têm blocos embutidos de RAM que são bem convenientes para rodar bcrypt em paralelo no mesmo chip. Já foi feito, inclusive.
A senha de entrada é limitada a 51 caracteres. Para senhas maiores, alguém teria que combinar o bcrypt com uma função de hash (calcula o hash da senha, e usa o resultado com bcrypt).
Combinar primitivos criptográficos tem riscos, então isto não é recomendado para uso geral.

scrypt
O scrypt é bem mais novo (projetado em 2009), baseado no PBKDF2 e num stream cipher chamado Salsa20/8. De qualquer forma, estas são apenas ferramentas em torno do núcleo que concentra a força do
scrypt, que é a RAM. O scrypt foi feito de forma a usar muita RAM (ele gera alguns bytes pseudo-aleatórios, e os lê repetidamente, numa sequência também pseudo-aleatória).
"Muita RAM" é algo difícil de paralelizar. Um PC básico é bom no acesso à RAM, e normalmente não vai tentar ler simultaneamente da RAM dezenas de bytes sem relação aparente.
Um atacante com GPU ou FPGA pode querer fazer isso, mas terá dificuldade.
Vantagens:

Um PC, ou seja, o que o defensor vai usar pra aplicar o hash normalmente, é uma das melhores (senão a melhor) plataforma para operar o scrypt.
O atacante não tem mais vantagem investindo em GPU ou FPGA.
Uma opção a mais de ajuste: uso de memória.

Desvantagens:

É novo ainda (minha "regra pessoal" é de aguardar ao menos 5 anos de exposição -- mas, é claro, é bom que outras pessoas usem o scrypt em produção, para dar maior visibilidade).
Não tem tantas implementações à disposição para as diversas linguagens.
Não está claro qual o ideal de CPU e RAM a usar. Pra cada acesso pseudo-aleatório o scrypt precisa computar um hash, um cache miss gasta 200 ciclos, uma chamada de SHA-256 gasta 1000. Há espaço para melhorias nesse aspecto.
Uma opção a mais para ajustar: quanta memória usar.

Iterated And Salted S2K do OpenPGP
Estou mencionando este, pois você vai usar se for proteger arquivos com senha usando GnuPG. Essa ferramente segue o formato OpenPGP, que define suas próprias funções de hash, chamadas "Simple S2K", "Salted S2K" e "Iterated and Salted S2K".
Apenas a terceira pode ser considerada "boa" no contexto desta resposta. É definida como uma hash de uma string longa (configurável até uns 65 megabytes) e consiste em repetição de um salt de 8 bytes e a senha.
Em linhas gerais, O "Iterated And Salted S2K" do OpenPGP é decente, similar a um PBKDF2 com menos opções. Você raramente vai encontrar essa implementação fora do OpenPGP.
"crypt" do Unix
Sistemas do tipo Unix atuais (como Linux), usam variantes iteradas e com salt da função crypt(), que é baseada em boas funções de hash, com milhares de iterações. Isso é razoavelmente bom. Alguns sistemas também podem usar bcrypt, que é melhor ainda.
A função crypt() "antiga", que era baseada no block cipher DES, não é boa:

É lenta em software, mas rápida em hardware, e ainda pode ser acelerada em software quando computando várias instâncias em paralelo (técnica conhecida como SWAR ou "bitslicing"), que é vantajoso para o atacante.
Ainda é muito rápida com 25 iterações.
Seu salt é de 12 bits, implicando em reúso frequente.
Trunca a senha a 8 caracteres e ainda trunca o bit alto, transformando em ASCII puro (7 bits).

As variantes novas, que são as que estão em uso atualmente, são OK.
Funções de hash ruins para senhas
Tudo o mais, em especial soluções caseiras que as pessoas insistem em criar, assumindo que "criptografia segura" é "jogar fora toda operação criptográfica ou não que pode ser pensada".
Veja esta pergunta como exemplo. O princípio nela parece ser de que a complexidade com a bagunça das instruções vai confundir atacantes.
Na prática, o desenvolvedor vai sempre estar mais perdido na sua própria criação do que o atacante.
Complexidade é ruim. Solução caseira é ruim. Novidade é ruim. Lembrando disso você vai evitar 99% dos problemas de hash de senhas, e segurança em geral.
Hash de senha no Windows costumava ser terrivelmente medonho, agora é só péssimo (MD4 sem salt e iterações).
Derivação de chave
Até agora nós consideramos a questão de hash das senhas. Um problema próximo é a transformação de uma senha numa chave simétrica que possa ser usada para criptografia. Isto é chamado de derivação de chave e é a primeira coisa que você faz quando encripta um arquivo com senha.
É possível fazer exemplos elaborados de funções de hash que são seguras para guardar um token de validação, mas que são péssimas para gerar chaves simétricas; o oposto é possível, da mesma maneira. Esses exemplos entretanto são artificiais. Para casos práticos como os descritos acima:

A saída de uma hash de senha é aceitável como chave simétrica, após ser truncada no tamanho requerido.
Uma função de derivação de chave pode servir como hash de senha, desde que a chave derivada seja longa o suficiente pra evitar "pré-imagens genéricas" (o atacante tem a sorte de achar uma senha que dê o mesmo resultado). Uma saída de 100 bits deve ser suficiente.

Para falar a verdade, PBKDF2 e scrypt são funções de derivação de chave, e não de hashing -- e o NIST aprova o PBKDF2 como função de derivação de chave, e não explicitamente como hasher.
(mas com um pouquinho só de hipocrisia, dá pra ler o material do NIST de maneira a se entender que o PBKDF2 é bom para hash de senhas).
Ainda, o bcrypt é na verdade um block cipher (a parte de processamento de senha é o "key schedule") que é depois usado em modo CTR para produzir três blocos de 192 bits de saída pseudo-aleatória, fazendo-o uma espécie de função de hash. O bcrypt pode virar uma função de derivação de chave com uma leve operação, usando o block cypher em modo CTR para gerar mais blocos.
Mas, como de costume, não recomentamos remendos caseiros. Felizmente 192 bits são mais que suficientes para a maioria dos propósitos (por exemplo, encriptação simétrica com GCM ou EAX só precisa de 128 bits na chave).
Considerações adicionais
Quantas iterações?
Quanto mais melhor! Essa corrida de lento-e-salted é uma disputa acirrada entre atacante e defensor.
Você usa muitas iterações para deixar o hashing mais dificil para todos.
Para aumentar a segurança, você deve deixar o número mais alto que seja tolerado no servidor, considerando as outras coisas que ele deve fazer. Quanto mais alto melhor.
Colisões e MD5
O MD5 está quebrado: é muito fácil conseguir vários pares de entradas diferentes com o mesmo valor de saída. Estas são as colisões.
Entretanto, colisões não são um problema para hash de senhas. Hash de senhas tem que resistir às pré-imagens, não colisões.
Colisões são pares que dão mesma saída sem restrições, enquanto no hash de senhas o atacante tem que achar uma mensagem que dê uma determinada saída, que ele não escolheu.
Isso é bem diferente. Até onde sabemos, o MD5 é praticamente tão forte quanto sempre foi em relação a pré-imagens (há um ataque teórico que ainda está muito distante de ser viável na prática).
O verdadeiro problema com o MD5 é que seu uso é muito comum para senhas, ele é muito rápido e não tem salt. Mas o PBKDF2 usado com MD5 seria robusto.
Você deve usar SHA-1 ou SHA-256, mas por questão de "relações públicas". As pessoas ficam nervosas quando ouvem "MD5".
Geração do salt
O objetivo fundamental do salt é ser o mais único possível. Sempre que um salt é reusado, potencialmente pode ajudar a um atacante. Por exemplo, se você usa o nome do usuário como salt, um atacante pode construir rainbow tables usando "admin" e/ou "root", pois a tabela serviria para muitos lugares que possuem usuários com esses "nomes".
Da mesma forma, quando um usuário muda a senha, o nome permanece, levando ao reúso do salt. Senhas velhas são sempre alvos de valor, pois usuários tendem a reaproveitá-las em muitos lugares. (é sempre divulgado que é péssima idéia, todo mundo sabe, mas continua fazendo porque torna a vida mais fácil), e além disso as pessoas tendem a gerar senhas sequenciais. Se a senha velha do Alaor é "SenhaSecreta37", bem capaz que a nova seja "SenhaSecreta38" ou "SenhaSecreta39".
O jeito "barato" de obter salts únicos é usar aleatoriedade. Se você gera seu salt com bytes aleatórios de um gerador seguro que seu OS ofereça, (/dev/urandom, CryptGenRandom()...) você terá valores de salt "únicos suficientemente", se forem de 16 bytes por exemplo, para nunca ver na vida uma colisão de salt.
O UUID é um jeito padrão de se obter valores "únicos". Lembrando que UUID "versão 4" usa aleatoriedade (122 bits), como mencionado acima.
Vários frameworks oferecem funções simples para gerar UUID sob demanda, e eles podem ser usados como salt
O salt tem que ser secreto?
O salt não foi feito pra ser secreto, senão seria chamado de chave. Você não precisa divulgar o salt, mas se precisar (usando uma solução de hash no cliente, por exemplo), não se preocupe.
O salt existe apenas para ser único. Não é nada mais do que a seleção de uma função de hash entre muitas.
Pepper
Criptógrafos não podem deixar uma metáfora quieta. Eles precisam estendê-las com mais analogias e trocadilhos (salt significa "sal", pepper significa "pimenta"). Se você usa uma pepper na sua função de hash, está usando uma espécie diferente de algoritmo criptográfico; você está calculando um código de autenticação de mensagem (MAC) sobre a senha. A chave do MAC é sua pepper.
"Apimentar" faz sentido se você tiver uma chave secreta que o atacante não é capaz de ler. Lembre-se de que nós usamos o hash por que consideramos que um atacante pode conseguir uma cópia da base de dados do servidor ou até o disco todo. Um caso comum é um servidor com dois discos em RAID 1. Um disco falha, por ter a placa queimada. Acontece a toda hora. O sysadmin troca o disco, o espelho é refeito, e nada é perdido graças à magica do RAID 1. Bom, mas o disco velho não funciona mais, e o sysadmin não tem mais uma maneira fácil de limpar seu conteúdo, então ele simplesmente descarta o disco. O atacante encontra o disco no lixo, troca a placa e, vejam só! Ele tem uma cópia completa do sistema, com base de dados, configuração, executáveis, OS...
Para a pepper funcionar num caso desses, você precisa de algo mais que um PC com discos; você precisa de um dispositivo de segurança por hardware (HSM).
Os HSMs são caros, tanto em termos econômicos quanto operacionais, mas com um HSM, basta usar a pepper e processar as senhas com um simples HMAC (por exemplo com SHA-1 ou SHA-256). Isso vai ser muito mais eficiente que bcrypt/PBKDF2/scrypt e suas complexas iterações. Fora que usar um HSM fica com cara bem profissional numa WebTrust audit.
Hashing do lado do cliente
Como o hashing é propositalmente "caro", faria sentido numa arquitetura cliente-servidor usar a CPU do cliente. Afinal, quando 100 clientes conectam a um servidor só, coletivamente eles têm muito mais poder de processamento. Para isto, o server precisa mandar o salt para o cliente. Isso implica em mais uma ida e volta de dados, o que pode ou não ser fácil de adicionar em casos específicos. Num contexto web é mais complicado, pois o javascript sempre foi mais "anêmico" pra usar a CPU. Num contexto de senha segura remota (SRP), o hashing tem que acontecer de qualquer forma no lado do cliente.
Conclusão
Use bcrypt (há quem seja contra). PBKDF2 também não é ruim. Caso você use scrypt, vai estar "ligeiramente adiantado", com os riscos implícitos nessa expressão; mas é bom pro progresso da ciência. Ser um "crash dummy" é uma profissão honrada!

Esta é uma adaptação da excelente resposta dada por thomas pornin no site Information Security, que também faz parte da rede Stack Exchange.
Comment: Quanto a deixar o hash lento, recomento um sleep na thread de tempo aleatório, por causa de [Timing attack](http://en.wikipedia.org/wiki/Timing_attack)
Comment: @MiguelAngelo A função do hash é preveninr ataques ***offline***, o atacante que obteve uma cópia do seu BD não vai fazer também o `sleep` "por questão de honra", ele vai retirá-lo para poder testar senhas o mais rapidamente possível... Melhor manter o fator de trabalho o mais alto possível, senão **você** fica lento e seu adversário não. P.S. Concordo que *timing attack* é uma questão séria, mas não sei se se aplica ao hash de senhas. [Essa pergunta no security.SE](http://security.stackexchange.com/q/9192/6939) discute mais profundamente o assunto.
Comment: Parabéns pela medalha de ouro "Ótima resposta" dos 100 votos a favor, a primeira do site. :)
Comment: @mgibsonbr: realmente, o sleep deveria ser feito independentemente do hash ser calculado ou não. O ideal seria que todos os requests para uma página de login tivessem a mesma duração, independente das credenciais serem válidas, do hash e de quaisquer outros fatores.
Comment: @VictorStafusa grato, mas essa aí temos que considerar que o trabalho significativo mesmo foi do autor original ;)
Comment: @mgibsonbr Tem outros ajustes que fiz no meio também, é uma adaptação, e não uma tradução 100%. Esse link que você passou também faz referência ao mesmo artigo que "Morreu", acho que por hora vou usar ele como substituto, pois menciona alguns pontos. Vou ver no webarchive antes se temos o original. UPDATE: atualizei com o arquivo da Wayback Machine
Comment: Se eu fosse resumir PBKDF2, o que seria exatamente? Ao criar uma hash no estilo `$$$` ficaria: `pbkdf2$100000$16$kXNppmR0lbEoxRYXBtozKLv6KnAGQ==` ?
Comment: A definição e os requisitos do PBKDF2 estão descritos resumidamente em https://en.wikipedia.org/wiki/PBKDF2. A [implementação PBKDF2 do PHP 5.5](http://php.net/manual/en/function.hash-pbkdf2.php), por exemplo, dá a derivação de chave neste formato de 160 bits: `120fb6cffcf8b32c43e7`. Quanto a armazenar os outros parâmetros em string, como no seu exemplo, depende muito de como os valores serão usados.
Comment: O link na conclusão "há quem seja contra" está quebrado, por acaso você conhece seu conteúdo para que procuremos uma fonte alternativa? A propósito, esse link não estava na resposta original no security.SE, e embora eu não conheça seu conteúdo eu vejo [argumentos contrários a ele](https://news.ycombinator.com/item?id=3724560).
Comment: `Desvantagens: Tamanho fixo de saída: 192 bits.` >>> Eu jurava que todo hash tinha essa propriedade! +1
Comment: @Bacco atualiza a resposta para incluir o [Argon2](https://en.wikipedia.org/wiki/Argon2) e a informação que o SCrypt é vulnerável ao [cache-timing](https://github.com/pbhogan/scrypt/issues/18).
Comment: O artigo do criticismo ao `bcrypt`: http://www.unlimitednovelty.com/2012/03/dont-use-bcrypt.html?m=1
Comment: @Inkeliz vou ver uma horinha dessas pra dar uma "geral", preciso separar um tempo pra isso.
Comment: Gostei  "PBKDF2 com SHA-1", na verdade significa "PBKDF2 com HMAC com SHA-1".
Comment: Simplesmente magnifica a resposta, parabéns my king =)
Comment: @JonathasB.C. o trabalho "pesado" foi do autor original, eu apenas adaptei para o português: https://security.stackexchange.com/users/655/thomas-pornin
Answer:
Se eu fizer o hash de senhas antes de armazená-las em meu banco de dados, é suficiente para evitar que elas sejam recuperadas por alguém?

O objetivo da função de hashing é dificultar que um atacante que já obteve acesso (leitura) a seu banco de dados descubra as senhas originais. Pois para ganhar acesso online (i.e. logar como um usuário) não basta apresentar o hash como credencial: é necessário apresentar algo que - após hasheado - seja idêntico ao hash armazenado. Um bom algoritmo de hash deve portanto ser resistente a ataques de pré-imagem (i.e. dado um hash X, encontrar uma string Y tal que hash(Y) = X).
Outras características desejáveis de uma função de hash são a lentidão (aumenta o tempo gasto numa busca exaustiva; importante se - como é comum em senhas escolhidas pelo próprio usuário - a entropia das senhas é baixa) e a unicidade (ainda que dois usuários tenham a mesma senha, seus hashes sejam distintos - evita que um único ataque descubra senhas de vários usuários). Para bons algoritmos que atendam a esses requisitos, ver a resposta do @Bacco.

Estou falando apenas da recuperação diretamente do banco de dados, e não qualquer outro tipo de ataque, como força bruta na página de login da aplicação (...) Qualquer forma de hash não vai impedir esses ataques.

Na realidade, um hash bem feito tornará esse cenário específico pelo menos tão seguro quanto contra um ataque offline - pois coloca um limite inferior ao tempo necessário para se testar cada candidato a senha. Existem maneiras melhores de se proteger contra ataques online (limitar o número de tentativas de login em um determinado período de tempo, aumentar a espera e/ou bloquear o usuário após N tentativas fracassadas, etc), mas mesmo na ausência das mesmas o hash deve proteger contra ataques de força bruta.

Tenho preocupação em dificultar ou até impossibilitar a obtenção das senhas originais caso o BD seja comprometido.

Como já mencionado, o grande problema de se proteger uma senha é sua baixa entropia: existem algoritmos sofisticados para gerar bons "candidatos a senha", capazes de "adivinhar" a grande maioria das senhas tal como são escolhidas pelos usuários comuns, mas sem perder tempo explorando senhas improváveis (como pqzrwj). Quando combinados com dados pessoais do usuário em questão, seja obtido em registros públicos, seja com dados do próprio usuário (esse segundo fora do escopo da pergunta, já que é um cenário parecido com o de um keylogger), a taxa de descoberta se torna ainda maior.
Por essa razão, se uma credencial de acesso é derivada de uma senha, nada do que você fizer vai impossibilitar alguém de testar candidatos de senha até encontrar a verdadeira. Não importa o quanto seu processo de derivação seja complicado (a princípio, pensei em sugerir SRP ou HOTP/TOTP para ajudar a proteger a senha original, mas percebi que seria inútil), quando se assume que o atacante possui acesso a todos os seus parâmetros (algoritmo, salt, pepper, etc) e resultado esperado (hash, chave, etc), ele pode recuperar sua senha por força bruta.
Desse modo, impossibilitar a obtenção da senha original é inviável, resta apenas dificultar (o que é feito através de um algoritmo - não necessariamente um hash - lento). Para tornar o esquema à prova de falhas, só impedindo que o atacante ganhe acesso à informação confidencial em primeiro lugar...

Detalhe adicional: me refiro a "senhas" no sentido de "texto a ser memorizado pelo usuário"; se um sistema utiliza senhas geradas aleatoriamente e suficientemente longas (256 bits de entropia, ou 512 na presença de computação quântica), então mesmo o hash mais simples e rápido - como o MD5 - será suficiente para impedir na prática que o atacante descubra uma senha previamente desconhecida (MD5 é vulnerável a colisões, mas isso não é relevante aqui - sua resistência a pré-imagem é o que importa, e isso ainda não foi contestado).
O motivo é que, embora teoricamente ainda se possa testar candidatos até achar o certo, o número de candidatos é tão grande que não é possível fazê-lo na prática: mesmo divergindo todos os recursos do planeta (e além) para essa tarefa, a probabilidade de se achar o candidato certo permaneceria negligível.
Entretanto, esse tipo de senha costuma ser demasiado complexa para ser guardada na memória, de modo que a única maneira prática de utilizá-la é escrevendo-a em algum lugar/mantendo uma cópia em arquivo/usando um gerenciador de senhas. Nesse contexto - visto que é necessário dar proteção adicional aos dados gravados - essa credencial é mais comumente chamada de "chave", não de senha, e possui características de segurança bem distintas daquilo que chamamos no dia-a-dia de senha.

Quais preocupações adicionais evitariam o acesso às senhas? Existem formas melhores de fazer esse hash?

A "lentidão" do hash é você que escolhe: se não há problema em se esperar 1 minuto antes de se fazer o login, você pode escolher um hash que leva 1 minuto para computar num hardware "topo-de-linha". Um ataque de dicionário/força bruta a 1 tentativa por minuto dificilmente iria longe... No fim, é um equilíbrio entre confidencialidade e disponibilidade.
E quanto a providências adicionais, é importante uma "defesa em profundidade" (ex.: use um algoritmo de hash que use, ao mesmo tempo a) um valor do banco de dados; b) um valor no sistema de arquivos; c) um valor presente só na memória - informado pelo operador durante o início/restart do servidor) e o reforço de sua aplicação/servidor para prevenir ataques que dariam acesso a esses dados. Só lembrando que, quanto maior o requisito de segurança, maior o custo - então pese os riscos e as consequências antes de "fazer todo o esforço possível" ou almejar um sistema "o mais seguro possível", pois isso dificilmente seria a atitude mais sensata (ex.: o item "c" exigiria intervenção manual sempre que o servidor fosse reiniciado).
Answer: phpass - o segredo do WordPress

"Como fazer hash de senhas de forma segura?"

Quando eu tive que responder a essa pergunta na prática, há alguns anos atrás, eu fui espiar o código do WordPress. Meu pensamento era: se o mundo inteiro usa massivamente o WordPress, e não estamos mais ouvindo falar de ataques devido a vulnerabilidades de segurança no mesmo... então isso significa que a solução deles está "à prova de balas"...
E foi então que mergulhei no código do WordPress. Confesso que fiquei horrorizado com o que me parecia uma baderna. Mas também me surpreendi, estupefato, com o fato de que o WordPress não usa Session - este foi um grande aprendizado, e eu admirei muito isso. Enfim, fui destrinchando a coisa até extrair de lá o código que lida com autenticação / autorização - incluindo a geração do hash. Juntei tudo numa classe, usei em alguns projetos, e recentemente transformei num package para o Laravel.
A quem interessar, o código está no GitHub.
Porém, o peso-pesado da criptografia é realizado pelo "Portable PHP password hashing framework" (phpass).
Conhecendo apenas o necessário e suficiente sobre salt e chaves, mas mesmo sem saber os detalhes das profundezas sobre encriptação, sei que estou oferecendo aos meus clientes uma solução "top notch" - tão segura quanto a que é efetivamente usada pelo peso-pesado WordPress! :-)
Exemplos Práticos
A utilização do phpass para gerar um hash de uma senha é facílima:
$hasher = new PasswordHash();
$hash = $hasher->HashPassword( $senha );

Lembrando que é tão segura quando a geração de hash do WordPress.
Outra coisa legal é que a cada vez que a função é executada para a mesma senha, um hash diferente é gerado! Por causa disso mesmo, não é possível conferir se uma senha está correta fazendo
if ($hash_armazenado_no_bd == $hasher->HashPassword( $senha ))

Assim mesmo, para conferir se uma senha está correta é muito fácil também:
$hasher = new PasswordHash();
$correta = $hasher->CheckPassword( $senha, $hash );

No código acima, a variável $hash deve conter o hash da senha do usuário, salvo previamente no banco de dados, e obtido do mesmo.
Desse modo, graças ao open source, com o menor esforço possível satisfaço um exigente requisito de segurança, fazendo o sistema o mais seguro possível pelo menor custo possível! ;-)
Para saber mais: How to manage a PHP application's users and passwords
Comment: A propósito, a razão pela qual toda vez a função retorna um hash diferente pra mesma senha é porque a saída do bcrypt inclui o sal (gerado aleatoriamente) e o fator de trabalho. O código `if ($hash_armazenado_no_bd == $hasher->HashPassword( $senha ))` não funciona porque ele re-gera esses parâmetros, mas o que o `CheckPassword` faz por baixo dos panos é basicamente a mesma coisa - só que implementado da forma correta para o algoritmo usado.
Comment: Concordo que o phpass é uma biblioteca decente, mas conhecer alguns detalhes do seu funcionamento ainda é importante para se construir um "sistema o mais seguro possível". Por exemplo, se esse pacote for usado num PHP anterior ao 5.3.0 (e sem o patch do Suhosin) todas as garantias de segurança vão por água abaixo (pois na ausência do bcrypt ele recai sobre MD5 iterado). O fator de trabalho do algoritmo (tão importante quanto "salt e chaves") também é configurável por esse pacote (`$hash_cost_log2`), e se mal utilizado também o torna inseguro.
Comment: Mas será seguro o suficiente para estarmos descansados?
Comment: Olá! Só vi isso agora e ajudou-me MUITO!
Mas tenho ainda uma duvida... eu uso esse checkpassword assim: `include_once('DataAccess.php');
   $db = new DataAccess();
   $stored_hash = $db->getPassword();
   $correta = $hash->CheckPassword( $user_pass, $stored_hash );

   if ($correta == true){ ... }` Mas continua a dizer que a password está errada... Alguma ideia?
Answer: Resumindo:
Que aceder aos Hash pode de forma mais rápida ou mais lenta aceder às password.
Há sites com as chamadas Rainbow Tables, que são BSs de com hashs pre calculados.
No caso do SQL / MySQL / ... tem uma ferramenta "Hashcat" que ajuda a comparar hashs.
Se quiser segurança máxima, use tokens (criam aleatoriedade à password) ou certificados digitais.
Dê uma vista de olhos nos seguintes sites:
Rainbow Tables
https://www.freerainbowtables.com/
Hashcat
http://hashcat.net/oclhashcat/
Answer: Use Salt.
Isto é, uma sequência alfanumérica que só seu sistema conhece e que você adiciona às senhas antes de fazer o hash. Só isso acaba com a maioria dos ataques.
Com Salt usado corretamente até o MD5 pode ser usado com certa tranqüilidade. Melhor ainda se você usar um salt aleatório e único por usuário, guardado em separado dos hashes das senhas.
Sem salt, até os algoritmos mais complexos ficam suscetíveis a ataques de força bruta com Rainbow Tables, por exemplo.
Answer: A grosso modo eu (particularmente) crio um "salt" para concatenar com o hash, uma especie de "tempero", por exemplo;
$senhaDoUSuario = 'minhaSenhaFraca';
$salt = 's697er3z1680e6r87er2g35g6514'; //(catwalk)
$pass = sha1($senhaDoUSuario . $salt);  //Coloco sal na criptografia

echo $pass;

// Senha sem "sal", apenas criptografada
// 7cdbf96f878b6816abdecd3f564a897ab393cecd

// Resultado com sal e criptografada
// 7cdbf96f878b6816abdecd3f564a897ab393cecds697er3z1680e6r87er2g35g6514

Mesmo que o usuario mal intensionado tenha acesso a senha criptografada, ele não conseguira usar softwares ou aplicações que quebram a criptografia.

Tradução de salt do inglês: sal

Seria ideal também salvar o salt em alguma variável de ambiente para fazer a verificação.
Para a verificação você faria a comparação das hashes (variável do usuário concatenada com o salt como no exemplo acima).
Comment: @fabio adicionei um meio de fazer a verificação.
Comment: @CmteCardeal, quando você for adicionar o _fenced code block_, cuidado para não adicionar [indentação desnecessária](https://pt.stackoverflow.com/posts/88340/revisions).
Answer: Funções de hash boas para senhas
PBKDF2
O PBKDF2 vem da PKCS#5. É parametrizado com contador de iterações que iniciando por 1 e não tem limite superior, um salt arbitrário sem restrição de tamanho, e o tamanho requerido de saída. (O PBKDF2 gera uma saída de tamanho configurável), e um PRF. Na prática o PBKDF2 é sempre usado com HMAC, que é construído por sua vez sobre uma função de hash também. Quando dizemos "PBKDF2 com SHA-1", na verdade significa "PBKDF2 com HMAC com SHA-1".
Vantagens:
Já foi definido há bastante tempo, e ainda está "ileso".
Já está presente em vários frameworks (como .NET, por exemplo).
Altamente configurável (apesar de algumas implementações não permitirem a escolha do hash, como o .NET que usa apenas SHA-1).
Aprovado pelo NIST (observar a diferença entre hashing e derivação de chave; leia a seguir).
Tamanho de saída configurável (leia a seguir).
Desvantagens:
É intensivo somente pra CPU, e bem mais acessível para a GPU (o servidor é um pc normal usualmente, para tarefas usuais, enquanto o atacante pode investir mais em hardware especializado e ter vantagem com isso).
Você tem que ajustar os parâmetros por sua conta (gerar e gerenciar o salt, número de iterações etc). Há um encoding padrão para os parâmetros do PBKDF2 mas ele usa ASN.1, então as pessoas evitam sempre que podem (ASN.1 é complicado para não-experts).
Comment: Acredito que deva usar o PBKDF2 em último caso. O BCrypt, criado há muito mais tempo, ainda consegue ser melhor do que o PBKDF2. Hoje, existe o Argon2i.
Answer: Se possível utilize o Argon2, ele foi o vencedor do PHC, possui mais opções de ajustes, se comparado ao PBKDF e ao BCrypt.
Ele você pode ajustar:

Iterações: custo de tempo, mais operações serão feitas.
Memoria: custo de memoria, mais memoria será exigida.
Threads: custo por paralelismo, mais processos serão iniciados.

Você tem duas opções:

Argon2i: seguro contra ataques side-channel, os acessos à memoria não vão revelar traços da entrada atual. Isto é ideal caso esteja usando algum hardware compartilhado ou com acesso para terceiros, como em um servidor em nuvem pública.
Argon2d: totalmente vulnerável contra ataques side-channel, tal como o SCrypt. Porém, garante melhor segurança contra GPU/FPGA, uma vez que não é possível pre-computar os dados. Isto é ideal caso esteja numa plataforma segura ou que não tenha preocupações com side-channel, como em um aplicativo para Android.
Argon2id: é mais recente e é a junção dos dois acima, sendo uma solução entre os dois casos. Ele garante melhor proteção contra side-channel, comparando com Argon2d. Além disso, possui melhor proteção contra GPU, se comparado com o Argon2i. Essa opção é a melhor para todos os casos, onde existe uma preocupação com ambos os ataques.
Answer: Um exemplo bem simples. Pego uma palavra (que poderia ser uma senha) e gero o MD5 da mesma:
$ echo "teste" | md5sum
1ca308df6cdb0a8bf40d59be2a17eac1  -

Se você procurar pela string "1ca308df6cdb0a8bf40d59be2a17eac1" no Google, descobre imediatamente que ele está relacionado a palavra "teste". Os atacantes usam as chamadas "rainbow tables" que são coleções de MD5s ou SHA-1's (e outros hashes ditos seguros) com palavras conhecidas.
Por isso, um hash não é suficiente para proteger uma senha, porque os usuários usam senhas fracas e toda senha forte que já "vazou" em algum lugar, vai sendo adicionada às "rainbow tables".
A técnica básica de hash correto de senha é "salgar" a senha com um dado adicional. Por exemplo:
echo "28234892423394 teste" | md5sum
2409fe72ab7c6d335b35dc9e7090951d  -

Este MD5 você não encontra no Google. Onde você for armazenar a senha, você armazenaria as duas informações: o "salt" e o MD5:
28234892423394
2409fe72ab7c6d335b35dc9e7090951d
O "Salt" não precisa ser criptografado e é inútil para tentar descobrir a senha original a partir do hash (supondo que o hash seja bom, o MD5 já não é considerado bom). Quando o usuário digitar a senha, você concatena-a com o "salt" e recalcula o MD5. Se bater com o armazenado, prova que o usuário conhece a senha original.
Mas você não vai fazer nada disso manualmente. Toda linguagem tem funções criptográficas como bcrypt() que fazem tudo automaticamente. As outras respostas também explicam de forma extensa outras técnicas como HMAC, etc.
Comment: Isso não resolve o problema, ainda continua sendo extremamente rápido uma busca exaustiva. O salt não atrasa a computação, o tempo continua igual, a diferença é despresível ou inexistente. Isso resolve um problema e um maior continuará existindo. O BCrypt é totalmente diferente de MD5, o HMAC também não foi feito para senhas, por isso existe o PBKDF2 que usa HMAC, porém várias vezes, para tentar atrasar buscas exaustivas. Buscas exaustivas funcionam com senhas porque elas, por si, tem baixa entropia, inclusive existe o [HashCat](https://hashcat.net/hashcat/).
Comment: Além disso, se você estiver acrescentando o salt como prefixo você poderá estar anulando ele. Já que, neste caso, se o salt tiver o mesmo tamanho do bloco do MD5, você pode comprimido apenas uma vez. Isso é, você comprime o prefixo e então apenas busca a senha e compara o valor comprimido, ganhando ainda mais performance. O MD5 usa  merkle–Damgard, que seria "igual" ao CBC, por isso poderá comprimir o salt uma vez. :D


ASP.NET MVC após atualizar os pacotes o template padrão se perde?

Question: Sou novo nesta área, estou "caminhando descalço nas pedras" para aprender ASP.NET, uso o VISUAL STUDIO 2017 Community 2017 Versão 15.8.4.
Ao criar um novo projeto ASP.NET MVC o visual studio gera uma aplicação vazia com um menu.
Ao atualizar os pacotes via Console do Gerenciador de Pacotes essa aplicação perde o menu e suas funcionalidades.
Acredito que seja por conta da atualização do Bootstrap e demais scripts. Confesso que estou no escuro sem o modelo que o ASP.NET MVC cria para me orientar, já vi no site do Bootstrap que a versão atual é 4.1. Já no modelo criado com o ASP.NET MVC a versão é 3.3.7.
Ou seja, não pode atualizar os pacotes do modelo criado?
Alguém já passou por essa situação, perder a formatação da página por conta disso ?
Já pesquisei vários modelos e exemplos, mas todos que encontrei se baseiam em versões mais antigas, os modelos no site do Bootstrap estão bem diferentes.
A minha falta de experiência me diz que já devo ter a resposta mas não estou sabendo interpretá-la.
Desde já, agradeço aos amigos que puderem me dar uma direção a seguir...
Answer: A versão nova do bootstrap tem algumas break changes.
Uma alternativa é você fixar no packages.config a versão do pacote.
<code><package id="bootstrap" version="3.3.7" targetFramework="net472" allowedVersions="[3.3.7]" />
</code>
Ou atualizar o seu template conforme as novas especificações do boostrap 4.1
Comment: Obrigado pela dica Pablo!
Comment: Feito!
Adicionando essa restrição a versão do Bootstrap se mantem e o modelo criado com o ASP.NET MVC não perde a sua formatação nem seu funcionamento.
Grato pela atenção Pablo!


Will using setTimeout ensure something executes in NodeJS?

Question: I'm creating a REST backend using ExpressJS. A part of the backend allows users to upload file assets, which should only exist for 10 minutes.
It safe to use setTimeout, to delete the file after 10 minutes, or are there better ways of doing this in NodeJS? How can I ensure the file is deleted? Here is my current solution:
router.post('/upload', fileUpload.single('asset'), (req, res) => {
  // Do something with the file
  res.status(201).end();
  setTimeout(() => {
    // Delete the file
  }, 600000);
});

Answer: Your approach is not going to scale, as it will potentially create a huge number of delayed methods. Better way is to store the information about the file into some associative array (object) such as :
{ "path":"date_uploaded" }

And to check every, say, XX seconds if there is anything that needs deleting with setInterval(). I.e. go through the whole structure and see if anythign was created more then 10 minutes ago. For all such elements you delete the file and remove it from the array.
var pending = {};

router.post('/upload', fileUpload.single('asset'), (req, res) => {
  // Do something with the file
  pending[file_name] = (new Date()).getTime();
  res.status(201).end();
});

setInterval(
function(){
     // check each element of pending and see if it needs to be deleted
}, 30000);

Comment: So I just shouldn't use `setTimeout` inside `router.post`?
Comment: Well... you should not create a timeout for every file you want to delete. Create a single repetitive task that handles all of the pending files. And yes, I would launch this method  when your server starts running. If pending array is empty, this method will simply do nothing.
Comment: That makes sense. Thanks for the advice.
Comment: Don't forget to have some kind of clearup method on server startup. If your server crashes, anything that _was_ in pending will be lost, and will sit there forever.


Scala simple way to search timeStamps in a Map of timestamps

Question: I have a
val timestampOffsetMap: Map[ZonedDateTime, Int]

would like to search nearest before timeStamp( a.k.a ZonedDateTime) to getOffset
def getNearestBeforeTimeStampOffset(timeToCheck: ZonedDateTime): Int = ???

I know about sortedMap and thinking about using it, but not sure if there is a better way to solve the problem.
Also I am on scala 2.11 for collections API
Comment: Can u post an example input and what should be the output, would help me to implement and test my code
Comment: Sure, Example:
Input:
ZonedDateTime.now()
Output:
28

Usage:

       `val offset = getNearestBeforeTimeStampOffset(ZonedDateTime.now)`
Answer: Update
As Joe Pallas has pointed out, scala's default implementation of TreeMap provides essentially the same functionality as Java's NavigableMap. However, the API is quite different: on TreeMap, there are methods from, to and range, that create ranged projections of the TreeMap. On these ranged projections, the methods headOption and tailOption can be used to select elements that essentially correspond to ceil and floor-elements of a given key.
The reason why the API looks quite different (it returns entire trees instead of a single ceil/floor-elements), is that, somewhat counter-intuitively, building a ranged projection of an immutable tree is asymptotically just as expensive as retrieving a single element.
Nevertheless, I think that there is nothing wrong with using a Java collection for such a specific task, especially if the API is more intuitive. I also suspect that Java's implementation might actually be a tiny bit faster and produce less garbage (that's a speculation, I didn't measure it).

Original answer
Java standard collections provide implementations of NavigableMap, with java.util.TreeMap being one example. The NavigableMap provides methods like floorKey, floorEntry, ceilingKey and ceilingEntry, which seem to do exactly what you want:
import java.util.TreeMap
import java.time.ZonedDateTime

val tm = new TreeMap[ZonedDateTime, Int] // + add entries

def getNearestBeforeTimeStampOffset(timeToCheck: ZonedDateTime)
: Int = tm.floorEntry(timeToCheck).getValue

I'm not sure whether Scala's TreeMap provides a similar functionality, at least it's not called anything with "ceiling" or "floor" in the name. This eternally old question here also didn't point immediately to the functionality analogous to NavigableMap, so maybe it's easier to just use Java's TreeMap in this case.

To convert scala Map to java.util.TreeMap, something like this should work:
val yourMap: Map[ZonedDateTime, Int] = ???

import scala.collection.JavaConverters._
val tm = new java.util.TreeMap((yourMap.asJava : java.util.Map[ZonedDateTime, Int]))

Comment: is there an easy way to go from scala Map to Java TreeMap?
Comment: @abroy added note on conversion. It definitely should work with `JavaConverters` and maybe some type ascription here and there...
Comment: The ceiling/floor functionality for `TreeMap` is provided by `from` and `to/until` along with `headOption/lastOption`.
Comment: @JoePallas You are right. This whole `to/until`-story seems somehow eerily familiar. Indeed, I've even got a [bounty three years ago](https://stackoverflow.com/a/29731450/2707792) for an answer where I was saying exactly that: `TreeMap` provides `to` that corresponds to `floorKey` and `until` that roughly corresponds to `ceilingKey`. Do you want to post it as a separate answer, or should I update my answer? That probably shouldn't be left as just a comment...
Comment: @AndreyTyukin I'd suggest updating your answer.  It's already accepted, so the information may be easier to find the next time someone is looking for it.


Stouffer's Z-score method: what if we sum $z^2$ instead of $z$?

Question: I am performing $N$ independent statistical tests with the same null hypothesis, and would like to combine the results into one $p$-value. It seems that there are two "accepted" methods: Fisher's method and Stouffer's method.
My question is about Stouffer's method. For each separate test I obtain a z-score $z_i$. Under a null hypothesis, each of them is distributed with a standard normal distribution, so the sum $\Sigma z_i$ follows a normal distribution with variance $N$. Therefore Stouffer's method suggests to compute $\Sigma z_i / \sqrt{N}$, which should be normally distributed with unit variance, and then use this as a joint z-score.
This is reasonable, but here is another approach that I came up with and that also sounds reasonable to me. As each of $z_i$ comes from a standard normal distribution, the sum of squares $S=\Sigma z^2_i$ should come from a chi-squared distribution with $N$ degrees of freedom. So one can compute $S$ and convert it to a $p$-value using cumulative chi-squared distribution function with $N$ degrees of freedom ($p=1−X_N(S)$, where $X_N$ is the CDF).
However, nowhere can I find this approach even mentioned. Is it ever used? Does it have a name? What would be advantages/disadvantages compared to Stouffer's method? Or is there a flaw in my reasoning?
Comment: Thanks, whuber! Could you describe your simulation in more detail, I am curious. On the other hand, if $z_i$ have different signs but large absolute values, then Stouffer's method can end up with overall $z \approx 0$, whereas my method would report a VERY significant $p$. I guess in some cases it can make much more sense (and I suspect in my case it does, but I am not sure).
Comment: You are right, which is why I did not post my comment as an answer. But what kinds of situations are there where the alternatives vary so radically from the null in *both* directions, except due to chance alone?
Comment: One salient flaw that jumps out is Stouffer's method can detect systematic shifts in the $z_i$, which is what one would usually expect to happen when one alternative is consistently true, whereas the chi-squared method would appear to have less power to do so.  A quick simulation ($N=100$, $10^4$ iterations) shows this to be the case; the chi-squared method is *seriously* less powerful to detect a one-sided alternative.
Comment: The situation I had in mind is something like the one in Pearson's chi-squared test, where one is interested in whether an empirical distribution differs from the null; then deviations in either direction matter. But after giving it a second thought, I guess your intuition is correct and in my case suspicious deviations are all in one direction. If you post your comment as an answer and provide some details on your quick simulation (I am very curious why the chi-squared method turns out to be less powerful!), I will be happy to accept it.
Comment: The sum of n Z scores has a distribution with a variance of n?  Why isn't the variance the square of the standard error of the mean?  The sum of $Z^2$ as implied in the title does have a variance of N.  Maybe I'm missing something obvious?
Comment: @rpierce: variance of a sum equals to sum of variances. Variance of each z-score (under null) is 1 by definition. So the variance of the sum of $N$ z-scores equals to $N$ (and it is distributed normally). Sum of $z^2$ is distributed as chi-squared with $N$ degrees of freedom; its variance is $2N$ if I am not mistaken.
Comment: @rpierce: I am sorry, I have no idea what you mean. What is "expected variance" and what is "standard variance"? I am saying that if each $z_i \sim \mathcal{N}(0,1)$, then $\Sigma_1^N z_i \sim \mathcal{N}(0, N)$.
Comment: I'm out of my depth it seems.  I know what the simulations look like, but I'm not tracking particularly well.

I used the term "expected variance" to be what is sounds like, the variance you expect for sums of Z.  From a frequentist standpoint, if you took sums of Z (of the same size) repeatedly, you would build a sampling distribution of sums of Z, and that sampling distribution would have a variance of "expected variance", i.e. N.
Comment: I had deleted my comment right before you posted, because I realized I was out of my depth and decided it wasn't worth taking up more of your time.
Answer: One flaw that jumps out is Stouffer's method can detect systematic shifts in the $z_i$, which is what one would usually expect to happen when one alternative is consistently true, whereas the chi-squared method would appear to have less power to do so. A quick simulation shows this to be the case; the chi-squared method is less powerful to detect a one-sided alternative.  Here are histograms of the p-values by both methods (red=Stouffer, blue=chi-squared) for $10^5$ independent iterations with $N=10$ and various one-sided standardized effects $\mu$ ranging from none ($\mu=0$) through $0.6$ SD ($\mu=0.6$).

The better procedure will have more area close to zero.  For all positive values of $\mu$ shown, that procedure is the Stouffer procedure.

R code
This includes Fisher's method (commented out) for comparison.
<code>n <- 10
n.iter <- 10^5
z <- matrix(rnorm(n*n.iter), ncol=n)

sim <- function(mu) {
  stouffer.sim <- apply(z + mu, 1,
                    function(y) {q <- pnorm(sum(y)/sqrt(length(y))); 2*min(q, 1-q)})
  chisq.sim <- apply(z + mu, 1,
                    function(y) 1 - pchisq(sum(y^2), length(y)))
  #fisher.sim <- apply(z + mu, 1,
  #                  function(y) {q <- pnorm(y);
  #                     1 - pchisq(-2 * sum(log(2*pmin(q, 1-q))), 2*length(y))})
  return(list(stouffer=stouffer.sim, chisq=chisq.sim, fisher=fisher.sim))
}

par(mfrow=c(2, 3))
breaks=seq(0, 1, .05)
tmp <- sapply(c(0, .1, .2, .3, .4, .6),
              function(mu) {
                x <- sim(mu);
                hist(x[[1]], breaks=breaks, xlab="p", col="#ff606060",
                     main=paste("Mu =", mu));
                hist(x[[2]], breaks=breaks, xlab="p", col="#6060ff60", add=TRUE)
                #hist(x[[3]], breaks=breaks, xlab="p", col="#60ff6060", add=TRUE)
                })
</code>
Comment: I used matlab to reproduce your simulation. Conclusions: when all $z_i$ deviate consistently from 0, then Stouffer wins over Fisher with a small margin and "my" method looses hopelessly (as you showed). When only one of $z_i$ deviates a lot from 0, then Fisher wins over "my" method with a small margin and Stouffer loses hopelessly.
Comment: You could easily modify the `R` simulation to test this.  It would be a good way to introduce yourself to this statistical computing platform. :-)
Comment: Thanks again, this is very nice. And what happens if you uncomment Fisher's method? I suspect you have already tried it. Does Stouffer consistently win? (Sorry for not trying it out myself, but I have no experience with R and do not have it at hand.)
Comment: Update: regarding comparison between Fisher's and Stouffer's methods I found a nice discussion [here](http://books.google.de/books?id=yQLFl1ILjZwC&lpg=PT64&ots=3W5p3DRR_Z&dq=stouffer%20vs%20fisher&pg=PT64#v=onepage&q=stouffer%20vs%20fisher&f=false). The claim is that Stouffer is more sensitive to consistent deviations from null, whereas Fisher is more sensitive to single (but large) deviations. I guess in your simulation you had consistent deviations ($\mu$ the same in all $N$ tests), correct? I wonder what would happen if only 1 out of $N$ tests shows a strong deviation.
Comment: Great discussion and QA! One quick question: what if one forms this problem as an outlier/anomaly detection by calculating Mahalanobis distance and follow something like [this](https://stats.stackexchange.com/questions/20543/distribution-of-an-observation-level-mahalanobis-distance)?
Comment: I noticed that @amoeba did mention scenarios that are particularly interesting to me in the comments under Q: "On the other hand, if zi have different signs but large absolute values, then Stouffer's method can end up with overall z≈0, whereas my method would report a VERY significant p". Would going down the Mahalanobis distance path a good approach then?
Answer: One general way to gain insight into test statistics is to
derive the (usually implicit) underlying assumptions that would lead
that test statistic to be most powerful. For this particular case a student and I
have recently done this:
http://arxiv.org/abs/1111.1210v2
(a revised version is to appear in Annals of Applied Statistics).
To very briefly summarize (and consistent with the simulation results in another answer) Stouffer's method will be most powerful when the "true"
underlying effects are all equal; the sum of Z^2 will be most powerful when
the underlying effects are normally distributed about 0.
This is a slight simplification
that omits details: see section 2.5 in the arxiv preprint linked above
for more details.
Comment: (+1) Somehow I thought I wrote it a long time ago, but it seems I did not: thanks a lot for registering here specifically to answer my question! I appreciate it. Section 2.5 in your paper is indeed very relevant.
Answer: Slightly o/t: one of the issues with both these approaches is the loss of power due to the degrees of freedom (N for stouffer's; 2N for Fisher's). There have been better meta-analytical approaches developed for this, which you may want to consider (inverse-variance weighted meta-analysis, for example).
If you're looking for evidence of some alternative tests within a group, you may want to look at Donoho and Jin's higher criticism statistic: https://projecteuclid.org/euclid.aos/1085408492
Answer: To answer the question and for any further readers: is it ever used?, there is an exhaustive paper by Cousins (2008) on arXiv, which listed and reviewed a couple of alternative approaches. The proposed one does not seem to appear.


How to show more terms in the "Parent terms" select list when adding taxonomy term?

Question: When adding terms to a taxonomy vocabulary, the "Parent terms" scrolling selector list in the "RELATIONS" section only displays 4 items. When dealing with large, complex, hierarchical taxonomies, this makes it difficult and slow to find the parent (a similar complaint and another).
I would love to be able to use something like the Simple hierarchical select or Client-side hierarchical select widget there, but assuming that's not currently possible, how can I simply display a longer list to make the selection a bit easier?
I am guessing there is a file somewhere containing a setting of "4" (unless that's a default) that I would able to increase to "20" for example. I hunted but couldn't find it.
I'd be interested in an answer, even if it would be a core hack that I would have to redo with each update.

Edit: It seems, from this link, that one solution may involve adding code such as this:
<?php
function MyModuleName_form_alter(&$form, &$form_state, $form_id) {
  if ($form_id == 'taxonomy_form_term') {
    $form['relations']['parent']['#size'] = '20';
  }
}

But where to add it? Or perhaps in a custom module (called MyModuleName)? Perhaps in MyTheme.theme? Or perhaps in a twig file such as html--admin--structure--taxonomy--manage--MyVocabularyName--add.html.twig?
Answer: OK Nick, you need to add the 'hook' into a custom module..
so for drupal 8 if you do not have a custom module follow the documentation here
https://www.drupal8.ovh/.../create-a-simple-module-for...
https://www.drupal8.ovh/.../create-a-simple-module-to-use...
In 'modules' folder create a custom folder 'custom' to hold your custom modules.
path should be ...modules/custom
inside this create a folder folder to hold your custom module my_custom_module ( orwhatever you want to call it )
path should be ...modules/custom/my_custom_module
inside this folder (my_custom_module) add a 'my_custom_module.info.yml' file in this file add
name: My custom module
description: My custom module description
package: Custom

type: module
core: 8.x

run drush en my_custom_module -y
or in admin/modules enable the module
once enabled add a .module file to the my_custom_module folder, called my_custom_module.module (or whatever you have called it)
in this file you can add the hooks you want to use for your one it will be
<?php
function my_custom_module_form_alter(&$form, &$form_state, $form_id) {
if ($form_id == 'taxonomy_term_vocabulary_name_form') {
$form['relations']['parent']['#size'] = '15';
}
}

change the my_custom_module to whatever you have called your module
change the section of the form id == vocabulary name to the name of the vocab you have created, you may need to inspect this and find it the form id! mine matched the vocab
clear the cache, go to your vocabulary and add a new term ! fingers crossed the size of the selct box has changed
think this covers it all, good luck
Comment: As an addendum, `$form['relations']['#open'] = TRUE;` can be added to that function so the form opens by default. Furthermore, if you have the [Chosen module](https://www.drupal.org/project/chosen) installed, then it can "take over" that widget and act as a combo of drop-down scrolling select list and auto-complete widget, making it much easier to select parent terms in a large vocabulary. If you both add that line and have Chosen installed, then you can remove the `'#size'` line from the function, since it doesn't have an affect.


Quais seriam casos reais de uso de programação funcional no mundo .NET (F#)?

Question: Recentemente (ok, já faz alguns bons meses) estive me interando da linguagem F#, que é a resposta da Microsoft em oferecer uma linguagem de programação funcional na plataforma .NET.
Porém ainda não ficou bem claro pra mim os reais casos e vantagens do uso deste paradigma sobre as "tradicionais" linguagens orientadas a objeto que já estão bem consolidadas (neste caso, C# ou VB.NET).
Portanto:

Em quais casos a programação funcional viabiliza soluções que a programação orientada a objeto é falha / morosa / impossível?
Há algum caso de uso desta linguagem / paradigma em projetos conhecidos (ou open-source)?
Do ponto de vista profissional, para as demandas de nosso mercado (brasileiro), vale a pena aprofundar os conhecimentos neste paradigma?
Comment: Pra dar uma ideia do uso de programação funcional na indústria, tem essa página aqui http://www.haskell.org/haskellwiki/Haskell_in_industry
Comment: Acho que é o mesmo que perguntar "quais os casos reais onde eu usaria a matemática?"
Comment: sua pergunta é muito ampla, e talvez fuja da proposta do site. Mas espero que essa resposta seja o que você queria saber.
Comment: @korbes: Bacana! Obrigado pelo link.
Answer: Embora o paradigma de programação Imperativo seja o mais popular entre programadores [profissionais], ele é apenas um entre vários meios de se "dar ordens" a um computador. Alem dele e do Funcional, temos também a Programação em Lógica (ex.: Prolog), Dataflow (ex.: o motor interno de uma planilha), Function-Level (os programas não manipulam dados, mas sim outros programas), etc. E, é claro, a mais conceitual/teórica Máquina de Turing - à qual todos os paradigmas anteriores são computacionalmente equivalentes.
Cada um desses paradigmas apresentam vantagens e desvantagens, e é comum à medida que as linguagens de programação "evoluem" que elas incorporem aspectos dos demais paradigmas. A principal razão pela qual se usa um paradigma ou outro é sua expressividade: a princípio, todos poderíamos estar programando em Máquinas de Turing, mas além da dificuldade de se ler/escrever/compreender tais programas eles também seriam por demais extensos em relação ao que fazem de útil. Da mesma forma, paradigmas diferentes oferecem um grau de expressividade maior para domínios específicos (ainda que a linguagem como um todo seja Turing-completa).
Quanto à F# em particular, vou citar uma resposta a uma pergunta similar no Stack Overflow em inglês:

Minha expectativa é que F# será usada para pedeços/peças de alguns sistemas especializados - as partes que envolvem threading complexo / matemática / cálculos financeiros / modelagem / etc, onde F# se adequa bem. Na maior parte das outras áreas (IU, Camada de Acesso a Dados, etc), uma linguagem de propósito geral como C# parece (na minha opinião) preferível.
Uma das vantagens de F# é que (em teoria) você pode provar que o código está funcionando, em vez de somente testá-lo. O suporte a threading (graças à imutabilidade e o uso assíncrono de <code>!</code>) também é bom (embora PLINQ pode competir em threading).

(Comentário: discordo do autor dessa resposta no sentido que é sim possível provar que um programa imperativo está correto - só é mais trabalhoso...)
Não posso comentar sobre o nosso mercado, uma vez que não participo do "ecossistema" Microsoft (preferindo desenvolver em software livre), mas de um modo geral a abertura das mentes dos programadores brasileiros para a programação funcional creio que seria muito bem vinda!
Comment: Legal! Muito obrigado pela sua explicação. Uma aula pra mim.
Answer: Pelo que entendi da linguagem, o uso dela seria algo semelhante ao do matlab.
E seria utilizada onde você necessita realizar cálculos matemáticos complexos.
No próprio link que você passou sobre programação funcional há o seguinte trecho:

Linguagens de programação funcionais, especialmente as puramente
  funcionais, tem sido mais usadas academicamente que no desenvolvimento
  comercial de software

Na área comercial é mais comum você encontrar uso na área de processamento de imagens(ou vídeo).
Isso não significa que uma aplicação inteira seria feita nessa linguagem, mas uma parte do processamento seria calculado por um script escrito nela.
Um exemplo pratico de uso: o sistema da folha de pagamento do estado onde trabalho tem toda sua parte visual(os módulos e telas que os funcionários operam) feitas em uma linguagem que facilite a criação de forms. Mas o processamento do calculo da folha de pagamento, que resulta em um volume gigantesco de cálculos, é rodado em scripts C/C++. A prioridade nesse caso, foi ganhar em processamento, já que os cálculos em si não envolvem funções tão complexas.
Tudo compõe um único sistema, mas com algumas partes escritas em linguagens diferentes.
Comment: Obrigado @Guilherme pela sua resposta. Sua abordagem já me esclareceu que o uso é direcionado, e não uma tendência generalizada. Era o que eu precisava confirmar.
Comment: As duas primeiras linhas da sua resposta estão erradas. Matlab é uma linguagem especializada para computação numérica, F# é uma linguagem de propósito geral tal como Ruby, Haskell, Clojure, C# etc.


Optimising filtering multiple SQL count sub queries with SQLAlchemy

Question: I'm trying to convert raw postgres-SQL into sqlalchemy which uses a count and filter
SELECT

  (
   SELECT
     COUNT(user_model.uuid)
     FILTER ( WHERE  email_vector @@ parse_websearch('search term'))
   ) AS email_vector,

   (
    SELECT
    COUNT(user_model.uuid)
    FILTER ( WHERE  first_name_vector @@ parse_websearch('search term'))
    ) AS first_name_vector,

FROM
user_model

WHERE
(user_model.uuid = '20d7c90d-ebfa-4b04-9ee7-4fdedabc6c0b' AND all_vectors @@  parse_websearch('search term')  )

This works great and is very fast (sub 100ms - even when filtering 20 fields)
I've written the sqlalchemy as (simplified)
search_query = []
search_vectors = [ email_vector, first_name_vector]
search_vector_names = [ 'email_vector', 'first_name_vector' ]

for search_vector, search_vector_name in zip(search_vectors, search_vector_names):
     search_query.append(sa.sql.select(
                sa.func.count(user_model.uuid)) \
                    .filter(search_vector.op('@@') \
                        (sa.func.parse_websearch(search_term))) \
                    .label(search_vector_name)
            )

base_query = db.session.query(*search_query)

base_query = base_query.filter(user_model.uuid==user_uuid)
base_query = query.filter(search_vector.op('@@')(sa.func.parse_websearch(search_term))

This produces the following SQL
SELECT (
  SELECT count(user_model.uuid) AS count_1
  FROM user_model
  WHERE user_model.email_vector @@ parse_websearch(%(parse_websearch_1)s)) AS email_vector,

  (SELECT count(user_model.uuid) AS count_2
  FROM user_model
  WHERE user_model.first_name_vector @@ parse_websearch(%(parse_websearch_2)s)) AS first_name_vector,

WHERE user_model.uuid = %(uuid_1)s AND (user_model.all_vectors @@ parse_websearch(%(parse_websearch_30)s))

This works but is quite slow (+1 second). I'm not sure why it's so slow or how to do a filter query on the sub queries.
I suspect the COUNT is being performed on each sub query where the SQL uses the filtered results from the final WHERE condition, but I'm not totally sure and I can't find any reference to filter (which I think it shorthand for CASE?) in the sqlalchemy docs. I've tried adding .filter(user_model.uuid==uuid)  to the COUNT SQL but it is still slow.
Would anyone be able to offer an insight into what I'm missing?
Answer: I eventually did this using CASE
            case_stmt = sa.case(
                [
                    (
                        full_text_search_vector.op('@@') \
                        (sa.func.parse_websearch(last_search_term)),1
                    )
                ]
            ).label(col_name)

            query.append(case_stmt)

        base_query = db.session.query(*query)


Dropping the modulus sign in integrals of the form $\int 1/t ~dt$

Question: In the process of solving a DE and imposing the initial condition I came up with the following question.
I've reached the stage that
$$\ln y + C = \int\left(\frac{2}{x+2}-\frac{1}{x+1}\right)dx$$
$$\Rightarrow \ln y +C=2\ln|x+2|-\ln|x+1|$$
$$\Rightarrow y=A\frac{(x+2)^2}{|x+1|}.$$
Now I had also found that the curve passes through $(-4,-3)$. Susbstituting in the expression above, we find $A=-9/4$. However, the solution in the markscheme (the problem was from a past exam) drops the modulus sign and so it gives $A=9/4$.
So my question is, why do they drop the modulus sign and when is one allowed to do so in dealing with integrals of the form $\int 1/t ~dt$?
Thanks in advance.
Answer: First of all, you should presumably have had
$$\ln |y| + C = 2\ln |x+2| - \ln |x+1|\,, \quad\text{leading to}\quad |y| = A\frac{(x+2)^2}{|x+1|}\,.$$
Since a solution curve through $(-4,-3)$ cannot cross the lines $x=-1$ and $y=0$, we infer that throughout $y<0$ and $x<-1$, so $|y|=-y$ and $|x+1|=-(x+1)$. Thus, the solution is
$$y=\frac94\frac{(x+2)^2}{x+1}\,, \quad x<-1,\ y<0\,.$$
Check the markscheme carefully! :)
Answer: $\ln (-x)$ does not make sense for $x>0$ so modulus sign must always be there for the function to make sense. You can get rid of modulus sign iff you know that $\ln(x)$ is used for some $x$ greater than zero(i.e. the parameter inside the function must be greater than zero.)
Like in this case if the modulus sign is not there there and $A=-9/4$ then for  $\forall x>-1$ , we have $y<0$ but then $\ln y$ does not make any sense(though we have used $\ln y$ to arrive at this equation.)
Comment: Yes, so is the markscheme wrong in dropping the sign and claiming that $A=9/4$ instead of $-9/4$?
Comment: In my view its wrong.


What is the difference between x++ and ++x in Java

Question:
What is the difference between x++ and ++x in Java
Can anybody please tell me the difference of the above by refering the below code,

class Example{
    public static void main(String args[]){
        int x=10;
        int y;
        y=x++;  //Prints 11     10
        System.out.println(x+"\t"+y)
    }
}

class Example{
    public static void main(String args[]){
        int x=10;
        int y;
        y=++x;  //Prints 11     11
        System.out.println(x+"\t"+y)
    }
}

Comment: @SotiriosDelimanolis Not necessarily, if you don't know it's called *postincrement* and *preincrement*, respectively. Easy if you know. Still a duplicate, this has been asked many times.
Comment: duplicate of http://stackoverflow.com/q/1094872/799558
Comment: @MichaelKjörling You don't need to call it by name though. Just put i++ vs ++i in some search engine.
Comment: @MichaelKjörling Actually its very easy, check this [google search](https://www.google.co.uk/#hl=en&output=search&sclient=psy-ab&q=difference+between+x%2B%2B+and+%2B%2Bx+java&oq=difference+between+x%2B%2B+and+%2B%2Bx+java&gs_l=hp.3...766.10380.0.10500.39.20.2.22.214.171.124.2664.0j18j1.19.0.les%3B..0.0...1c.1.4.psy-ab.r_6b-1uvjYI&pbx=1&bav=on.2,or.r_gc.r_pw.r_cp.r_qf.&bvm=bv.42965579,d.d2k&fp=2d067e3b3a7f4d22&biw=1280&bih=923)
Answer: y=x++ assigns x to y, then increments x.
y=++x increments x, and then assigns it to y.
Answer: ++x is the pre-increment. i.e., The value of x is first incremented and then assigned to x.
x++ is post increment. i.e., the value of x is assigned first and then incremented.
y=x++;

is essentially same as
y =x;
x= x+1;

y=++x; is same as
y= (x+1);

Comment: @MichaelKjörling sorry, i dint get you. why would you reassign y to x??
Answer: Pre and Post increment. Increment BEFORE assignment and increment AFTER assignment respectively.
Answer: The difference is that in the first case (x++) Java first resolves the assignment issue and then increments x. In the other case (++x) Java first resolves the increment and then the assignment.
In the following code you will see the difference:
@Test
public void test1() {
    int x = 1;
    int y = 1;

    y = 2 + x++;
    assertEquals(2, x);
    assertEquals(3, y);
}

@Test
public void test2() {
    int x = 1;
    int y = 1;

    y = 2 + ++x;
    assertEquals(2, x);
    assertEquals(4, y);
}

As you can see, x always will be incremented, but the difference is the order in which the expression is resolved.
Hope it would be useful!


PHP Como eu faço para multiplicar horas com a quantidades de vezes que vai ser repetido?

Question: Eu tenho uma tabela em meu MySQL de produtos com tempo, exemplo:
Tabela Processos

id - descrisão - Tempo
01 - Furar - 0:01:50

Exemplo se eu mandar fabricar uma peça que tem 5 furos, eu tenho que multiplicar quantidade pelo tempo.
echo $tempo * 5;

a variável $tempo, é pego na tabela processos.
Mas me retorna 0, ao invés de retornar 0:09:10
O que está errado ?
Answer: Você pode fazer de duas maneiras a mesma solução.

Diretamente no MySQL utilizando funções de conversão TIME_TO_SEC e SEC_TO_TIME
SELECT SEC_TO_TIME(
         TIME_TO_SEC('00:01:50') * 5
       ) as TEMPO_TOTAL

Fazendo no PHP
$tempo = "00:01:50"; // Formato: 'HH24:MI:SS'
$furos = 5;

$str_time = preg_replace("/^([\d]{1,2})\:([\d]{2})$/", "00:$1:$2", $tempo);
sscanf($str_time, "%d:%d:%d", $hours, $minutes, $seconds);

// tempo total em segundos
$tempo_total = ($hours * 3600 + $minutes * 60 + $seconds) * $furos;

echo gmdate("H:i:s", $tempo_total); //Formata o tempo total para visualização

Comment: Obrigado Everson , no mysql não da para meu processo, pois uma peça tem 5 furos, outra tem nenhuma, outra tem mais de 1000 furos.
Answer: <?php

$hora = "04:15:57";

//Transformar em segundos
$tmp = explode(':', $hora);
$segundos = $tmp[0] * 3600 + $tmp[1] * 60 + $tmp[2];

//Aplica a multiplicação
$segundos = $segundos * 5;

//Tranformar em hora
echo gmdate("H:i:s", $segundos);

?>


For each column of a dataframe, add mean and standard deviation in the last two rows

Question: Sample dataframe:
import pandas as pd
import numpy as np

rng = np.random.RandomState(123)

data = rng.random((10,2))
foo = pd.DataFrame(data, columns=['A', 'B'])

I want to add two rows to foo, the first one containing (for each column) the mean of rows from 0 to 9, and the second one containing (again, separately for each column) the standard deviation of rows from 0 to 9. How can I do that?
Answer: Here is one option :
out = pd.concat(
        [foo, foo.describe().loc[["mean", "std"]]]
        # with an optional chain `.reset_index(drop=True)`
)

Output :
print(out)

             A         B
0     0.696469  0.286139
1     0.226851  0.551315
2     0.719469  0.423106
3     0.980764  0.684830
4     0.480932  0.392118
5     0.343178  0.729050
6     0.438572  0.059678
7     0.398044  0.737995
8     0.182492  0.175452
9     0.531551  0.531828
mean  0.499832  0.457151
std   0.243457  0.233585

Comment: It works! Can you please improve the answer by explaining why we need double square brackets in the call to `loc`? `loc[["mean", "std"]]`
Comment: We're using here square brackets (*i.e a list*) in [`loc`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.loc.html) because we're selecting more than a single row (`mean` and `std`) in the DataFrame returned by [`describe`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.describe.html) (*read more here* : [*Different choices for indexing*](https://pandas.pydata.org/docs/user_guide/indexing.html#different-choices-for-indexing))
Comment: ok, I would have added that in the answer rather than in the comments, but as you prefer.


CSS + Java Script : Tratando imagem maior que uma div circular

Question: Bom dia !!
Estou tentando fazer o seguinte:
Criei uma function que ao clicar na foto, manda a foto para a div circular conteudo, o problema é que se a imagem for maior que a div, ela sobrepõe tudo, gostaria de tratar ela para ficar inteira porém dentro da div como na foto:
(Vermelho foto atual sem tratamento) (Azul o modo desejado)

function clickImagem(src)
{
  $('.conteudo').empty();
  var el = document.getElementById('conteudo');
  $('#conteudo').css('background',"url('"+src+"') no-repeat center");
  $('#conteudo-foot').empty();
}
.conteudo{
  width:320px;
  height:300px;
  border-radius:50%;
  border:0.1px solid #000;
  z-index:5;
  background:#fff;
  margin: 35px auto;
  -webkit-box-shadow: 0 0 10px rgba(0,0,0, 0.7);
  -moz-box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
  box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);

}
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title></title>

 Podem me ajudar por favor?
Comment: Você quer que a imagem fique dentro do círculo, perdendo as partes que extrapolam a circuferência ou você quer que a imagem quadrada fique dentro do círculo?
Comment: Então, gostaria de saber como faço para a imagem ficar dentro do círculo azul
Answer:
Inline

function clickImagem(src)
{
  $('#conteudo').empty();
  var el = document.getElementById('conteudo');
  $(el).html('')
}
.conteudo{
  width:320px;
  height:300px;
  border-radius:50%;
  border:0.1px solid #000;
  z-index:5;
  background:#fff;
  margin: 35px auto;
  -webkit-box-shadow: 0 0 10px rgba(0,0,0, 0.7);
  -moz-box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
  box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
  overflow: hidden;
  position: relative;
  text-align: center;
}
.conteudo > img{
    width: 70%;
    height: 70%;
    position: relative;
    margin-top: 14%;
}
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title></title>

Com flexbox (consulte o suporte http://caniuse.com/flexbox)

function clickImagem(src)
{
  $('#conteudo').empty();
  var el = document.getElementById('conteudo');
  $(el).html('')
}
.conteudo{
  width:320px;
  height:300px;
  border-radius:50%;
  border:0.1px solid #000;
  z-index:5;
  background:#fff;
  margin: 35px auto;
  -webkit-box-shadow: 0 0 10px rgba(0,0,0, 0.7);
  -moz-box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
  box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
  overflow: hidden;
   display: -webkit-box;
   display: -ms-flexbox;
   display: flex;
  -webkit-box-align:center;
  -ms-flex-align:center;
  align-items:center;
  -webkit-box-pack: center;
  -ms-flex-pack: center;
  justify-content: center;
}
.conteudo > img{
    width: 70%;
    height: 70%;
}
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title></title>

Com a imagem em background

function clickImagem(src)
{
  $('.conteudo').empty();
  var el = document.getElementById('conteudo');
  $('#conteudo').css('background',"url('"+src+"') no-repeat center");
  $('#conteudo').css('background-size',"70% 70%");
  $('#conteudo-foot').empty();
}
.conteudo{
  width:320px;
  height:300px;
  border-radius:50%;
  border:0.1px solid #000;
  z-index:5;
  background:#fff;
  margin: 35px auto;
  -webkit-box-shadow: 0 0 10px rgba(0,0,0, 0.7);
  -moz-box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
  box-shadow: 0 0 10px rgba(0, 0, 0, 0.7);
  overflow: hidden;
  background-size: 70% 70%;
}
<!DOCTYPE html>

  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width">
  <title></title>

Comment: Perfeito !! Obrigado Felipe
Comment: Neste caso ele ajusta a imagem para dentro do círculo certinho. Mas neste caso eu gostaria de apresentar a imagem (quadricular) inteira dentro da div, tem como fazer desta forma?
Comment: entendi, já edito
Comment: Obrigado @Felipe !!
Comment: Editado, por nada hehe!
Comment: Se o Script deixar a imagem como background o código também funcionará??
Comment: Ai o método muda, teria de redimensionar o background e centraliza-lo, porém seria mais fácil, nesse caso da imagem também seria fácil se ela estivesse em um um container exemplo uma div, como ela está sozinha, centraliza-la não é uma tarefa fácil.
Comment: Eu posso editar minha pergunta para te apresentar esta questão melhor??
Comment: Claro, edite com o que deseja fazer.
Comment: Editei o JavaScript para deixar a imagem como background
Comment: Era só setar o size, editado!


Return status of python unittest

Question: I'm trying to call a unittest from another python file, and evaluate the exit code.  I was able to use unittest.TestLoader().loadTestsFromModule and unittest.TextTestRunner.run to call the unittest from another python file, but that's returning the entire results to the cmd.  I would like to simply set a variable equal to the status code so I can evaluate it.  I was able to find a method unittest.TestResult.wasSuccessful, but I'm having trouble implementing it.  When I add it to the use case, I get the following AttributeError: AttributeError: 'ConnectionTest' object has no attribute 'failures'
I've included some code samples below and a mockup of the desired result as an illustration of what I'm trying to achieve.  Thank you in advance.
""" Tests/ConnectionTest.py """

import unittest
from Connection import Connection

class ConnectionTest(unittest.TestCase):

    def test_connection(self):
        #my tests

    def test_pass(self):
        return unittest.TestResult.wasSuccessful(self)

if __name__ == '__main__':
    unittest.main()

""" StatusTest.py """

import unittest
import Tests.ConnectionTest as test
#import Tests.Test2 as test2
#import Tests.Test3 as test3
#import other unit tests ...

suite = unittest.TestLoader().loadTestsFromModule(test)
unittest.TextTestRunner(verbosity=2).run(suite)

""" Return True if unit test passed
"""
def test_passed(test):
    if test.test_pass() == 0:
        return True
    else:
        return False

""" Run unittest for each module before using it in code
"""
def main():
    tests = "test test2 test3".split()
    for test in tests:
        if test_passed(test):
            # do something
        else:
            # log failure
            pass

Update
To put the question more simply, I need to set the highlighted variable below to the highlighted value.
Comment: Please include your code as text in the body of your question.  It's easier to read, available to accessibility tools, can be copied, and allows people who can't access imgur at work to help you too.
Comment: @PatrickHaugh sorry about that, I'll update momentarily
Answer: You mentioned you tried implementing result.wasSuccessful, but would something like the following work:
result = unittest.TextTestRunner(verbosity=2).run(suite)
test_exit_code = int(not result.wasSuccessful())

The value of test_exit_code would then be either 0 when the test suite ran successfully or 1 otherwise.
If you want to disable the output of the TextTestRunner you can specify your own stream, such as:
from io import StringIO

result = unittest.TextTestRunner(stream=StringIO(), verbosity=2).run(suite)

Comment: Nice, thank you will! That worked.  I changed the verbosity parameter in TextTestRunner, but it's still printing 'Ran x tests in xs' and the 'OK'. Is there a way to suppress that print/ output?
Comment: Glad it worked. So you're also looking to suppress all the console output?
Comment: Yes, what i'm basically looking to do is have logic in my main script that will call a class/ method if it's corresponding unit test passed, or not call the class/method if it doesnt.  For that, i just need to set the unit test status code == var and then use the var in an if then in my other script.  So in short, yes, i dont need the console output for the unit test
Comment: I see. So presumably you could use the approach above - `result = unittest.TextTestRunner(verbosity=2).run(suite)` but pass an individual test rather than the whole suite in order to get a pass/fail answer for that test. As for disabling the output, you can specify your own `stream` argument to the `TextTestRunner` - see updated answer.
Comment: Thank you so much for your help @Will.   Your answer was perfect.

Return status of python unittest


2 decoradores em um método Python

Question: Bem, eu tenho uma classe bem simples chamada de Task, onde quero armazenar as minhas tasks para depois salvar em um banco.
No entanto, eu quero ir tratando os tipos dos meus atributos, gostaria que o atributo task_name só aceitasse o tipo string.
Para isso eu tenho um decorador chamado validate_type, no entanto eu não estou entendendo onde está o erro, mas sempre que eu rodo o programa, ele levanta a exceção.
def validate_type(typee):
    def _validate(func):
        def inner(*args, **kwargs):
            if all(isinstance(val, typee) for val in args):
                return func(*args)
            else:
                raise TypeError("Voce atribuiu o valor errado")
        return inner
    return _validate

class Task(object):
    def __init__(self, task_name):
        self._task_name = task_name

    @property
    def task_name(self):
        return self._task_name

    @task_name.setter
    @validate_type(str)
    def task_name(self, value):
        self._task_name = value

task = Task('minha task')
task.task_name = 4
print(task.task_name)

Esse decorador funciona com funções mas com métodos não.
Acredito que seja devido ao self da classe mas não sei como resolver
Answer: Precisamente. Em um método, o self vai ser inserido como primeiro argumento na chamada. Na sua verificação você checa o tipo de todos os argumentos passados - e o tipo do primeiro sempre vai ser igual o tipo da classe.
Pra deixar claro - o problema não tem nada a ver com "2 decoradores" - o decorador property.setter sempre espera uma função que vai receber uma instância da classe no primeiro parâmetro, mas ele não é um decorador "comum" que retorna um wrapper da função decorada. A solução que proponho aqui foge um pouco da sua pergunta, apontando uma alternativa ao property, e sem usar decorador algum. O problema específico do seu código é abordado logo abaixo.
Se quiser um decorador genérico para verificar todos os tipos, que você possa usar tanto em funções como métodos, acho que o método mais explícito é aceitar um parâmetro que indique se a função decorada é uma função normal, ou um método, e nesse caso, não verificar o tipo do primeiro argumento:
def validate_type(typee, method=False):
    start_arg = 1 if method else 0
    def _validate(func):
        def inner(*args, **kwargs):
            if all(isinstance(val, typee) for val in args[start_arg:]):
                return func(*args)
            else:
                raise TypeError("Voce atribuiu o valor errado")
        return inner
    return _validate
...

class Task(object):
    def __init__(self, task_name):
        self._task_name = task_name

    @property
    def task_name(self):
        return self._task_name

    @task_name.setter
    @validate_type(str, True)
    def task_name(self, value):
        self._task_name = value

(Como sugiro outra abordagem abaixo, não efetuei outras melhorias nesse código. Mas note que se o seu decorador for chamado com argumentos com nome, em vez de posicionais, seu decorador não vai funcionar - eles vem na variável kwargs, que esse código nem toca)
Se pretende usar esse decorador em vários setters, aí tem opções mais simples mesmo: ou um decorador simples que verifique direto só o tipo do segundo argumento (o value).
No entanto, se sua intenção é ter várias properties só pra fazer a checagem de tipo, aí  a melhor opção mesmo é dar um passo atrás e criar uma classe de Descriptor - isso é, não usar a camada que o property fornece que deixa você usar funções como setters e getters, e sim, criar uma classe que já tenha a lógica de setter com verificação de tipo inclusa.
Em outras palavras: criamos uma classe de objetos que deve ser usada como atributos de classe, e verifica automaticamente as instâncias das atribuições em tempo de execução.
Com isso, não é necessário nem usar o nome do atributo com _ para replicar o atributo na instância - podemos usar diretamente o __dict__ da instância para guardar o valor de mesmo nome. (Com property também é possível, na verdade).
class TypedAttr:
    def __init__(self, type):
        self.type = type

    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, instance, owner):
        return instance.__dict__[self.name]

    def __set__(self, instance, value):
        if not isinstance(value, self.type):
            raise TypeError(f"Attribute {self.name!r} must be set to instances of {self.instance!r}")
        instance.__dict__[self.name] = value

E aí, você pode ter sua classe simplesmente assim - perceba como posso colocar vários atributos com tipo sem precisar de nenhum código de setter e getter para cada atributo:
class Task(object):

    task_name = TypedAttr(str)
    task_points = TypedAttr(int)

    def __init__(self, task_name, points=1):
        self.task_name = task_name
        self.task_points = 1

E no terminal interativo:
>>> t = Task("teste")
>>> t.task_name
'teste'
>>> t.task_name = 23
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 10, in __set__
TypeError: Attribute 'task_name' must be set to instances of <class 'str'>
>>> t.task_points = 25.0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 10, in __set__
TypeError: Attribute 'task_points' must be set to instances of <class 'int'>

Veja como funcionam os "descriptors" na documentação do Python - o property, como dito acima, é só uma conveniência para incorporar métodos específicos de get e set mesmo.

2 decoradores em um método Python


Linearly independent vectors each subtracted by a linear combination of them are linearly dependent if coefficients add up to $1$

Question: The task
I've been given the following problem:

Let $v_1, \ldots, v_n$ linearly independent vectors in an $\mathbb{F}$-vector space $V$ and $u = \lambda_1 v_1 + \ldots + \lambda_n v_n$ a linear combination of those vectors.
Prove that
$$v_1 - u, \ldots, v_n - u \text{ are linearly dependent} \Leftrightarrow \lambda_1 + \ldots + \lambda_n = 1 $$

Unfortunately, I have some trouble with this question. What steps would need to be taken in order to prove this? One hint might be the fact that if a set of vectors is linearly independent, it means any linear combination of them has only one clear set of coefficients (and the other way around).
EDIT: After angryavian's answer, I've understood how to prove the first direction. Unfortunately, the other direction still leaves me quite puzzled. A hint would be greatly appreciated.
Answer: Mistake in counterexample: $\mu_1$ can be real number, so they are linearly dependent.

Proving the original problem:
$\implies$ direction: If $v_1 - u, \ldots, v_n - u$ are linearly dependent,
there exist $c_1, \ldots, c_d$ not all zero such that
$$0 = c_1 (v_1 - u) + \cdots + c_n (v_n - u)
= (c_1 - (c_1 + \cdots + c_n)\lambda_1) v_1 + \cdots + (c_n - (c_1 + \cdots + c_n)\lambda_n) v_n.$$
By linear independence of $v_1,\ldots, v_n$,
$$c_i - (c_1 + \cdots + c_n) \lambda_ i =0, \text{ for all } i = 1, \ldots, n.$$
Summing over all $i$ yields $$c_1 + \cdots + c_n = (c_1 + \cdots + c_n)(\lambda_1 + \cdots + \lambda_n).$$
If $c_1 + \cdots + c_n \ne 0$, then we are finished.
The other situation $c_1 + \cdots + c_n = 0$ cannot happen, since then $c_1 (v_1 - u) + \cdots + c_n(v_n - u) = c_1 v_1 + \cdots + c_n v_n \ne 0$, by linear independence of $v_1, \ldots, v_n$, which contradicts our premise.
$\impliedby$ direction:
It is your job to find $c_1, \ldots, c_n$ not all zero such that
$$0 = c_1 (v_1 - u) + \cdots + c_n (v_n - u)
= (c_1 - (c_1 + \cdots + c_n)\lambda_1) v_1 + \cdots + (c_n - (c_1 + \cdots + c_n)\lambda_n) v_n.$$
There is a relatively straightforward choice of $c_1,\ldots, c_n$ (in terms of the $\lambda_1, \ldots, \lambda_n$) that will make this work.

Overkill matrix approach:
WLOG assume $v_1, \ldots, v_n$ span $V$ (else work in the subspace spanned by $v_1, \ldots, v_n$). We consider matrices and vectors using the basis $v_1, \ldots, v_n$.
The columns of the matrix $I - \lambda \mathbf{1}^\top$ are $v_1 - u, \ldots, v_n - u$. Here, $\lambda \mathbf{1}^\top$ is the $n \times n$ matrix consisting of the column $(\lambda_1, \ldots, \lambda_n)$ repeated $n$ times.
It suffices to show that $0$ is an eigenvalue of $I - \lambda \mathbf{1}^\top$ if and only if $\lambda_1 + \cdots + \lambda_n = 1$.
One can show that the eigenvalues of $I - \lambda \mathbf{1}^\top$ are $1$ and $1 - (\lambda_1 + \cdots + \lambda_n)$.
Comment: Alright, then that's a trivial mistake. I'll remove the part regarding the counter example.
Comment: It seems finding the $c_i$ for the other direction isn't as trivial for me as you might have expected. Obviously, we need $c_i - (c_1 + \ldots + c_n) \lambda_i = 0 \forall i \in 1,\ldots,n$ due to linear independence of $v_1, \ldots, v_n$. Solving for $c_i$, we get a term that depends on the value of every other $c_j, j \in 1,\ldots, n \setminus \left\{i\right\}$, which does not seem helpful to me. Additional, I'm unsure how to employ the fact $\lambda_1 + \ldots + \lambda_n = 1$ in this setting.
Comment: @StckXchnge-nub12 Try $c_i = \lambda_i$.
Answer: If you consider the matrix having as columns the coordinates of the new vectors with respect to the given linearly independent set (everything takes place in the subspace of which $\{v_1,\dots,v_n\}$ is a base):
\begin{bmatrix}
1-\lambda_1 & -\lambda_1 & \dots & -\lambda_1 \\
-\lambda_2 & 1-\lambda_2 & \dots & -\lambda_2 \\
\vdots & \vdots & \ddots & \vdots \\
-\lambda_n & -\lambda_n & \dots & 1-\lambda_n
\end{bmatrix}
you see that this matrix is
$$
I-
\begin{bmatrix} \lambda_1 \\ \lambda_2 \\ \vdots \\ \lambda_n \end{bmatrix}
\begin{bmatrix} 1 & 1 & \dots & 1 \end{bmatrix}
$$
which is not invertible (meaning that $\{v_1-u,\dots,v_n-u\}$ is linearly dependent) if and only if $1$ is an eigenvalue of
$$
A=
\begin{bmatrix} \lambda_1 \\ \lambda_2 \\ \vdots \\ \lambda_n \end{bmatrix}
\begin{bmatrix} 1 & 1 & \dots & 1 \end{bmatrix}
$$
This is a matrix with rank at most one, so it has at most one nonzero eigenvalue, namely
$$
\begin{bmatrix} 1 & 1 & \dots & 1 \end{bmatrix}
\begin{bmatrix} \lambda_1 \\ \lambda_2 \\ \vdots \\ \lambda_n \end{bmatrix}
=\lambda_1+\lambda_2+\dots+\lambda_n
$$


How to use versioning in TYPO3?

Question: I want to create version(ing) for page and records inside my backend environment.
is their any difference between versioning and workspace?
Comment: you want to create version but you don't know what this is ?
Comment: Yes, i have create versioning.
Answer: A workspace lets you version record related to a workspace and to publish this workspace in one go (or switch two workspaces).
Versioning is required for workspaces, but can be used without workspaces.
Usually versioning is only used together with workspaces to create staging environments with workflows in the backend.

How to use versioning in TYPO3?