ALLEN ATLAS CEREBRAL

Visão geral

Esta base de dados de células cerebrais é uma pesquisa de características biológicas derivadas de dados de células únicas, de humanos e ratos.

O banco de dados contém propriedades eletrofisiológicas , morfológicas e transcriptômicas coletadas de células individuais e modelos simulando atividade celular. Nesta fase inicial da geração de dados, a cobertura da pesquisa foi focada em áreas selecionadas do córtex cerebral e nos neurônios talâmicos.

Procure os dados de resposta eletrofisiológica e as morfologias neuronais reconstruídas usando a ferramenta de Pesquisa de Caracteres Celulares . Os dados transcriptômicos podem ser acessados ​​através da página de download .

Use o Kit de Desenvolvimento de Software Allen (SDK) para acessar e analisar programaticamente dados em bruto e executar modelos.

Os dados podem ser baixados selecionando experimentos individuais na ferramenta de Pesquisa de Caracteres de Celular, acessando arquivos RNA-Seq transcriptômicos através da página de Download , ou através do SDK ou API Allen

 

 

 

Dados de rato

As células são adquiridas de áreas cerebrais selecionadas em ratos adultos. As células são identificadas para o isolamento com base em linhas de ratos transgênicos que abrigam repórteres fluorescentes conduzidos por drivers específicos do tipo celular. Para análises eletrofisiológicas e morfológicas, foram selecionadas células excitatórias com expressão enriquecida em camada e células inibitórias baseadas em marcadores clássicos. As áreas cerebrais selecionadas para análise incluem sub-regiões do córtex visual, córtex motor e córtex motor lateral anterior (ALM), na área do motor secundário (MOs).

Para a análise transcriptômica, foram realizadas dissecções regionais e laminares em espécimes de linhas transgênicas pan-neuronais, pan-excitatórias e pan-inibitórias, para amostra de forma abrangente. Os dados do núcleo geniculado lateral (LGd) também estão incluídos.

Este diagrama interativo de Venn mostra quantas células estão disponíveis para cada modalidade de dados (eletrofisiologia, morfologia, transcriptômica) e modelos. Selecione uma categoria para visualizar o subconjunto de células.

Existem 1058 células de mouse para as quais temos dados de eletrofisiologia.

 

 

Dados humanos

As células são adquiridas a partir do tecido cerebral doado nos lobos temporais ou frontais com base em anotações estruturais descritas no Atlas de referência do cérebro humano Allen . Para análises eletrofisiológicas e morfológicas no córtex, as células são selecionadas com base na forma do soma e na localização laminar.

Para a análise transcriptômica, diferentes camadas de córtex são dissecadas e os núcleos neuronais são isolados. A amostragem laminar é guiada pelo número relativo de neurônios presentes em cada camada.

 

 

 

Sobre eletrofisiologia

As gravações de grampos de patch de células inteiras fornecem informações básicas sobre propriedades de disparo celular. As gravações são realizadas usando uma variedade de protocolos de estímulo, incluindo pulsos curtos, passos longos, rampas lentas e ruído naturalista para caracterizar as propriedades intrínsecas desses neurônios. Os protocolos detalhados são descritos no whitepaper técnico de visão geral de eletrofisiologia .

Sobre Morfologia

A estrutura celular informa a função e a diversidade neuronal. Para ver a forma da célula, as células são preenchidas com biocitina e imagens em série para visualizar suas morfologias. Imagens planar e reconstruções de células 3D podem ser visualizadas com os dados de eletrofisiologia da célula, ou baixados para análise off-line. Os protocolos detalhados são descritos no whitepaper técnico da síntese de morfologia .

Sobre Transcriptomics

A seqüência de ARN pode fornecer um perfil transcriptômico para cada célula. Os transcritos genéticos são isolados, amplificados e seqüenciados, e as leituras estão alinhadas com um genoma de referência. A expressão de ARN por gene é relatada como uma média de isoformas de transcrição. Os dados estão disponíveis para células inteiras e, em alguns casos, isolados de frações nucleares. Para os núcleos, uma proporção significativa de lições se alinha aos intrões. Todos os dados podem ser baixados e os protocolos detalhados são descritos no quadro técnico geral da transcriptomics .

Sobre Modelos

Uma variedade de modelos neuronais que simulam propriedades de células intrínsecas estão disponíveis. Os modelos incluem: modelos generalizados de injeção e fogo, modelos biofisicamente realistas, de neurônio único com dendritos passivos e soma ativo (perisomático) e com condutâncias ativas (tudo ativo). As simulações podem ser vistas em linha ao lado das respostas celulares medidas, quando disponíveis. Todos os modelos podem ser baixados, e protocolos detalhados são descritos nos whitepapers técnicos: GLIF , perisomatic , all-active .

 

Fonte:  http://celltypes.brain-map.org/

Anúncios

Como implementar o Blockchain em JavaScript

Ouvimos falar sobre Bitcoin, Ethereum além de outras moedas praticamente todos os dias. 2017 afinal, foi o ano dascryptocurrencies.

Nesse post porém, não vou focar em nenhuma dessas moedas digitais. Mas sim na tecnologia por trás delas, que muitas pessoas dizem ser tão revolucionárias quanto a própria internet, o Blockchain.

A ideia é implementar passo-a-passo uma versão simplificada do Blockchain em JavaScript e ir explicando como essa tecnologia disruptiva funciona por baixo dos panos.

Então, continue lendo esse post para aprender:

  • O que é e como funciona o Blockchain
  • Proof of Work?
  • Pra que servem os Blocos
  • O que é Mineração

Introdução

O Blockchain parece uma tecnologia de outro mundo e gera muitas dúvidas. Apesar disso, é algo extremamente fácil de definir:

O Blockchain nada mais é do que um banco de dados aberto e distribuído.

Esse banco de dados é composto de Blocos. E todos esses Blocos são ligados entre si em uma sequência. Daí o nome, Blockchain (cadeia de blocos).

Além disso, esse banco de dados é imutável.
E faz sentido que seja.

Imagina se fosse possível que alguém intencionalmente modificasse sua conta. Agora os 10 Bitcoins que você possui viraram 1.

Blocos

Vamos começar a implementação pela parte mais fácil: os Blocos. A estrutura de um Bloco deve possuir os seguintes campos:

  • index
  • timestamp
  • hash
  • previousHash
  • data

Crédito: https://medium.com/@lhartikk/a-blockchain-in-200-lines-of-code-963cc1cc0e54

index e o timestamp são campos comuns em praticamente todos bancos de dados. O campo data serve principalmente pra guardar transações mas podemos também colocar outras informações. O hash é calculado internamente e serve pra manter a integridade de cada Bloco e a segurança de todo o sistema (como vamos ver no final do post). E por final, o previousHash é o elo de ligação que liga cada Bloco ao seu Bloco anterior.

Com isso, temos a primeira implementação de um Bloco:

const sha256 = require(crypto-js/sha256)
class Block {
constructor(index = 0, previousHash = null, data = Genesis block) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.hash = this.generateHash()
}
generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp).toString()
}
}
module.exports = Block
view rawblock.js hosted with ❤ by GitHub

A função generateHash usa a biblioteca externa crypto-js pra gerar o hash seguindo o padrão sha256.

Parece complicado, mas tudo o que você precisa saber é que essa função vai receber uma string como por exemplo:

foo

E vai retornar uma string encriptada:

2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae

Blockchain

Agora que já temos uma versão mínima de um Bloco, já podemos começar a construir o Blockchain, que como falei anteriormente é uma sequência de Blocos ligados entre si.

Com isso, essa é a primeira versão do Blockchain:

const Block = require(./block)
class Blockchain {
constructor() {
this.blocks = [new Block()]
this.index = 1
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data)
this.index++
this.blocks.push(block)
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

No construtor da classe, temos o array de Blocos inicializado já com o Genesis Block (o primeiro bloco criado no registro do Bitcoin). Adicionei também o index para poder incrementar toda vez que um novo Bloco for adicionado no Blockchain.

Além disso duas funções foram criadas:

  • getLastBlock
  • addBlock

A primeira é extremamente simples, ela serve pra pegar o último Bloco que foi criado.

A segunda é uma pouco mais complicada, mas também não é nada de outro mundo. Ela serve pra adicionar novos Blocos ao Blockchain.

Integridade

Apesar de a versão anterior já funcionar razoavelmente bem, precisamos adicionar alguma garantia de que o Blockchain não tenha sido alterado por algum ataque malicioso.

Precisamos adicionar uma nova função para checar a integridade do Blockchain:

isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}

Lembrando que para verificarmos a integridade do Blockchain precisamos garantir três características:

  • hash de cada Bloco foi gerado corretamente
  • index dos Blocos está em sequência
  • Os Blocos estão ligados entre si através dos hashes

Com essa simples função podemos testar se modificações maliciosas foram feitas e se o Blockchain deve ser invalidado:

const Blockchain = require(./blockchain)
const blockchain = new Blockchain()
blockchain.addBlock({ amount: 4 })
blockchain.addBlock({ amount: 50 })
console.log(blockchain.isValid()) // true
blockchain.blocks[1].data.amount = 30000 // ataque malicioso
console.log(blockchain.isValid()) // false

E finalmente com isso já temos uma primeira versão básica e funcional do Blockchain em JavaScript:

const Block = require(./block)
class Blockchain {
constructor() {
this.blocks = [new Block()]
this.index = 1
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data)
this.index++
this.blocks.push(block)
}
isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

Problemas

Apesar de já termos uma versão inicial funcionando, ainda podemos melhorar bastante a nossa implementação.

Um dos problemas com essa versão atual é que usuários podem criar novos Blocos de forma muito rápida, podendo invalidar o Blockchain, ou coisas ainda piores. Não vou entrar em muitos detalhes dessa particularidade da tecnologia, mas o post abaixo faz um excelente trabalho nesse sentido:

Explaining blockchain — how proof of work enables trustless consensus

Em resumo, precisamos de alguma ferramenta que não permita que usuários possam criar Blocos desenfreadamente.

Proof of Work

O conceito de Proof of Work, como o próprio nome já sugere, é um mecanismo que faz com que um usuário tenha um trabalho computacional significativo ao realizar determinada tarefa.

Essa ferramenta já era utilizada antes do Bitcoin ser inventado para evitar por exemplo spams e ataques DoS.

No Bitcoin, o Proof of Work funciona da seguinte forma: o hash que é gerado automaticamente em cada Bloco deve começar com uma quantidade X de zeros, dependendo da dificuldade geral do sistema.

Por exemplo, se a dificuldade geral do sistema for 1, esse hash é inválido porque não começa com um zero:

a5036427617139d3ad9bf650d74ae43710e36d4f63829b92b807da37c5d38e8d

Porém, esse outro hash é válido porque começa com um zero:

07da8bff6cfea68a3f0a5bafc9b24d07f503e2282db36ffb58d43f9f4857c54b

Sempre que um usuário for criar um novo Bloco, ele vai precisar criar diversos hashes até que um deles tenha a quantidade de zeros no começo fazendo com que a regra geral do sistema seja atendida.

Ah, o nome disso é Mineração.

Lembrando que quanto maior o número de zeros que devem estar no começo do hash, maior o poder computacional necessário para a tarefa.

Dito isso, vamos agora implementar a versão final do Blockchain com a mineração.

Primeiramente vamos alterar os Blocos.

class Block {
constructor(index = 0, previousHash = null, data = Genesis block, difficulty = 1) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.difficulty = difficulty
this.nonce = 0
this.mine()
}
/* */
}
view rawblock.js hosted with ❤ by GitHub

No construtor, adicionamos os campos difficulty (dificuldade geral do sistema) e nonce (quantidade de tentativas até que o hash correto seja criado). Além disso, temos também um chamada para a função mine.

mine() {
this.hash = this.generateHash()
while (!(/^0*$/.test(this.hash.substring(0, this.difficulty)))) {
this.nonce++
this.hash = this.generateHash()
}
}
view rawblock.js hosted with ❤ by GitHub

A função mine vai criar hashes até que a quantidade de zeros à esquerda do hash seja atentida.

Lembrando que para que os hashes criados sejam diferentes, devemos adicionar o campo nonce na função generateHash:

generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp + this.nonce).toString()
}
view rawblock.js hosted with ❤ by GitHub

Com isso temos a versão final do Blocos com a mineração:

const sha256 = require(crypto-js/sha256)
class Block {
constructor(index = 0, previousHash = null, data = Genesis block, difficulty = 1) {
this.index = index
this.previousHash = previousHash
this.data = data
this.timestamp = new Date()
this.difficulty = difficulty
this.nonce = 0
this.mine()
}
generateHash() {
return sha256(this.index + this.previousHash + JSON.stringify(this.data) + this.timestamp + this.nonce).toString()
}
mine() {
this.hash = this.generateHash()
while (!(/^0*$/.test(this.hash.substring(0, this.difficulty)))) {
this.nonce++
this.hash = this.generateHash()
}
}
}
module.exports = Block
view rawblock.js hosted with ❤ by GitHub

Agora basta alterarmos o Blockchain para que o campo difficulty seja passado para os Blocos:

const Block = require(./block)
class Blockchain {
constructor(difficulty = 1) {
this.blocks = [new Block()]
this.index = 1
this.difficulty = difficulty
}
getLastBlock() {
return this.blocks[this.blocks.length 1]
}
addBlock(data) {
const index = this.index
const difficulty = this.difficulty
const previousHash = this.getLastBlock().hash
const block = new Block(index, previousHash, data, difficulty)
this.index++
this.blocks.push(block)
}
isValid() {
for (let i = 1; i < this.blocks.length; i++) {
const currentBlock = this.blocks[i]
const previousBlock = this.blocks[i 1]
if (currentBlock.hash !== currentBlock.generateHash()) {
return false
}
if (currentBlock.index !== previousBlock.index + 1) {
return false
}
if (currentBlock.previousHash !== previousBlock.hash) {
return false
}
}
return true
}
}
module.exports = Blockchain
view rawblockchain.js hosted with ❤ by GitHub

E é só isso 🙂

Lembrando que o código está todo no GitHub.

Ah, se você quiser saber mais sobre o Blockchain:

Outras implementações:

Fonte: https://tableless.com.br/como-implementar-blockchain-em-javascript/?utm_source=tablelessRelatedLink

Web Speech API – Reconhecimento de voz com JavaScript

Imagine websites onde os usuários podem navegar pelas páginas ou preencher campos de formulário usando a sua voz e até mesmo interagir com a página enquanto dirige, sem tirar os olhos da estrada.

O reconhecimento de voz tem várias aplicações no mundo real. Muitas pessoas tornaram-se familiarizadas com este conceito graças a softwares como o Siri e S-Voice. Esta aplicação pode melhorar drasticamente a usabilidade dos websites, principalmente para deficientes visuais. Imagine websites onde os usuários podem navegar pelas páginas ou preencher campos de formulário usando a sua voz e até mesmo interagir com a página enquanto dirige, sem tirar os olhos da estrada.

 

 

O que é Web Speech API?

A Web Speech API foi lançada no final de 2012 e permite que os desenvolvedores forneçam a entrada de voz e recursos de saída de texto-para-voz em um navegador web. Esta API cuida da privacidade dos usuários, pois antes de deixar o site para acessar a voz através do microfone, o usuário deve explicitamente conceder a permissão. Curiosamente, o pedido de autorização é o mesmo que a API getUserMedia, apesar de não precisar da webcam. Se a página que executa esta API usa o protocolo HTTPS, o navegador solicita a permissão apenas uma vez.

 

 

Então veremos logo abaixo, um exemplo básico de como podemos implementar esta nova API aos nossos projetos:

Criando a primeira página com reconhecimento de voz:

Passo 1 – Estrutura HTML:

A estrutura HTML é bem simples, vejamos a marcação abaixo:

<p id="ola">Olá tableless, você falou:</p>

<button id=”rect”>Gravar</button> <span id=”unsupported” class=”hidden”>API not supported</span>

Onde:

  • Transcription – Onde se encontrará o texto informando oque o usuário falou
  • Rect – Botão para reconhecer a voz do usuário
  • unsupported – Caso a API não seja suportada pelo browser

Passo 2 – Testando

Como qualquer API, temos que verificar primeiramente se o browser suporta SpeechRecognition:

// Test browser support
window.SpeechRecognition = window.SpeechRecognition ||
window.webkitSpeechRecognition ||
null;

//caso não suporte esta API DE VOZ            
if (window.SpeechRecognition === null) {
    document.getElementById('unsupported').classList.remove('hidden');
}else {
    //......
}

Passo 3 – Métodos e propriedades

Depois de testar a compatibilidade da API, iremos instanciar o reconhecedor de  voz, usando o speechRecognition(). Como o código listado abaixo:

var recognizer = new window.SpeechRecognition();

Este objeto expõe os seguintes métodos:

  • onstart: Define um callback que é disparado quando o serviço de reconhecimento começou a ouvir o áudio com a intenção de reconhecer.
  • onResult: Define um callback que é disparado quando o reconhecedor de voz retorna um resultado.
  • onerror: Define um callback que é acionado quando ocorre um erro de reconhecimento de voz.
  • onend: Define um callback que é disparado quando o serviço foi desligado. O evento deve sempre ser gerado quando a sessão termina, não importa o que a razão.

Iremos criar uma varável que será responsável por exibir o texto que o usuário falou e também iremos definir a propriedade continuous = true, que faz com que o reconhecedor de voz não pare de ouvir, mesmo que tenha pausas do usuário.

var transcription = document.getElementById("transcription");

            //Para o reconhecedor de voz, não parar de ouvir, mesmo que tenha pausas no usuario
            recognizer.continuous = true;

Agora iremos definir a função “onresult” que define um callback que é disparado quando o reconhecedor de voz retorna um resultado.

recognizer.onresult = function(event){
                transcription.textContent = "";
                for (var i = event.resultIndex; i < event.results.length; i++) {
                    if(event.results[i].isFinal){
                        transcription.textContent = event.results[i][0].transcript+' (Taxa de acerto [0/1] : ' + event.results[i][0].confidence + ')';
                    }else{
                        transcription.textContent += event.results[i][0].transcript;
                    }
                }
            }

Vamos analisar este código um pouco mais detalhadamente:

transcription.textContent = “”;    Faz com que limpe o texto que se encontra dentro da “

for (var i = event.resultIndex; i < event.results.length; i++) {  Loop que pecorre o evento que contém o texto que o usuário falou.

Note que dentro deste loop, há uma condição, que verifica se o evento se encontra na última posição (event.results[i].isFinal), caso seja verdadeira, ele irá imprimir todo o texto, junto com a taxa de acerto, que vai de “0” até “1”. Caso seja falsa, ele vai adicionar mais texto na nossa div

Passo 4 – Anexando o evento de click

Agora iremos anexar um evento de click, ao nosso botão, segue 0 código abaixo :

document.querySelector("#rect").addEventListener("click",function(){
                try {
                    recognizer.start();
                  } catch(ex) {
                    alert("error: "+ex.message);
                  }
            });

Onde:

recognizer.start(); – Inicia o record ( a gravação );

catch(ex) {

alert(“error: “+ex.message);

} –  tratamento de log, caso exista, algum erro de gravação

É importante observarmos que o reconhecedor demora um pouco para poder interpretar a sua voz, mais ou menos uns 3 à 4 segundos, esta API ainda está em teste e que infelizmente até agora, só é  suportada no chrome,

Finalizando

Bem pessoal, essa foi uma breve introdução sobre Web Speech API. Futuramente irei trazer mais artigo

Disponibilizei o código no github e também disponibilizei uma demo.

Clique aqui para ver a demo online

Clique aqui, para ir ao código completo.

 

Fonte:https://tableless.com.br/web-speech-api-reconhecimento-de-voz-com-javascript/

 

 

 

 

 

Software para Windows de Eugene Muzychenko

Software comercial

Cabo de áudio virtual (VAC)

Driver de multimídia do Windows que cria um ” cabo virtual ” representado por dois dispositivos de forma de onda, entrada e saída, com ligação interna entre eles. Permite transferência de som direta e intocada entre diferentes aplicativos. Útil para gravar a saída de áudio do aplicativo em tempo real e salvar um fluxo de som de saída de aplicativos que não permitem gravá-lo diretamente no arquivo WAV. VAC é uma “versão de onda” do “cabo de loopback MIDI”, como os drivers Loopback do MultiMid ou do Hubi . Ao contrário do Total Recorder, você pode simplesmente salvar o fluxo de áudio, o VAC permite rotear em tempo real.,Foobar2000 , AIMP , Audacity , Audition , Skype , Flex-Radio etc.).

Cabo de áudio virtual 4 páginas (XP / 2k3 / Vista / Win 7/8 / 8.1 / 10)

Cabo de áudio virtual 3 páginas (9x / ME / NT4 / 2k / XP / 2k3)

Software grátis

Wave Clone

Ferramenta multimídia do Windows para compartilhar as portas Wave (MME) entre várias aplicações. Traz um recurso multi-cliente para qualquer dispositivo Wave. O Wave Clone é uma “versão de onda” dos “complementos de múltiplos clientes MIDI”, como os drivers de Loopback do MultiMid ou do Hubi .

Página Wave Clone (9x / ME / NT4 / 2k / XP / 2k3)

 

Manuais MIDI

Permite dividir seu teclado MIDI em dois manuais independentes (zonas), atribuir-lhes diferentes instrumentos MIDI e tocar as duas mãos ao mesmo tempo, produzindo peças de duas partes. Você não pode fazer isso usando um software de sequenciador popular.

Página de Manuales MIDI  (todos os sistemas)

 

FlushVol

Utilitário para liberar, uma vez ou periodicamente, buffers de arquivos de volume. Funciona como sync.exe de Mark Russinovich, mas enumera todos
os volumes fixos, incluindo montado em NTFS Mount Points . Pode ser instalado como um serviço para iniciar automaticamente e liberar buffers de volume com uma interfal dada.

Baixe FlushVol 1.4.2 (2k / XP / 2k3 / Vista / Win7 / 8/10 )

 

mscetool

O mscetool opera com o arquivo de cabeçalho MSCE dos arquivos WinCE CAB (um arquivo com extensão .000 que descreve o processo de instalação). O principal objetivo desse utilitário é mudar a arquitetura e / ou os campos do número de versão do WinCE no cabeçalho. Existem muitos programas que podem funcionar sob versões específicas do WinCE, mas são distribuídos em arquivos CAB com uma arquitetura forte e os números de versão mínima / máxima especificados.

Faça o download do mscetool 1.0 (2k / XP / 2k3 / Vista / Win7)

 

b000fftool

O b000fftool opera com arquivos de imagem gravados MS B000FF (MSBIN) contendo imagens do Windows CE / ROM móvel. Pode ser útil para corrigir valores de endereço de carga incorretos em imagens CE6 BIN produzidas por BOOOFF, XipPort, Remaker e ferramentas similares.

Baixe o b000fftool 1.0 (2k / XP / 2k3 / Vista / Win7)

 

tcctoolce

O tcctoolce executa algumas operações específicas para os dispositivos baseados em CPU ARCH da Telechips sob o WinCE (apenas a implementação de imagens instantâneas está implementada).

Baixe tcctoolce 1.0.1 (WinCE 4.2 ou superior)

 

TaskbarControlCE

TaskbarControlCE destina-se a controlar a aparência da barra de tarefas do Explorer em caso de alternar entre janelas normais e em tela cheia. Inicialmente desenvolvido para a estação multimídia do carro Createc / Joy-J-2619.

Baixar TaskbarControlCE 1.0.1 (WinCE 4.2 ou superior)

 

Driver SiLabs CP210x VCP para WinCE 4.2

Um driver VCP (Virtual Communication Port) para CP210x (CP2101, CP2102, CP2103, CP2104), chips USB para Serial Bridge fabricados pela Silicon Laboratories (anteriormente Cygnal). O driver cria COMn: porta serial virtual disponível para qualquer aplicativo de comunicação serial (emuladores de terminal, software de navegação GPS, etc.).

O driver funciona apenas em CPUs ARMV4 no Windows CE 4.2 (por exemplo, Windows Mobile 2003 SE ou Pocket PC 2003). Os drivers do CE 5.0 e 6.0 estão disponíveis no site do SiLabs .

Baixe cp210xvcp_ce42_2_0_1_0 (CE 4.2)

 

shrinkvd

shrinkvd é um utilitário de linha de comando para encadear arquivos de disco virtual VMware pré-alocados de acordo com um espaço realmente ocupado por partições. Útil para otimizar os hóspedes do Vista / Win7 / Win8.

Baixar shrinkvd 1.2 (todos os sistemas PC Windows)

 

pegue a senha

getpassword é um utilitário de linha de comando para solicitar uma senha do teclado, escondendo a entrada e retornando via saída padrão (por exemplo, para um arquivo de comando / lote).

Baixe o getpassword 1.0 (todos os sistemas PC Windows)

 

getfileinfo

getfileinfo é um utilitário de linha de comando para extrair e imprimir várias informações de arquivo (data, hora, versão, especificação). Os resultados da versão do arquivo podem ser úteis para criar nomes de arquivos versionados. Os qualificadores de especificação de arquivo podem ser úteis para extrair substituição de argumento de unidade, caminho, nome e extensão, como o processador de lote (cmd.exe), mas sem expandir caracteres curiosos para nomes de arquivos existentes. As peças de especificação extraídas contendo curingas podem ser usadas para processamento posterior de arquivos.

Baixe o getfileinfo 1.9 (todos os sistemas PC Windows)

 

MixerInfo

MixerInfo mostra todas as informações sobre um mixer de áudio fornecido.

Baixar MixerInfo (com código fonte)

 

ArrangeChildren

ArrangeChildren destina-se a organizar várias janelas filho na área de cliente da janela MDI do aplicativo. Ele pode ser usado para arrumar janelas de projeto em IDEs (ambientes de desenvolvedores integrados), como Visual Studio , Sound Forge , Photoshop e outros.

Download ArrangeChildren 1.00

Baixe ArrangeChildren 1.04

 

CopyFileFragm

CopyFileFragm é um utilitário de console destinado a manipular fragmentos de arquivos binários e expandir / encolher arquivos. Pode extrair um fragmento de arquivo para outro arquivo ou stdout, escrever um fragmento em outro arquivo no lugar, substituir / expandir arquivos etc.

Baixar CopyFileFragm 1.11

 

copywobuf

copywobuf é um utilitário de linha de comando do console que copia um arquivo (sem curingas), abrindo arquivos de origem e de destino com
FILE_FLAG_NO_BUFFERING para impedir o armazenamento em cache de arquivos. É útil copiar arquivos de / para pastas compartilhadas em convidados da VMware para evitar o bloqueio do arquivo host pelo processo vmware-vmx.exe.

Baixe copywobuf 1.3

 

waveinfo

waveinfo é um utilitário de linha de comando do console que mostra informações sobre arquivos RIFF / WAVE (.wav).

Baixe o waveinfo 1.3

VMWRefresh

O VMWRefresh permite que você use o SoftICE 3.x ou 4.x no Windows 2000 / XP executado no VMWare 4.5.1 forçando a janela de convidado do VMWare a atualizar periodicamente.

Faça o download do VMWRefresh 1.04

 

picoc para Win32

Picoc é um intérprete de linguagem C muito pequeno, projetado para sistemas baseados em UNIX. Existe uma porta para Win32 (x86 / x64).

Baixar picoc para Win32 2,2 m

 

RASPPPoE 0.98b patch de tempo limite

Um patch para os drivers do protocolo RASPPPeE escrito por Robert Schlabbach . Aumenta RASPPPoE tempo limite para 120..150 segundos para permitir sessão PPP a persistir durante a reconexão modem DSL.

Baixe o patch de tempo limite RASPPPo 0.98b

 

Fonte: http://software.muzychenko.net/eng/

DNALinux – Uma solução Linux para Bioinformática

Programas de bioinformática incluídos no DNALinux

 

 

O ApE- A Plasmid Editor
Funciona no Windows (testado em 98, XP, NT), OS X (10.3, 10.4 e 10.5) e Linux / Unix, destaca sites de restrição na janela de edição, mostra tradução, Tm,% GC, ORF de DNA selecionado em tempo real, lê os arquivos DNA Strider, Fasta, Genbank e EMBL, copiar e salvar gráficos como metarquivos do Windows (somente MS Windows) em outros recursos. Para mais informações, visite o website.

Web site: http://www.biology.utah.edu/jorgensen/wayned/ape/

Outros documentos:

Citação:

AutodockSuite 4.0.1

AutoDock é um conjunto de ferramentas de encaixe automatizadas. Ele é projetado para prever como pequenas moléculas, como substratos ou medicamentos candidatos, se ligam a um receptor de estrutura 3D conhecida. O AutoDock consiste de dois programas principais: AutoDock executa o encaixe do ligando para um conjunto de grades descrevendo a proteína alvo; O AutoGrid pré-calcula essas grades. Além de usá-los para encaixe, as redes de afinidade atômica podem ser visualizadas. Isso pode ajudar, por exemplo, a orientar químicas sintéticas orgânicas para designar melhores aglutinantes.

Web site: http://autodock.scripps.edu/

Outra documentação:

Citação: Morris GM, Goodsell DS, Huey R, Olson AJ. Distribuição automated docking de ligandos flexíveis para proteínas: aplicações paralelas do AutoDock 2.4. J Comput Aided Mol Des. 1996 Ago; 10 (4): 293-304. Pubmed


O Biopython é um conjunto de ferramentas livremente disponíveis para computação biológica escrita em Python por uma equipe internacional de desenvolvedores.
É um esforço colaborativo distribuído para o desenvolvimento de bibliotecas e aplicações Python que abordam as necessidades dos trabalhos atuais e futuros em bioinformática. O código fonte está disponível sob a licença Biopython, que é extremamente liberal e compatível com quase todas as licenças do mundo. Trabalhamos junto com a Open Bioinformatics Foundation, que generosamente fornece espaço na web e CVS para o projeto.

Web site: www.biopython.org

Outra documentação: Bassi S (2007) A Primer on Python for Life Science Researchers. PLoS Comput Biol 3 (11): e199. doi: 10.1371 / journal.pcbi.0030199 
Python para Bioinformáticalivro de Sebastian Bassi

Citação: Cock PJ, Antao T, Chang JT, Chapman BA, Cox CJ, Dalke A, Friedberg I, Hamelryck T, Kauff F, Wilczynski B e Hoon MJ. Biopython: ferramentas Python livremente disponíveis para biologia molecular computacional e bioinformática. Bioinformática 2009 1 de junho; 25 (11) 1422-3. doi: 10.1093 / bioinformática / btp163 pmid: 19304878. Pubmed

 

Blast 2.2.20

A Ferramenta de Pesquisa de Alinhamento Local Básico (BLAST) encontra regiões de similaridade local entre sequências. O programa compara sequências de nucleotídeos ou proteínas para bases de dados de sequências e calcula a significância estatística dos fósforos. O BLAST pode ser usado para inferir relações funcionais e evolutivas entre sequências, bem como ajudar a identificar membros de famílias de genes.

Site: http://blast.ncbi.nlm.nih.gov/

Outros documentos:

Citação: Altschul, Stephen F., Thomas L. Madden, Alejandro A. Schaffer, Jinghui Zhang, Zheng Zhang, Webb Miller e David J Lipman (1997), “Gapped BLAST e PSI-BLAST: uma nova geração de programas de pesquisa de banco de dados de proteína”, Nucleic Acids Res. 25: 3389-3402.

 

ClustalX

Alinhamento múltiplo de sequências de ácido nucleico e proteína.
Clustal X é uma interface do Windows para o programa de alinhamento de sequências múltiplas ClustalW. Ele fornece um ambiente integrado para realizar alinhamentos múltiplos de seqüências e perfis e analisar os resultados. O alinhamento da seqüência é exibido em uma janela na tela. Um esquema de coloração versátil foi incorporado, permitindo destacar os recursos conservados no alinhamento. Os menus pull-down na parte superior da janela permitem selecionar todas as opções necessárias para o alinhamento de múltiplas sequências e perfis tradicionais.

Site: http://www.clustal.org/

Outros documentos:

Citação: Jeanmougin, F., Thompson, JD, Gouy, M., Higgins, DG e Gibson, TJ (1998) Alinhamento de seqüências múltiplas com Clustal X. Tendências Biochem Sci, 23, 403-5.

 

O EMBOSS é “A Suite Européia de Software de Biologia Molecular Européia”. O EMBOSS é um pacote gratuito de análise de software de código aberto especialmente desenvolvido para as necessidades da comunidade de usuários de biologia molecular (por exemplo, EMBnet). O software lida automaticamente com dados em uma variedade de formatos e até permite a recuperação transparente de dados de sequência da web. Além disso, à medida que as extensas bibliotecas são fornecidas com o pacote, é uma plataforma para permitir que outros cientistas desenvolvam e liberem softwares com um verdadeiro espírito de código aberto. O EMBOSS também integra uma série de pacotes e ferramentas atualmente disponíveis para a análise de seqüências em um todo sem costura. O EMBOSS quebra a tendência histórica para pacotes de software comercial.

Web site: www.emboss.org

Outra documentação:

Citação: Arroz, P. Longden, eu. e Bleasby, A. EMBOSS: The European Molecular Biology Open Software Suite (2000) Tendências em Genética 16, (6) pp276-277.

 

EMNU-1.05
emnu exibe um menu simples baseado em caracteres que permite que você exiba os nomes dos programas em relevo e selecione-os. Ele também exibe os nomes dos arquivos em seu diretório atual e permite exibir seus conteúdos, copiá-los, excluí-los e fazer outras coisas com eles. Emnu permite mover os menus de programas ou arquivos usando as teclas de seta. Pressionando RETURN quando você selecionou um item executará um programa ou exibirá um arquivo.

Web site: http://web.mit.edu/emboss_v4.0.0/www/embassy/emnu/emnu.html

Outros documentos:

Citação:

ESIM4-1.0.0
Alinhar um mRNA a um

site de sequência de DNA genômico : http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/esim4/esim4.html

Outros documentos:

Citação: Florea L, Hartzell G, Zhang Z, Rubin GM, Miller W. “Um programa de computador para alinhar uma sequência de cDNA com uma sequência de DNA genômico”. Genoma Res 1998 Sep; 8 (9): 967-74

 

FinchTV – Visualizador de rastreamento de cromatografia de sequência de DNA. 
O utilitário FinchTV para visualização de arquivos de cromatograma é um aplicativo autônomo que os pesquisadores usam para visualizar e editar facilmente seus dados de seqüência com interatividade dinâmica.

Web site: http://www.geospiza.com/Products/finchtv.shtml

Outros documentos:

Citação:

HMMER-2.3.2 Os
modelos escondidos do Markov do perfil (HMMs do perfil) podem ser usados ​​para fazer pesquisa de banco de dados sensível usando descrições estatísticas do consenso de uma família de seqüência. HMMER é uma implementação livremente distribuível do software HMM de perfil para análise de seqüência de proteínas.

Web site: http://hmmer.janelia.org/

Outra documentação:

Citação: A teoria por trás do perfil HMMs: R. Durbin, S. Eddy, A. Krogh e G. Mitchison, análise de seqüência biológica: modelos probabilísticos de proteínas e ácidos nucleicos, Cambridge University Press, 1998. IPRSCAN-4.3.1 Web site: documentação adicional: Citação:

Kalign 2.03
Kalign é uma ferramenta de linha de comando para realizar o alinhamento múltiplo de seqüências biológicas. Ele emprega o algoritmo Wu-Manber string-matching, para melhorar tanto a precisão quanto a velocidade do alinhamento. Ele usa abordagem de alinhamento global e progressivo, enriquecendo empregando um algoritmo aproximado de correspondência de cadeias para calcular distâncias de seqüência e incorporando combinações locais no alinhamento de outra forma global. Nas comparações feitas por seus autores, Kalign era cerca de 10 vezes mais rápido do que o ClustalW e, dependendo do tamanho do alinhamento, até 50 vezes mais rápido do que os métodos iterativos populares.

Web site: http://msa.sbc.su.se/cgi-bin/msa.cgi

Outra documentação:

Citação: Timo Lassmann e Erik LL Sonnhammer. Kalign – um algoritmo de alinhamento de sequências múltiplo preciso e rápido. BMC Bioinformatics 2005, 6: 298doi: 10.1186 / 1471-2105-6-298

MEMENEW-0.1.0 Web site de
detecção de motivos

http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/memenew/ememe.html

MIRA-2.8.2
O assembler do fragmento mira genome é um montador especializado para projetos de seqüenciamento classificados como “difíceis” devido ao alto número de repetições similares. Para transcrições de EST, miraEST é especializada na reconstrução de transcritos de ARNm prístinos enquanto detecta e classifica polimorfismos de nucleotídeos únicos (SNP) ocorrendo em diferentes variações.
O sistema de montagem está usando estratégias multipassos iterativas centradas no uso de regiões de alta confiança dentro de seqüências e tem uma estratégia de retorno para usar regiões de baixa confiança quando necessário.

Site: http://chevreux.org/projects_mira.html

 

MSE-1.0.0 Web site do 
Editor de Sequências Múltiplas

http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/mse/mse.html

 

MYEMBOSS-6.0.0 O
MYEMBOSS fornece uma estrutura de diretório e stubs de makefile para desenvolver suas próprias aplicações mais facilmente do que em versões anteriores a 3.0.0.

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/myemboss/

 

NCBI Toolkit

O NCBI Toolkit é uma coleção de utilitários desenvolvidos para a produção e distribuição do GenBank, Entrez, BLAST e serviços relacionados pelo Centro Nacional de Informação Biotecnológica. Inclui as ferramentas populares de bioinformática formatdb e blastall.

Web site: http://www.ncbi.nih.gov/IEB/ToolBox/SDKDOCS/INDEX.HTML

 

Polyxmass 0.9.7

PHYLIP (o pacote de inferência PHYLogeny) é um pacote de programas para inferir filogenias (árvores evolutivas). Está disponível gratuitamente na Internet e escrito para trabalhar em tantos tipos diferentes de sistemas de computador quanto possível.
Felsenstein, J. 2005. PHYLIP (Phylogeny Inference Package) versão 3.6. Distribuído pelo autor. Departamento de Ciências do Genoma, Universidade de Washington, Seattle.

Web site: http://evolution.gs.washington.edu/phylip.html

 

polyxmass é um conjunto de software para espectrometria de massa (bio) de polímero que é o Software Livre desenvolvido no GNU / Linux. Permite a definição de química de polímeros e a simulação / análise de dados espectrométricos de massa obtidos em (bio) polímeros.

Citação: Filippo Rusconi, GNU polyxmass: uma estrutura de software para simulações de espectrometria de massa de analitos lineares (bio-) poliméricos. BMC Bioinformatics 2006, 7: 226doi: 10.1186 / 1471-2105-7-226

 

Primer3 1.1.4 / Primer3plus (GUI da Web para primer3) O 
Primer3 é um programa amplamente utilizado para projetar iniciadores de PCR (PCR = “Reação em Cadeia de Polimerase”). O PCR é uma ferramenta essencial e omnipresente em genética e biologia molecular. O Primer3 também pode projetar sondas de hibridação e iniciadores de seqüenciamento.

Web site: http://primer3.sourceforge.net/

Outra documentação:

Citação: Rozen S, Skaletsky H (2000) Primer3 na WWW para usuários em geral e para programadores biologicos. Em: Krawetz S, Misener S (eds) Métodos e Protocolos de Bioinformática: Métodos em Biologia Molecular. Humana Press, Totowa, NJ, pp 365-386

 

Pymol 1.0r2 O
PyMOL é um sistema de visualização molecular de código aberto, criado por Warren Lyford DeLano e comercializado pela DeLano Scientific LLC, que é uma empresa de software privada dedicada à criação de ferramentas úteis que se tornam universalmente acessíveis para comunidades científicas e educacionais.

Site: http://www.pymol.org/

 

Rasmol 2.7.3.1
RasMol é um programa de gráficos moleculares destinado à visualização de proteínas, ácidos nucleicos e moléculas pequenas.

Site: http://www.rasmol.org/

 

 

readseq 1.7
Lê e grava seções nucleicas / proteínas em vários formatos. Os arquivos de dados podem ter múltiplas seqüências.

 

Sigma Align 1.1.1
A maioria das ferramentas para o alinhamento de sequências múltiplas são focadas no alinhamento da seqüência de proteínas ou da sequência de DNA que codifica a proteína. Sigma (“Alinhamento múltiplo codicioso simples”) é um programa de alinhamento com um novo algoritmo e esquema de pontuação projetado especificamente para seqüência de DNA não codificante.

Site: http://www.imsc.res.in/~rsidd/sigma/

Outros documentos:

Citação: Rahul Siddharthan, “Sigma: alinhamento múltiplo de sequências de DNA não codificantes fracamente conservadas”, BMC Bioinformatics 7: 143 ( 2006). Pubmed

 

SIGNATURE-0.1.0

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/signature/

 

STRUCTURE-0.1.0

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/structure/

 

TREEFINDER calcula árvores filogenéticas a partir de seqüências moleculares. O programa infere árvores mesmo grandes por máxima probabilidade sob uma variedade de modelos de evolução de seqüência. Ele aceita dados de nucleotídeos e aminoácidos e leva em consideração a heterogeneidade da taxa. Modelos separados podem ser assumidos para partições de dados definidas pelo usuário, taxas separadas, comprimentos de borda separados, composições de caracteres separadas. Todos os parâmetros podem ser estimados a partir dos dados. A pesquisa de árvores pode ser guiada por restrições topológicas fornecidas pelo usuário e iniciar árvores.

Web site: http://www.treefinder.de/

Outros documentos: o manual está disponível em formato pdf .

Citação: Jobb, G., A. von Haeseler e K. Strimmer. TREEFINDER: Um poderoso ambiente de análise gráfica para filogenética molecular. 2004. BMC Evolutionary Biology. Pubmed

 

TreeView 0.5.1
TreeView fornece uma maneira simples de ver o conteúdo de um arquivo de árvore de formato NEXUS, PHYLIP, Hennig86, Clustal ou outro formato. Enquanto PAUP e MacClade possuem excelentes instalações de impressão de árvores, pode haver momentos em que você só deseja ver as árvores sem ter que carregar o conjunto de dados de que foram geradas. O pacote PHYLIP contém programas de desenho de árvores que oferecem uma maior variedade de árvores que o TreeView, mas são um tanto desgastantes de usar. O próximo PAUP * para Windows não possui uma interface gráfica, portanto, o TreeView permite que você crie árvores de qualidade de publicação a partir de arquivos PAUP, diretamente ou gerando arquivos gráficos para edição por outros programas.

Web site: http://taxonomy.zoology.gla.ac.uk/rod/treeview.html

Outra documentação:

Citação: Page, RDM 1996. TREEVIEW: uma aplicação para exibir árvores filogenéticas em computadores pessoais. Aplicações informáticas nas Biociências 12: 357-358.

 

 

TOPO-1.0.0
TOPO cria uma imagem de uma proteína transmembranar.

Web site: http://saf.bio.caltech.edu/hhmi_manuals/solaris/embassy_apps/topo/topo.html

 

Vienna RNA 1.8.25

O Vienna RNA Package consiste em uma biblioteca de código C e vários programas autônomos para a predição e comparação de estruturas secundárias de RNA.
A predição da estrutura secundária do RNA através da minimização de energia é a função mais utilizada na embalagem. Nós fornecemos três tipos de algoritmos de programação dinâmica para a predição da estrutura: o algoritmo mínimo de energia livre de (Zuker & Stiegler 1981) que produz uma única estrutura ótima, o algoritmo de função de partição de (McCaskill 1990) que calcula as probabilidades de pares de bases no conjunto termodinâmico, e o algoritmo de dobragem sub-óptimo de (Wuchty et.al 1999) que gera todas as estruturas sub-ótimas dentro de uma determinada faixa de energia da energia ideal. Para a comparação de estrutura secundária, o pacote contém várias medidas de distância (dissimilaridades) usando o alinhamento de cordas ou a edição de árvores (Shapiro & Zhang, 1990). Finalmente, fornecemos um algoritmo para projetar seqüências com uma estrutura predefinida (dobra inversa).

Web site: http://www.tbi.univie.ac.at/RNA/

Outros documentos:

Citação: Ivo L. Hofacker, Walter Fontana, Peter F. Stadler, L. Sebastian Bonhoeffer, Manfred Tacker e Peter Schuster. Folding Rápido e Comparação de Estruturas Secundárias de RNA. Apareceu em: Monatsh.Chem. 125: 167-188 (1994).

 

 

Faça o download do DNALinux

DNALinux Virtual Desktop. Python for Bioinformatics Edition (NOVO! Jun 2009)

Instruções de instalação

  1. Baixe o arquivo torrent .
  2. Faça o download do DNALinux usando o torrent com um programa compatível com bittorrent como “Bittorrent”, Bittorrnado, Vuze ( veja aqui para obter uma lista completa )
  3. Faça o download do VMWare Free Player
  4. Baixar 7zip uncompressor
  5. Descompacte DNALinux.7z usando o 7zip e reproduza o arquivo vmk com o VMWare Player.

Download direto no RapidShare (12 partes):

Instrução para arquivos baixados do Rapidshare:

Para juntar as peças no Windows:

copiar / b dbasea * dnalinux.7z

Para juntar as peças no Linux:

gato dbasea *> dnalinux.7z

Soma de verificação MD5: f75e88f48e08161be62b70a8ef465e17

Versão antiga (não suportada):

Servidor DNALinux

Nota: A nova versão (VDE Python para Bioinformatcs) já é um servidor, portanto a edição do servidor é interrompida.

 

 

 

 

 

 

 

 

Fonte: http://www.dnalinux.com/installedsoftware.html

Hyperledger

 

Hyperledger (ou o “Projeto Hyperledger”) é um projeto colaborativo envolvendo várias indústrias, iniciado em dezembro de 2015 pela Linux Foundation,[1] seu objetivo é suportar livros razão distribuídos com base na Blockchain. O seu foco é livros razão feitos para suportar transações de indústrias globais, incluindo as principais empresas de tecnologia, financeiras e logísticas, com o objetivo de melhorar vários aspectos da performance e robustez.[2] O projeto aspira unir um número de tentativas independentes para desenvolver protocolos e padrões abertos, provendo um framework modular que suporta componentes diferentes para usuários diferentes. Isso inclui uma variedade de blockchains, cada uma com seu consenso, modelos de persistência, e serviços para identidade, controle de acesso e contratos.

Histórico

Em Dezembro de 2015, a Linux Foundation anunciou a criação do projeto Hyperledger. Os primeiros fundadores do projeto foram anunciados em Fevereiro de 2016, e mais 10 membros que compõem o conselho de administração foram anunciados em 29 de Março.[3] Em 19 de Maio, Brian Behlendorf foi apontado como diretor executivo do projeto.[4]

No inicio de 2016, o projeto começou a aceitar propostas para bases de código e outras tecnologias a serem incubadas, para potencial inclusão como componentes centrais do Hyperledger. Uma das primeiras propostas foi para uma base de código que combina trabalhos prévios feitos pela Digital Asset Holdings (Blockstream’s libconsensus) e a OpenBlockchain da IBM.[5]Posteriormente, esse projeto foi renomeado para Fabric.[6] Em maio, o livro razão distribuído da Intel (Sawtooth) também foi incubado.[7]

Membros

Os primeiros membros da iniciativa incluem empresas que trabalham com blockchain (Blockchain, ConsenSysR3), outras empresas tecnológicas (CiscoDigital Asset HoldingsFujitsuHitachiIBMIntelNECNTT DATARed HatVMware), empresas financeiras (ABN AMROANZ BankBNY MellonCLS Group, CME GroupThe Depository Trust & Clearing Corporation (DTCC), Deutsche Börse GroupJ.P. MorganState StreetSWIFTWells Fargo), e outras (AccentureCalastone, Credits, GuardtimeIntellectEUSymbiont).

Motivação do projeto

Os primeiros membros da iniciativa incluem empresas que trabalham com blockchain (Blockchain, ConsenSysR3), outras empresas tecnológicas (CiscoDigital Asset HoldingsFujitsuHitachiIBMIntelNECNTT DATARed HatVMware), empresas financeiras (ABN AMROANZ BankBNY MellonCLS Group, CME GroupThe Depository Trust & Clearing Corporation (DTCC), Deutsche Börse GroupJ.P. MorganState StreetSWIFTWells Fargo), e outras (AccentureCalastone, Credits, GuardtimeIntellectEUSymbiont).

Motivação do projeto

De acordo com o Whitepaper do Hyperledger [8]:

As a fledgling technology, existing blockchain implementations have fallen short of meeting the multitude of requirements inherent in the complex world of business transactions. Scalability challenges, and the lack of support for confidential and private transactions, among other limitations, make its use unworkable for many business-critical applications. […] To meet the varied demands of the modern marketplace, Hyperledger has been designed for a broad array of industry-focused use cases, thereby extending the work of the pioneers in the field by addressing the existing shortcomings.

Em outras palavras, baseado no cenário atual de requisitos da indústria, foi identificado que as implementações atuais de blockchain não são suficientes. Problemas de escalabilidade, falta de suporte para transações privadas e outras limitações são citados como os principais culpados. A proposta do Hyperledger é justamente suprir esses requisitos a partir de uma série de casos de uso. A ideia também consiste de estender trabalhos existentes com o objetivo de mitigar as suas limitações. Vale destacar que o Hyperledger tem o foco na indústria, mais especificamente nas relações B2B e B2C.[8]

Objetivos

O objetivo principal do Hyperledger é criar uma plataforma útil, fácil de usar e robusta onde qualquer individuo interessado em construir um software baseado em blockchain pode usa-lá como base. Por motivos práticos, o Hyperledger pode nunca alcançar esse ideal que cobre todos os casos possíveis, mas o objetivo do time é chegar o mais perto possível.[8]

De maneira mais tangível, o projeto também define objetivos mais específicos como: modularidade, extensibilidade, facilidade de uso, variedade de métodos criptográficos. Cada um desses objetivos contribui para a visão geral do Hyperledger. Por exemplo, a modularidade contribui para a interoperabilidade entre sistemas que, por sua vez, potencializa a flexibilidade do projeto, e aumenta a cobertura de casos. A extensibilidade também contribui para aumentar a cobertura de novos casos, já que funcionalidades novas podem ser adicionadas.[8]

A conceito da modularidade é importante porque incentiva o desenvolvimento externo. Uma empresa não relacionada pode desenvolver novos módulos e contribuir para a melhora de módulos existentes. Generalizando, deve ser possível construir uma blockchain que não usa nenhum componente central do Hyperledger, mas ainda assim, se encaixar no seu framework. A troca de componentes a fim de satisfazer requisitos específicos também é um conceito central do Hyperledger. Por exemplo, alguns casos pedem um algoritmo rápido de consenso que requer alguma confiança, enquanto outros casos podem pedir menos velocidade com mais confiança.[8]

A extensibilidade e modularidade se provam como requisito central do projeto porque é inviável prever todos os usos futuros do Hyperledger e de tecnologias blockchain de uma maneira geral. Facilitar as contribuições externas pode incentivar o envolvimento de pessoas que contribuirão e usarão o Hyperledger.[8]

Requisitos propostos

Transações privadas e contratos confidenciais

O Hyperledger pretende suportar uma variedade de ferramentas criptográficas que devem garantir a presença de confidencialidade e privacidade. Essas ferramentas não devem prejudicar as propriedades de privacidade. Alguns casos de uso requerem confidencialidade mais básicas e otimizadas para performance que não são adequadas para o uso financeiro. O objetivo é suportar tanto o caso otimizado par performance quanto os casos mais sofisticados que pedem algoritmos criptográficos mais complexos.[8]

Identidade e auditabilidade

Em adição as transações privadas e confidenciais, o conceito de identidade baseado numa infraestrutura de chave pública completa os algoritmos criptográficos provendo a confidenciabilidade do Hyperledger. Além da infraestrutura de chave pública, o Hyperledger também deve prover suporte a uma documentação compreensível e imutável sobre essas identidades – incluindo os requisitos de confidenciabilidade associada a elas. O objetivo da documentação é suportar os casos que envolvem troca de identidade e auditoria. É importante notar que sempre deverá ser respeito o contrato inicial sobre a anonimidade da identidade. Por exemplo, se é previso que certa entidade é totalmente anonima, a documentação não incluirá nada que quebre esse acordo.[8]

Interoperabilidade

Como o Hyperledger propõe a utilização de vários componentes independentes, a interoperabilidade é proposta para que a interação entre esses elementos ocorra apesar de possíveis implementações fundamentalmente diferentes. Por exemplo, é esperado que haja a cooperação entre mais de um tipo de blockchain. Dessa forma, é dito que existe interação quando informação é trocada e utilizada por esses componentes. Para prover esse caso de uso, é definido um protocolo que permite a comunicação entre 2 ou mais blockchains.[8]

Portabilidade

A portabilidade em um nível de infraestrutura garante que o projeto Hyperledger funcione da mesma maneira em ambientes computacionais heterogêneos. O valor da portabilidade é explicitado ao ressaltar que o projeto deverá rodar com base numa grande combinação de blockchains, falhar em prover a portabilidade fere um principio geral do Hyperledger. A portabilidade em um nível de arquitetura tem significado parecido com o de modularidade: significa abstrair as interfaces dos componentes centrais para que não haja acoplamento de ambientes. Por exemplo, o componente de contratos inteligentes pode ser movido para uma unidade diferente de produção sem que haja necessidade de mudança a esse componente. [8]

Arquitetura

A arquitetura geral do Hyperledger consiste de 4 categorias:

  • Identidade (Identity)
  • Política (Policy)
  • Blockchain e contratos inteligentes (Smart Contracts)

De uma forma geral, essas categorias possuem responsabilidades específicas: a identidade é responsável por identificar as entidades participantes, a policy é responsável por regular o acesso e responsabilidades dessas entidades e o blockchain provê o serviço p2p que guarda o estado do sistema. Vale destacar que essas categorias são divisões lógicas do software e não necessariamente significam serviços fisicamente separados.[8]

Serviços de identidade

O requisito deste componente é identificar os componentes participantes da rede. Esses componentes incluem organizações participantes, validadores e transactors; Objetos contidos no livro razão e componentes mais tangíveis como: redes, servidores e ambiente de execuções.[8]

Serviços de política 

Os serviços de política permitem o gerenciamento das políticas de acesso ao sistema. Algumas dessas políticas incluem o gerenciamento do registro de novos membros e o controle de suas entradas e saídas. Esse serviço também é responsável pelo níveis de privacidade e as políticas de confiabilidade, responsabilidade e consenso. [8]

Blockchain

Os serviços de blockchain consistem de 3 partes:

  • Protocolo P2P.
  • Livro razão distribuído.
  • Gerenciador de Consenso.

O protocolo P2P funciona em cima da infraestrutura atual da internet e provê as capacidades de intercomunicação do sistema. O livro razão distribuído é a parte central do sistema e tem características parecidas com a de outros sistemas de criptomoedas. Por exemplo, o livro razão é responsável por manter e processar o estado do sistema e isso também é comum a bitcoin. Outras responsabilidades do livro razão distribuído sob o contexto do Hyperledger incluem: validar transações; calcular o hash de toda a base de dados de forma eficiente após cada bloco; minimizar a quantidade de dados necessários necessários para uma participante operar.[8]

Por fim, o gerenciador de consenso provê uma abstração para que outras partes do sistema utilizem os algoritmos de consenso de forma transparente. A ideia central é facilitar o uso e ao mesmo tempo prover um sistema flexível o suficiente para que novos procedimentos de consenso também possam ser adicionados.[8]

Incubação de projetos

Como um dos objetivos do Hyperledger é agregar contribuições externas, é adotada uma política de incubação para o gerenciamento dessas contribuições. Unidades de trabalhos são chamados de Projetos, e esses Projetos possuem um ciclo de vida [9]:

  • Proposta
  • Incubação
  • Maturidade
  • Depreciado
  • Fim de vida

Metodologias de gerenciamento similares são comuns a outros projetos open source, como o eclispe,[10] apache [11] e o OSGEO.[12] Até Julho de 2016, o Hyperledger possui dois projetos em fase de incubação, o Fabric e o Sawtooth.[13]

Sawtooth

O projeto Sawtooth, consiste na implementação de uma plataforma para construir e rodar livros razões distribuídos. O seu objetivo de modularidade é alinhado ao Hyperledger e é um dos motivos pela sua incubação. Diferente do Bitcoin, a proposta do Sawtooth é oferecer flexibilidade, desde transferências internacionais até aplicações de internet das coisas.[14]

Fabric

O fabric também é um projeto de tecnologias blockchain que oferece a possibilidade de encaixar várias implementações para certas funcionalidades. A versão de preview disponível em Julho de 2016 possui as seguintes features[15]:

  • Blockchain permissiva com finalidade imediata
  • Ambientes para a execução de contratos inteligentes
  • Módulos de consenso PBFT, NOOPS e SIEVE
  • Framework de eventos que suporta eventos predefinidos e customizados
  • SDK Client e API REST Básicas e Ferramentas CLI

Nessa mesma versão, estão presentes alguns BUGs e limitações, como [15]:

  • Alto tempo de resposta depois de testes de estresse.
  • Não possui eventos para peers no SDK.
  • Atributos no TCert não estão encriptados.

Referências

  1.  «Linux Foundation Unites Industry Leaders to Advance Blockchain Technology». 17 de dezembro de 2015
  2. Ir para cima «Linux Foundation’s Hyperledger Project Announces 30 Founding Members and Code Proposals To Advance Blockchain Technology». 9 de fevereiro de 2016. Consultado em 17 de fevereiro de 2016
  3. Ir para cima «Open Source Blockchain Effort for the Enterprise Elects Leadership Positions and Gains New Investments». 29 de março de 2016
  4. Ir para cima «Founder of the Apache Software Foundation Joins Linux Foundation to Lead Hyperledger Project». 19 de maio de 2016
  5. Ir para cima «Incubating Project Proposal: Joint DAH/IBM proposal». Tamas Blummer, Christopher Ferris. 29 de março de 2016. Consultado em 21 de junho de 2016
  6. Ir para cima «hyperledger/fabric»GitHub. Consultado em 23 de junho de 2016
  7. Ir para cima «Sawtooth Lake Hyperledger Incubation Proposal». Mic Bowman, Richard Brown. 14 de abril de 2016. Consultado em 21 de junho de 2016
  8. ↑ Ir para:a b c d e f g h i j k l m n o «Hyperledger Whitepaper». Consultado em 5 de julho de 2016
  9. Ir para cima «Hyperledger Project Lifecicle». Consultado em 6 de julho de 2016
  10. Ir para cima «Eclipse Development Process 2015». Consultado em 6 de julho de 2016
  11. Ir para cima «Apache Incubator». Consultado em 6 de julho de 2016
  12. Ir para cima «OSGEO Incubation Process». Consultado em 6 de julho de 2016
  13. Ir para cima «Hyperledger github». Consultado em 6 de julho de 2016
  14. Ir para cima «Sawtooth introduction». Consultado em 6 de julho de 2016
  15. ↑ Ir para:a b «Fabric Releases». Consultado em 6 de julho de 2016

Bitcoin e Blockchain para leigos

O ativo financeiro digital mais famoso da internet é o BitcoinQue funciona em cima de uma tecnologia chamada “Blockchain”, que registra todas as transações envolvendo bitcoins, eletronicamente numa espécie de livro-razão imutável e criptografado.

Uma das característica do Bitcoin é mecanismo é que o registro dos negócios não é centralizado ou administrado por uma única instituição. O histórico das transações é armazenado em blocos que somente se encaixam se for utilizada certo tipo de assinatura digital.

E para haver a efetiva liquidação das operações, a cadeia de transações deve ser validada pelos demais participantes do mercado(mineradores, que emprestam sua força computacional para validar transações e criar novos bitcoins na rede, com isso ganham frações de bitcoins), para isso precisam confirmar a veracidade da chave pública divulgada. O desenvolvimento dessa intrincada engrenagem é atribuído a uma pessoa – ou a um grupo – que usou o pseudônimo de SatoshiNakamoto. Tecnologia criada em 2008, que seu autor até hoje permanece no anonimato.

Na prática a tecnologia do “Blockchain” implica mudança significativa na forma como a internet pode ser utilizada. Como distribuir e compartilhar informações, passa ser possível a transferência eletrônica da propriedade de ativos.

Por essa razão, a expectativa é que, no futuro próximo, será construída uma internet dos valores. Nesse novo ambiente, ao enviar um arquivo contendo determinado código, a propriedade do bem será automaticamente transferida.

Com o Blockchain já é possível imaginar diversos usos para a tecnologia, tais como contratos inteligentes onde se encerram e automaticamente, operações no mercado financeiro onde você poderá custodiar suas ações e trocá-las, transações de comércio internacional e a compra e venda de imóveis, registros de casamentos, nascimento e falecimento.

Hoje já existem 16,5 milhões de bitcoins no mercado. Por definição, o estoque máximo de bitcoins emitidos será de 21 milhões de unidades.

Nota: “Um” bitcoin é dividido em oito casas decimais (1.00000000), fracionando o seu valor, sendo assim você pode comprar frações de bitcoins, que no momento que foi escrito esse texto, a cotação atual comprando R$ 50,00 reais daria por volta de 0,00600000 bitcoins.

Os verificadores das transações, chamados no jargão do mercado de mineradores, podem criar bitcoins conforme o volume de cálculos executados, a rede dificulta a quantidade de bitcoins criados, pela quantidade de mineradores trabalhando nela e com tempo pelo seu processo deflacionário, escassez. A rede de mineradores é que garante o processamento das transações e a segurança do mercado(mineradores, são quaisquer pessoas que emprestam sua força computacional para validar e registrar as transações).

Leia também  Novo regulamento de criptomoedas da Coréia do Sul proíbe completamente Marketing Multinível

À prova de balas e transparente

Ninguém foi capaz, pelo menos por enquanto, de invadir o sistema para criar bitcoins falsos. Isso tem garantido a confiança na segurança da estrutura e atraído novos participantes.

Nas operações bancárias tradicionais, o Banco é a instituição responsável pelo controle do livro caixa das transações. E cobra altas tarifas por esse serviço, e sem contar que a qualquer momento pode “confiscar a sua poupança”, como já vimos há tempos atrás.

Por exemplo, para enviar um TED ou DOC, o Banco exige o pagamento de determinada remuneração. O mesmo acontece para manter a conta corrente ativa e emitir extratos, já o Bitcoin, você não precisa pagar taxas de custódia, manutenção, extratos, apenas paga pela sua transferência, uma taxa irrisória.

As operadoras de cartão de crédito também cobram para processar as transações entre lojistas e consumidores e também taxas de anuidade. O mesmo acontece com as bolsas de valores e de mercadorias para administrar a posição de cada investidor cobrando taxa de custódia e corretagens.

Em algumas transações os custos podem ser tão altos a ponto de inviabilizar as operações de pequeno montante, como no caso das transferências internacionais de valores financeiros, onde são inseridas novas taxas e ainda pode demorar dias para se concretizar, se concretizar… Onde pode aumentar o prazo, dependendo de finais de semanas e feriados.

Aceitação do Bitcoin no mundo

Uma das ideias do Bitcoin, portanto, é baratear os custos das transações, com valores irrisórios comparados a Bancos. A consequência pode ser o aumento no volume de negócios.

Por exemplo, um desenvolvedor de softwares no Brasil pode contratar os serviços de um programador na Ucrânia e pagar pelo trabalho por meio da transferência de bitcoins. Nessa situação o Bitcoin é usado como um meio de troca.

Considerando que a atual estrutura da internet já viabiliza a troca de arquivos sem barreiras geográficas, o uso em larga escala do bitcoin teria o efeito de estimular o comércio global de bens e serviços, com transferência de bitcoin para qualquer parte do mundo, com tempo médio de 10 minutos..

Leia também  Coreia do Sul prepara-se para taxar o uso do Bitcoin

Dado que o bitcoin possui cotação tanto em dólares quanto nas demais moedas mundiais, o programador ucraniano do exemplo poderia optar por manter parte de sua remuneração recebida do desenvolvedor brasileiro em bitcoins, como uma poupança.

Por fim, a decisão do programador ucraniano poderia ser a de gastar parte dos bitcoins na compra de produtos e serviços para serem consumidos, ou comprar produtos para o aperfeiçoamento do seu trabalho, tal como computadores e eletrônicos. A empresa americana Dell Computer, que fabrica computadores e notebooks, é um das lojas que aceitam bitcoin, na compra de seus produtos. Existe também um site brasileiro, chamado “Classificados BTC“, onde é possível comprar e vender produtos e serviços, com bitcoin.

Mesmo o Bitcoin não sendo considerado uma “moeda” (meio de troca, unidade de conta e reserva de valor; baseado no conceito econômico), pelos economistas, ainda sim é um excelente meio de troca, universalmente aceito, ainda que galgando.

O Bitcoin possui um valor especulativo. A cotação de um bitcoin saltou de pouco menos de US$ 300 em julho de 2015 para mais de US$ 2 mil em julho de 2017.

Para negociar Bitcoin, vale o alerta: como em todo investimento especulativo, é fundamental conhecer os riscos envolvidos, mas ao mesmo tempo o Bitcoin não é definido pelo preço, e sim sua tecnologia disruptiva que vamos descrever abaixo:

Bitcoin

  • 24h – Bitcoin funciona 24 horas por dia, 365 dias no ano, nunca para e as transações podem acontecer a qualquer hora do dia ou da noite, independente de finais de semanas e feriados.
  • Rápido – simples como enviar um e-mail ou sms, de um telefone móvel.
  • Descentralizado – não tem um controlador central, podemos transacionar com qualquer pessoa sem depender de um intermediador, uma rede ponto-a-ponto ou peer-to-peer, parecida com a rede do BitTorrent. BTC, também conhecido como Bitcoin, é um sistema livre, que não pode ser confiscado, como já aconteceu com a poupança nos anos 90.
  • Deflacionário – ao contrário do dinheiro emitido a esmo pelos Bancos Centrais, que geram inflação, o bitcoin é deflacionário e poderá ser criado somente 21 milhões, onde são criados em uma ordem decrescente.
  • Sistema de pagamento – O bitcoin é um ativo ao portadorvocê pode ser seu próprio Banco, transacionando e custodiando seus BTCs (a sigla de bitcoin).
  • Meio de troca – uma das maiores construtoras  do Brasil, a Tecnisa, aceita bitcoin como meio de pagamento em seus imóveis e várias pessoas no Brasil já entenderam as vantagens de aceitar Bitcoin e estão vendendo desde eletrônicos, até carros e casas de luxo, no Classificados BTC.
  • Privacidade – você pode ter milhões em Bitcoins, sem ter sua vida exposta pela FORBES, pois o seu nome não será divulgado na rede, você será identificado na rede com uma chave pública(parecida com essa: 1hlY78hOwe46VCd90oNuRX2j80se43WZ).
  • Segurança – a rede conjuntamente faz com que as regras sejam cumpridas, e acompanhada de uma resposta rápida dos seus usuários se alguém tentar fraldar o sistema, e também o custo benefício não compensa
  • Barato – custo irrisório, seja para enviar bitcoin para seu vizinho ou para o Japão, o custo é o mesmo.
  • Transparência – Bitcoin é um sistema de código aberto e as transações estão totalmente disponíveis para auditoria de qualquer pessoa, em tempo real, elas ficão registradas no Blockchain, o livro razão imutável com todas as transações da história do software Bitcoin registradas.
  • Inclusão social – metade da população brasileira não tem acesso a contas bancárias, por “N” motivos, mas o Bitcoin veio para mudar essa situação, onde quem quiser transferir dinheiro para qualquer parte do mundo, seja para se incluir no sistema financeiro ou ajudar em uma catástrofe mundial, você só precisa de um telefone móvel, acesso a internet e baixar o software do Bitcoin para transferir recursos para qualquer parte do mundo ou mesmo se incluir nele.
Com o Blockchain, Bitcoin é apenas o começo!

 

Fonte: https://guiadobitcoin.com.br/bitcoin-e-blockchain-para-leigos/

A segurança do bitcoin pela força computacional

 

A segurança no bitcoin é alcançada pela descentralização e pela força computacional. Este não é um vídeo técnico, mas sim uma visão geral do funcionamento da tecnologia.

Para fontes mais técnicas e detalhas, ver artigos abaixo.

Para saber mais:

Artigo “A grande inovação tecnológica do bitcoin Parte 1/2” http://www.infomoney.com.br/blogs/cam… Mining Bitcoin Wiki: https://en.bitcoin.it/wiki/Mining

Beginners’ Guide to Mining: https://99bitcoins.com/beginners-guid…

Bitcoin Mining Explained: https://chrispacia.wordpress.com/2013…

Everything you need to know about BTC mining: https://www.bitcoinmining.com/

How the bitcoin protocol actually works: http://www.michaelnielsen.org/ddi/how…

“Bitcoin – a Moeda na Era Digital”, livro publicado pelo Instituto Mises Brasil em 2014. http://www.mises.org.br/Ebook.aspx?id=99

Blog “Moeda na Era Digital” no portal InfoMoney http://www.infomoney.com.br/blogs/cam…

Está pensando em usar ou comprar bitcoin? Leia aqui antes: http://www.infomoney.com.br/blogs/cam…

Apoie este canal! Bitcoin: 1C6qa2DctPUcyAasDkgdBTJjhgpXaVjcUE

Contatos: Email: ulrich@mises.org.br

Facebook: https://www.facebook.com/fernando.ulrich

Twitter: https://twitter.com/fernandoulrich

Nós quase demos em construir cérebros artificiais

Hoje, as redes neurais artificiais estão fazendo arte, escrevendo discursos, identificando rostos e até mesmo dirigindo carros. Parece que estamos montando a onda de uma era tecnológica inovadora, mas o aumento atual das redes neurais é realmente uma espécie de renascimento.

Pode ser difícil de acreditar, mas os pesquisadores de inteligência artificial já começaram a ver a promessa nas redes neurais durante a Segunda Guerra Mundial em seus modelos matemáticos. Mas, na década de 1970, o campo estava pronto para desistir deles inteiramente.

“[T] aqui não houve resultados impressionantes até que os computadores crescessem, isto é, até os últimos 10 anos”, diz Patrick Henry Winston, professor do MIT especializado em inteligência artificial. “Continua a ser o facilitador mais importante do aprendizado profundo”.

Redes Neurais

As redes neurais de hoje são essencialmente árvores de decisão que dependem da lógica matemática que se assemelha, por falta de uma melhor analogia, ao disparo de sinapses no cérebro humano. Várias camadas de neurônios artificiais, ou nós, são utilizados para chegar à solução de um problema. À medida que os dados são alimentados através das camadas, uma computação simples ocorre em cada nó e a solução é passada para a próxima camada de neurônios para outra rodada de cálculos. O tempo todo, a matemática que ocorre em cada neurônio está sendo ligeiramente modificada pelo resultado anterior. Desta forma, uma rede neural pode se ensinar padrões em dados que combinam com uma solução desejada e otimizar o caminho para ele, como ajustar um violão. Quanto mais dados você alimenta uma rede neural, melhor fica ao ajustar seus neurônios e encontrar um padrão desejado.

Enquanto o campo emergiu nos últimos anos como um tour de force para especialistas em informática e até mesmo alguns hobbyists, a história da rede neural remonta até o início dos computadores. O primeiro mapa de uma rede neural veio em 1943 em um artigo de Warren Sturgis McCulloch e Walter Pitts. Mas o quadro de McCulloch tinha pouco a ver com a computação; Em vez disso, ele estava focado na estrutura e função do cérebro humano. O modelo de função de neurônio de McCulloch-Pitts, é claro, surgiu durante um tempo em que a tecnologia para monitorar essa atividade não existia.

McCulloch e Pitts acreditavam que cada neurônio no cérebro funcionaria como um interruptor on-off (como números binários 1 e 0), e que as combinações desses neurônios disparariam ou desativariam, produzindo decisões lógicas. Na época, havia muitas teorias concorrentes para descrever a forma como o cérebro operava, mas de acordo com um artigo de Gualtiero Piccinni da Universidade do Missouri, St. Louis, o modelo de McCulloch-Pitts fez algo que os outros não tinham: Funcionam para algo que se assemelhava a um computador simples, e isso despertou interesse em construir um cérebro artificial a partir do zero.

Sucesso inicial

O primeiro sucesso – e esse é um generoso termo – conceito de rede neural foi o algoritmo Perceptron do Frank Rosenblatt da Universidade Cornell. O Perceptron foi originalmente concebido para ser uma máquina, embora a sua primeira implementação fosse como uma classe de redes neurais que pudessem tomar decisões razoavelmente rudimentares. Eventualmente, o algoritmo foi incorporado em um computador com tamanho de geladeira chamado Mark 1, que era uma máquina de reconhecimento de imagem. Possui uma matriz de 400 fotocélulas ligadas à sua rede neural artificial, e poderia identificar uma forma quando era realizada antes do “olho”.

Poucos anos depois, em 1959, ADALINE chegou por meio de pesquisadores da Universidade de Stanford e, na época, era o maior cérebro artificial. Mas, também, só pode lidar com alguns processos por vez e foi concebido como uma demonstração de aprendizagem de máquinas em vez de ser configurado para uma tarefa específica.

Esses pequenos, mas tentadores avanços na computação alimentaram a histeria em torno da inteligência artificial na década de 1950, com a Sciencedirigindo a manchete “Human Brains Replaced?” Em uma questão de 1958 sobre redes neurais. Robôs inteligentes invadiram a ficção científica com um clipe mais rápido. Este mesmo ciclo, porém, repetiu-se com muitos processos automatizados ao longo da história. Como Adelheid Voskuhl apontou nos Andróides no Iluminismo , os autômatos executados no relógio foram construídos no século 18 como uma ameaça para a humanidade e a prova de que as máquinas governariam o mundo no devido tempo. Mas esses andróides do Iluminismo não passaram de marionetes glorificados.

Em meados do século 20, a pesquisa era lenta e não conseguia acompanhar a imaginação pública, como observa o professor de psicologia da Universidade de Toronto, Eyal Reingold. Relata que o cérebro artificial estava prestes a substituir a mente humana tão longe da realidade quanto possível.

“Infelizmente, esses sucessos anteriores causaram que as pessoas exagerassem o potencial das redes neurais, particularmente à luz da limitação na eletrônica, então disponível”, escreveu ele em uma história de inteligência artificial. “Este exagero excessivo, que decorreu do mundo acadêmico e técnico, infectou a literatura geral da época”.

O inverno está chegando

Não era o receio de uma aquisição de robôs que quase mataram a pesquisa da IA ​​no início dos anos 1970, porém; Era uma combinação de fatores. Enquanto o professor de informática do MIT, Marvin Minsky, é muitas vezes acreditado por fornecer um título de morte para Perceptrons, havia muito mais na história.

Havia o problema dos cortes no financiamento do governo. O governo estava canalizando mais dinheiro em programas de tradução que poderiam converter o russo para o inglês quase instantaneamente. As redes neurais iniciais mostraram essas habilidades com um vocabulário de 250 palavras , mas a pesquisa subseqüente foi lenta no melhor. Em meados da década de 1960, uma comissão governamental chamada Comitê Consultivo de Processamento de Linguagem Automática considerou a tradução automática “sem esperança”.

Conforme destacado por Gary Yang, um relatório de 1973 chamado Lightfoot Report também apontou que várias áreas onde a aprendizagem de máquinas poderiam ser aplicadas – como as funções de piloto automático – eram realmente melhor atendidas por métodos muito menos tecnologicamente avançados.

Nils Nilsson, professor aposentado de ciência da computação da Universidade de Stanford, trabalhou nessas primeiras gerações de inteligência artificial. Uma das maiores reivindicações da fama foi Shakey , um robô construído na década de 1960 que poderia realizar um reconhecimento de imagem rudimentar. Foi assim chamado, porque ele se perdeu quando se moveu, usando uma câmera de TV para capturar e entender o mundo ao seu redor. Poderia interpretar as entradas do computador sobre um objeto na sala e interagir com ele de determinadas formas. Também foi um sucesso inicial na rede neural, mas não foi suficiente.

Winston diz que um dos problemas era que as redes neurais não podiam ter uma abordagem abrangente. Ele diz que o documento Perceptron de Marvin Minsky mostrou que outras áreas de pesquisa de inteligência artificial eram necessárias – e que a tecnologia ainda não estava disponível.

“Os escritos de Minsky eram para uma categoria especial de Perceptrons”, diz Nilsson. “A principal razão pela qual a pesquisa sobre redes neurais se desviou na década de 60, que ninguém conseguiu descobrir uma maneira de treinar redes neurais de várias camadas”.

Para resumir: o artigo de Minsky demonstrou que, mesmo no seu mais complexo, a classe Perceptron de AI era muito binária em seus pensamentos, dificultando a habilidade da máquina de aprender a atacar tarefas mais complexas. Na opinião de Minsky, você precisava de diferentes tipos de inteligência artificial para conversar uns aos outros, o que pode ter ultrapassado as capacidades do hardware no momento.

“Minsky era tudo sobre pensar que você precisava de múltiplas representações, métodos e abordagens”, diz ele.

A rede neural começou assim a se retirar da imaginação pública, inaugurando o que foi chamado de “Inverno de Inverno”, onde o financiamento da pesquisa de inteligência artificial secou e muitas linhas de pesquisa pararam. Isso incluiu redes neurais e pesquisa de AI mudou para outras áreas de foco.

“As pessoas trabalharam em uma variedade de coisas: sistemas experientes, o uso da lógica para fazer raciocínio, reconhecimento de fala, visão computacional e robôs”, diz Nilsson. Sistemas experientes, destinados a ser vastos repositórios de conhecimento de especialistas computorizados em declarações de lógica, levaram a um segundo tipo de inverno AI quando suas habilidades também estavam superadas.

Fazendo um retorno

Mas em 1974, Paul Werbos, então estudante de doutorado de Harvard, introduziu uma maneira de melhorar as redes neurais. Ao espalhar várias redes neurais um ao outro, você poderia ter certos erros nos neurônios verificar os outros em um processo chamado backpropagation, uma maneira em que um cérebro artificial poderia “adivinhar” e procurar uma nova decisão.

Isso foi importante. As redes neurais anteriores poderiam ficar penduradas na mesma decisão. Se você colocou várias decisões em um resultado final, a máquina poderia essencialmente usar uma parte da rede neural para verificar novamente outra parte. Isso, de fato, deu uma complexidade em camadas à sua linha de pensamento. Em vez de pensar em preto e branco de entradas verdadeiras / falsas Perceptron, poderia interpretar um valor neutro para chegar a uma decisão pesando vários fatores.

Na verdade, ele iria além das declarações de lógica e na aprendizagem complexa de máquinas.

Era um documento arrojado e avançado – talvez um pouco mais ansioso. Nenhum hardware de computador no momento poderia lidar com operações tão complexas.

Nilsson também aponta para a publicação de 1986 do processamento distribuído paralelo: explorações na microestrutura da cognição de David E. Rumelhart da Universidade da Califórnia em San Diego e James L. McClelland da Universidade Carnegie Mellon. Melhorou o trabalho de Werbos mostrando um dos melhores mapas modernos da rede neural humana, criando o melhor mapa do cérebro.

Este mapa também ajudou a refinar as idéias de Werbo, mostrando como os neurônios funcionaram no cérebro e como você poderia aplicar isso às redes neurais artificiais. Você poderia resolver a incapacidade de entender as funções neutras ao ter outras redes neurais conectadas para obter uma resposta mais “refinada” neutra. Só precisava de um chute de algumas áreas: “grandes avanços no poder do computador e grandes bancos de dados que permitiram” aprendizado profundo “, como disse Nilsson. Esses avanços na computação chegaram. Hoje, os pesquisadores têm o poder de processamento e acesso a troves de dados armazenados em “a nuvem” para ensinar novas funções de algoritmos.

ADALINE e seus primos primitivos podem ter desaparecido da percepção pública, uma vez que a aprendizagem por máquinas passou a ser própria na última década. Mas essa revolução, décadas atrás, não foi dificultada por essas redes neurais. Em vez disso, eles eram de alguma forma muito primitivos e muito avançados para o seu tempo, mas seu tempo certamente chegou.

 

Sistemas Operacionais de Tempo Real – Timers

Introdução

Estava desenvolvendo algumas idéias para um novo artigo técnico, quando encontrei perdida, no fundo de uma gaveta virtual, uma biblioteca de rotinas em C que desenvolvi há algum tempo. É uma preciosidade!!! Eu mesmo já utilizei essas funções em vários projetos. Estou aqui disponibilizando esse material para você.

Vou contar um pouco a história dessa biblioteca. Houve uma época em que o meu trabalho era focado em projetos de desenvolvimento de sistemas dedicados baseados em processadores da família 8051. Desenvolvemos uma célula de carga digital, um sistema de monitoramento ambiental, um mini CLP, um sistema de monitoramento e controle de um processo químico, sistema de controle de elevadores etc. Daí surgiu a ideia de elaborar funções e rotinas padronizadas, pois quase todos esses sistemas tinham alguma coisa em comum, como por exemplo teclas, displays etc. e deveriam operar em tempo real. O objetivo foi diminuir o tempo gasto para o desenvolvimento de um novo projeto. Antes de prosseguir, recomendo a leitura do artigo Sistemas Operacionais de Tempo Real – Introdução, onde são abordados alguns conceitos que serão aplicados neste artigo.

É necessário apresentar aqui alguns esclarecimentos a respeito da filosofia usada na elaboração dessas rotinas. Eu parti do princípio de que os nossos sistemas são de tempo real e que realizam periodicamente algumas funções rotineiras, tais como verificar um teclado, atualizar displays, administrar LEDs de sinalização, realizar medidas, etc. Outras ações são tomadas por demanda, ou seja, apenas quando ocorrem. Essas demandas podem ser periódicas ou assíncronas (aleatórias). Daí já reconhecemos o primeiro elemento a ser implementado no nosso Sistema Operacional: um temporizador (Timer). Para quem não sabe, os processadores tradicionais da família 8051 têm apenas 2 temporizadores, enquanto outras versões oferecem pelo menos mais um. Antes de continuar, acho interessante recordarmos a arquitetura dos microcontroladores da família MCS-51 e os modos de operação dos seus temporizadores. Na parte final desse artigo será desenvolvido um pequeno exemplo prático, cujo código poderá ser compilado e simulado.

TIMERS da família MCS-51

Para ilustrar o que será abordado aqui, vamos nos referenciar aos microcontroladores de fabricação da ATMEL, com a arquitetura baseada no 8051, cujo documento completo você pode consultar aqui: ATMEL 8051 Microcontrollers Hardware Manual. Na Figura 1 podemos observar a arquitetura interna de um microcontrolador AT89S8253, que continua sendo produzido, mostrando em destaque o bloco dos temporizadores.

Timers - Diagrama em blocos da arquitetura interna de um microcontrolador
Figura 1: Diagrama em blocos da arquitetura interna de um microcontrolador AT89S8253

 

Sem entrar nos detalhes referentes aos contadores / temporizadores Timer 0 e Timer 1 dessa família de microcontroladores, basta dizer que eles podem ser programados para funcionarem em 4 modos distintos de operação:

  • Modo 0: O temporizador é configurado como um contador de 13 bits, que pode receber um valor inicial e conta para cima. Na transição do valor limite superior 0x1FFF para  0x0000, é acionado um flag de sinalização;
  • Modo 1: Similar ao modo 0, porém é configurado o contador para 16 bits;
  • Modo 2: O temporizador é configurado como um contador de 8 bits, com um registro de 8 bits associado para recarregar o valor inicial automaticamente. Na transição, é acionado um flag;
  • Modo 3: Nesse modo de operação, o Timer 0 opera como 2 contadores distintos de 8 bits, enquanto o Timer 1 nesse modo de operação permite que se congele a contagem.

Convenções para o uso dos Timers

Para o objetivo de projetar uma biblioteca com rotinas padronizadas, foi definido que o Timer 0 seria o temporizador padrão do sistema e o Timer 1 também poderia ser usado para isso, se acaso não fosse necessário usá-lo para gerar baud-rate da comunicação serial.

O período de interrupção do temporizador deve ser o maior possível e baixo o suficiente para atender às necessidades prioritárias do sistema. Para que se entenda o motivo disso, observe o seguinte exemplo:

Suponhamos que:

  • Um microcontrolador que, por restrições de sua arquitetura e do oscilador (clock) utilizado, possa executar no máximo 10.000 instruções por segundo;
  • Uma rotina de interrupção provocada pelo temporizador execute 20 instruções na média a cada interrupção.

Se numa hipótese absurda o temporizador for dimensionado para gerar 500 interrupções por segundo, a rotina de interrupção vai consumir todo o tempo disponível para executar as instruções do microcontrolador (500 x 20 = 10.000)! Se por exemplo esse número puder cair para 50 interrupções por segundo, sem prejudicar a operação do sistema, a rotina de interrupção vai consumir apenas 10% do total disponível (1.000), deixando os outros 90% para as demais atividades do microprocessador.

A compreensão do que foi ilustrado nesse exemplo é fundamental. As rotinas que são executadas com maior frequência devem ser otimizadas para serem executadas no menor tempo possível e na menor frequência possível também. Voltando ao exemplo das 500 interrupções, se acaso a rotina de interrupção executasse apenas 18 instruções ao invés das 20, já sobrariam 1.000 instruções por segundo que poderiam ser executadas por outras atividades. Em muitos casos isso é suficiente. Note que para esse exemplo em particular, só analisamos uma das soluções possíveis para viabilizar a operação do sistema. Poderia-se também lançar mão de outros recursos, como por exemplo aumentar a frequência do oscilador do microcontrolador.

Assim a frequência da interrupção do nosso timer deve ser dimensionada de modo que:

  • A função que deverá ser executada com maior frequência possa ser atendida pelas interrupções do timer no menor tempo necessário para isso (e maior possível), definindo assim as especificações do timer de referência do sistema;
  • Outras temporizações mais lentas sejam realizadas como múltiplos da interrupção do timer e implementadas por meio de temporizadores virtuais de software.

Um temporizador virtual de software é uma estrutura no programa em que a cada temporizador é associado um valor inicial, que se traduz num número inteiro de interrupções do Timer 0, e um flag de sinalização. A cada interrupção do Timer 0, o temporizador de software é decrementado e testado se zero. Se for zero, é ligado o flag para avisar que a contagem de software foi terminada e o temporizador é reinicializado para o seu valor inicial. O tratamento do final de contagem é realizado no programa principal, testando-se o flag e reinicializando-o depois.

O timer de referência deverá funcionar no modo 2 de operação. Observe que a programação do Timer 0 depende da frequência de clock do microcontrolador, do fator de divisão do clock, que nas CPUs tradicionais do MCS-51 é de 12 vezes, e da frequência requerida de interrupção. Um último limitante é que o valor inicial do Timer nessa configuração é de no máximo 255 (8 bits). Na biblioteca também foi desenvolvido um padrão para a programação do Timer 1, especialmente se não for usado para gerar baud-rate.

Detalhes da Biblioteca em C

O código em C a seguir foi desenvolvido para o compilador KEIL C51 μVision, na versão de avaliação. Se você quiser testar o programa exemplo que desenvolveremos no final deste artigo, recomendo que você baixe e instale esse programa.  O arquivo de biblioteca com os trechos de código em C para a utilização dos timers de forma padronizada está dividido em segmentos. O primeiro segmento define uma série de constantes, que podem ser ajustadas conforme as especificações do projeto. Veja o trecho do código a seguir.

Nesse código há alguns parâmetros que precisam ser alterados, conforme o projeto:

  • #define   FREQUENCIA_DO_CLOCK_DA_CPU 12.0e+6 // Hz —->  12 MHz, por exemplo.

Inicializar essa constante com o valor do clock do seu microcontrolador.

  • #define   FATOR_DE_ESCALA_CLOCK_TIMER    12.0f     // Divide o clock por 12

Valor do pre-scaler.

  • #define   FREQUENCIA_DE_INTERRUPCAO_TIMER_0 5e+3  // Hz —- > 5 kHz, por exemplo.

Define a frequência da interrupção do timer.

São apenas esses três parâmetros que devem ser inicializados. Não é necessário alterar outras partes do código!

O segundo segmento da biblioteca refere-se às inicializações dos timers, conforme o modo de operação, e os comandos para iniciar a operação do temporizador. Observe que nesse segmento é mostrada a rotina principal (void main(void)) e indicado onde devem ser inseridos os trechos do código.

O terceiro segmento mostra como são definidas as rotinas de interrupção.

EXEMPLO

A seguir vamos desenvolver o nosso programa de exemplo. Nesse programa, será programado o Timer 0 no modo 2 de operação, com o microcontrolador operando com um clock de 4 MHz e uma frequência de interrupção de 1,5 kHz. Confira o código no quadro abaixo.

Se você quiser simular o programa exemplo acima e explorá-lo um pouco mais, siga os seguintes passos:

  • Instale o KEIL C51 μVision;
  • Baixe o arquivo Testa_Timer.zip;
  • Instale os arquivos de Testa_Timer.zip num diretório para testes;
  • Navegue até o diretório de testes e acione o arquivo Testa_Timer.uvproj (2 “clickes”)  (Figura 2).

Timers - Arquivos no diretório de teste
Figura 2: Arquivos no diretório de teste

Nesse instante deverá abrir o programa Keil e a tela deverá ser a retratada na Figura 3. Esse painel permite navegar no código em C, editá-lo e compilá-lo. Não é necessário fazer isso para realizar a simulação, mas você poderá posteriormente alterar alguns parâmetros do código e testar o programa com as novas alterações.

Timers - Programa Keil pronto com o programa exemplo carregado
Figura 3: Programa Keil pronto com o programa exemplo carregado

A seguir coloque o programa no modo de Debug (Figura 4, Figura 5 e Figura 6) para que se possa iniciar a simulação.

timers - Selecionando o modo Debug do programa
Figura 4: Selecionando o modo Debug do programa

Antes de entrar no modo de depuração, aparece na tela a mensagem da Figura 4. “Clicke” no  “OK” para continuar.

Timers - Aviso de que no modo de avaliação, o código fica limitado a 2K
Figura 5: Aviso de que no modo de avaliação, o código fica limitado a 2K

timers - Modo Debug de operação
Figura 6: Modo Debug de operação

 

Observe que já estão destacados os painéis de monitoramento do Timer 0 e do Port 3, cujo bit 1 deverá ser alternado a cada término de contagem do temporizador de software. As duas variáveis principais (bFlagTimerDeSoftware e nTimerDeSoftware) poderão ser monitoradas na janela Watch 1 durante a simulação.

É possível utilizar as teclas de função F11 para executar o programa passo a passo ou F5 entrar em execução. Recomendo que você inicie a simulação utilizando o passo  a passo para poder observar detalhadamente como que funciona o mecanismo de operação desse programa.

Resumo

Neste artigo técnico foram apresentados alguns conceitos relativos à utilização de temporizadores de hardware de um microcontrolador associados a temporizadores de software para a implementação de arquiteturas de software típicas de  sistemas operacionais de tempo real. Também foi apresentada e explicada uma biblioteca padronizada para a utilização dos timers de microcontroladores da família MCS-51, codificada em C, para ser compilada no programa da Keil. Depois foi desenvolvido um programa exemplo para que você possa simular o que foi apresentado e observar os detalhes dessa implementação.

Este artigo é o segundo da série de artigos que abordam algumas funções comuns em projetos de sistemas embarcados de tempo real. Confira os demais artigos (em breve).

Sistemas Operacionais de Tempo Real

Bibliotecas de funções e rotinas padronizadas em linguagem C para MCS-51

  • Timers (este artigo) – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso dos Timers do MCS-51;
  • Displays de 7 segmentos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso em displays de 7 segmentos;
  • Teclados Matriciais – É apresentada uma biblioteca desenvolvida em linguagem C para varredura, leitura, debounce, identificação da tecla acionada e desvio para a rotina de tratamento. A forma como as rotinas foram escritas, permitem sua fácil reutilização em outros projetos;
  • Periféricos – É apresentada uma biblioteca desenvolvida em linguagem C para a inicialização e o uso de alguns periféricos, tais como conversores A/D, sensor de temperatura e memórias seriais.

Fonte: https://www.embarcados.com.br/rtos-timers/

Guia completo dos Seletores CSS3

Introdução

O Módulo das CSS3 denominado “Selectors Level 3” atingiu, em 29 de setembro de 2011, o status de Recomendação do W3C. Essa Recomendação descreve os seletores já existentes nas CSS1 e CSS2 e cria novos seletores para as CSS3.

Seletores são “padrões” ou “modelos” que casam com os elementos de uma árvore do documento e portanto podem ser usados para selecionar os nós de um documento XML. Seletores foram otimizados para serem usados com as linguagens de marcação HTML e XML.

CSS (Cascading Style Sheets) é uma linguagem para descrever a renderização de documentos HTML e XML em uma tela, em papel, em sintetizadores de voz, etc.

As CSS usam seletores para atrelar propriedades de estilização aos elementos de um documento.

Tabela de seletores

Padrão Casa com Tipo CSS
* qualquer elemento Seletor universal 2
E elementos do tipo E Seletor tipo 1
E[foo] elementos com o atributo “foo” Seletor atributo 2
E[foo=”bar”] elementos E cujo valor do atributo “foo” é exatamente igual a “bar” Seletor atributo 2
E[foo~=”bar”] elementos E cujo valor do atributo “foo” é uma lista de valores separados por espaço, um dos quais é exatamente igual a “bar” Seletor atributo 2
E[foo^=”bar”] elementos E cujo valor do atributo “foo” começa exatamente com a string “bar” Seletor atributo 3
E[foo$=”bar”] elementos E cujo valor do atributo “foo” termina exatamente com a string”bar” Seletor atributo 3
E[foo*=”bar”] elementos E cujo valor do atributo “foo” contém a substring “bar” Seletor atributo 3
E[foo|=”en”] elementos E cujo atributo “foo” tem uma lista de valores começando com “en” e seguida por um hífen Seletor atributo 2
E:root elemento E raiz do documento Pseudo-classe estrutural 3
E:nth-child(n) elemento E que é o enésimo filho do seu elemento pai Pseudo-classe estrutural 3
E:nth-last-child(n) elemento E que é o enésimo filho (contado de trás para frente) do seu elemento pai Pseudo-classe estrutural 3
E:nth-of-type(n) elemento E que é o enésimo irmão do seu tipo Pseudo-classe estrutural 3
E:nth-last-of-type(n) elemento E que é o enésimo irmão (contado de trás para frente) do seu tipo Pseudo-classe estrutural 3
E:first-child elemento E que é o primeiro filho de seu elemento pai Pseudo-classe estrutural 2
E:last-child elemento E que é o último filho de seu elemento pai Pseudo-classe estrutural 3
E:first-of-type elemento E que é o primeiro irmão de seu tipo Pseudo-classe estrutural 3
E:last-of-type elemento E que é o último irmão de seu tipo Pseudo-classe estrutural 3
E:only-child elemento E que é o único filho de seu elemento pai Pseudo-classe estrutural 3
E:only-of-type elemento E que é irmão único do seu tipo Pseudo-classe estrutural 3
E:empty elemento E que não tem elementos filhos (inclusive nós de texto) Pseudo-classe estrutural 3
E:link
E:visited
elemento E que sendo destino de um link ainda não foi visitado (:link) ou que já tenha sido visitado (:visited) Pseudo-classe link 1
E:active
E:hover
E:focus
elemento E durante determinadas ações do usuário Pseudo-classe ação do usuário 1 e 2
E:target elemento E que é o destino de um fragmento identificador de um URI Pseudo-classe :target 3
E:lang(pt-br) elemento E em um determinado idioma – “exemplo: pt-br” Pseudo-classe :lang() 2
E:enabled
E:disabled
elemento E de uma interface de usuário que está habilitado (:enabled) ou desabilitado (:disabled) Pseudo-classe estado do elemento UI 3
E:checked elemento E de uma interface de usuário que está marcado (:checked) (por exemplo: radio-button ou checkbox) Pseudo-classe estado do elemento UI 3
E::first-line primeira linha formatada do elemento E Pseudo-elemento ::first-line 1
E::first-letter primeira letra formatada do elemento E Pseudo-elemento ::first-letter 1
E::before conteúdo gerado antes do elemento E Pseudo-elemento ::before 2
E::after conteúdo gerado depois do elemento E Pseudo-elemento ::after 2
E.foo elemento E cujo valor da classe é “foo” Seletor classe 1
E#foo elemento E cujo valor do atributo ID é “foo”. Selector ID 1
E:not(seletor) elemento E que não casa com o seletor simples seletor Pseudo-classe negação 3
E F elemento F descendente do elemento E Elemento descendente 1
E > F elemento F filho do elemento E Elemento filho 2
E + F elemento F imediatamente precedido pelo elemento E Elemento irmão adjacente 2
E ~ F elemento F precedido pelo elemento E Elemento irmão geral 3

Criei versões HTML, PNG e SVG desta tabela otimizadas para impressão. Que tal imprimir a tabela e tê-la na sua mesa de trabalho para uma referência e consulta rápida?
versão HTML para impressão desta tabela (link abre em nova janela)
versão PNG para impressão desta tabela (link abre em nova janela)
versão SVG com personalização de cores para impressão desta tabela (link abre em nova janela).

Vamos estudar a seguir cada um dos seletores constantes da tabela.

Incorporamos nesta página, para cada um dos seletores estudados, com uso de IFRAME para o JSFiddle, exemplos que demonstram o efeito de estilização. Você poderá complementar seus estudos clicando o link existente no canto superior direito do IFRAME e editando os códigos dos exemplos de modo interativo.

Seletor universal

♦ Casa com qualquer elementoOs conteúdos de cada um dos elementos da marcação, ao serem renderizados em um navegador, são estilizados com regras CSS mínimas (por exemplo: cor e tipo de fonte, margens, paddings, etc.) que fazem parte de uma folha de estilos nativa do navegador e que na ordem de cascata tem a prioridade mais baixa, ou seja, qualquer declaração de estilo do autor ou usuário sobrescreve a folha de estilos nativa.

Não existe uma padronização para essa folha de estilos e cada navegador implementa sua própria folha de estilos nativa. Como consequência ocorrem inconsistências de renderização, em relação a estilização básica, entre navegadores.

Destas inconsistências a que produz maiores transtornos é a não padronização dos valores para as propriedades margin e padding.

A principal utilização do seletor universal é “zerar” essas propriedades para todos os elementos da marcação. Como consequência o autor terá que definir explicitamente para cada elemento, na sua folha de estilos, aqueles valores.

* {
  margin: 0;
  padding: 0;
  }

O seletor universal quando declarado de forma contextual pode produzir resultados interessantes. Observe os exemplos a seguir:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor tipo

♦ Casa com elementos de um determinado tipoSintaxe: E

Usado para estilizar os elementos da marcação que são de um mesmo tipo; por exemplo: elemento do tipo p(parágrafo), do tipo div, do tipo ol, do tipo strong, e assim por diante.

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletores de atributo

♦ Casam com elementos cujo atributo satisfaçam determinadas condições

presença de um atributo

♦ Casa com elementos que contenham um determinado atributoSintaxe: E["foo"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

valor de um atributo

♦ Casa com elementos com determinado valor de atributoSintaxe: E[foo="bar"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

valor de um atributo pertence a uma lista de valores separados por espaço

♦ Casa com elementos cujo valor de atributo pertença a uma lista de valores separados por espaçoSintaxe: E[foo~="bar"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

valor de um atributo começa com string

♦ Casa com elementos cujo valor de atributo começa com uma determinada stringSintaxe: E[foo^="bar"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

valor de um atributo termina com string

♦ Casa com elementos cujo valor de atributo termina com uma determinada stringSintaxe: E[foo$="bar"]

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletores do tipo pseudo-classe

elemento raiz

♦ Casa com o elemento raiz do documentoSintaxe: :root

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Nesse exemplo a cor dos elementos é herdada do elemento raiz.

enésimo filho

♦ Casa com o elemento que é o enésimo filho do seu elemento paiSintaxe: E:nth-child(n)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

enésimo filho de trás para frente

♦ Casa com o elemento que é o enésimo filho do seu elemento pai, contado de trás para frente na marcaçãoSintaxe: E:nth-last-child(n)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

enésimo irmão do seu tipo

♦ Casa com o elemento que é o enésimo irmão (filhos do mesmo elemento pai) do seu tipoSintaxe: E:nth-of-type(n)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

enésimo irmão do seu tipo de trás para frente

♦ Casa com o elemento que é o enésimo irmão (filhos do mesmo elemento pai) do seu tipo, contado de trás para frente na marcaçãoSintaxe: E:nth-last-of-type(n)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

primeiro filho

♦ Casa com o elemento que é o primeiro filho do seu elemento paiSintaxe: E:first-child

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

último filho

♦ Casa com o elemento que é o último filho do seu elemento paiSintaxe: E:last-child

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

primeiro do mesmo tipo

♦ Casa com o elemento que é o primeiro irmão (filhos do mesmo elemento pai) do mesmo tipoSintaxe: E:first-of-type

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

último do mesmo tipo

♦ Casa com o elemento que é o último irmão (filhos do mesmo elemento pai) do mesmo tipoSintaxe: E:last-of-type

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

único filho

♦ Casa com o elemento que é o único filho do seu elemento paiSintaxe: E:only-child

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

único irmão

♦ Casa com o elemento que é o único irmão (filhos do mesmo elemento pai) do mesmo tipoSintaxe: E:only-of-type

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

elemento vazio

♦ Casa com o elemento que não tem filhos (inclusive filhos do tipo nós de texto)Sintaxe: E:empty

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

link

♦ Casa com o elemento que é um link não visitadoSintaxe: a:link

Exemplo:

<a href="http://maujor.com">Site do Maujor<</a>
a:link {
  color: red; 
  text-decoration: none;  
}

link visitado

♦ Casa com o elemento que é um link que já foi visitadoSintaxe: a:visited

Exemplo:

<a href="http://maujor.com">Site do Maujor<</a>
a:visited {
  color: orange; 
  text-decoration: underline;  
}

ativo

♦ Casa com o elemento que por ação do usuário foi tornado ativoSintaxe: a:active

Exemplo:

<a href="http://maujor.com">Site do Maujor<</a>
:active {
  outline: 1px solid pink;  
}

sobre

♦ Casa com o elemento que, por ação do usuário, teve um dispositivo apontador colocado sobre eleSintaxe: a:hover

Exemplo:

<a href="http://maujor.com">Site do Maujor<</a>
a:hover {
  color: green;
  background: black;  
}

foco

♦ Casa com o elemento que por ação do usuário a ele foi dado o focoSintaxe: E:focus

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Não existe uma padronização relacionando os elementos HTML que podem receber foco. Mas, em geral são eles:

  • Elemento a
  • Elemento area com atributo href
  • Elemento input
  • Elemento select
  • Elemento textarea
  • Elemento button (não desabilitado)
  • Elemento iframe
  • Elemento a
  • Qualquer elemento com o atributo tabindex

alvo

♦ Casa com o elemento que é o alvo do fragmento identificador de um linkSintaxe: E:target

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

idioma

♦ Casa com o elemento que foi marcado em determinado idiomaSintaxe: E:lang

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

habilitado ou desabilitado

♦ Casa com o elemento da interface de usuário que seja habilitado ou desabilitadoSintaxe: E:enabled e E:disabled

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

marcado

♦ Casa com o elemento da interface de usuário que tenha sido marcadoSintaxe: E:checked

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

primeira linha

♦ Casa com a primeira linha do texto formatado de um elementoSintaxe:
E:first-line — até as CSS2.1
E::first-line — modificada peals CSS3

As CSS3 modificaram a sintaxe para esse seletor. Os navegadores antigos não suportam a nova sintaxe e o modernos suportam as duas sintaxes.

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Notas:

1 – Esse seletor aplica-se somente a elementos nível de bloco

2 – Somente às propriedades listadas a seguir podem ser estilizadas por esse seletor

  • propriedades para fontes
  • propriedades para cores
  • propriedades para background
  • word-spacing
  • letter-spacing
  • text-decoration
  • vertical-align
  • text-transform
  • text-shadow
  • line-height
  • clear

primeira letra

♦ Casa com a primeira letra do texto formatado de um elementoSintaxe:
E:first-letter — até as CSS2.1
E::first-letter — modificada pelas CSS3

As CSS3 modificaram a sintaxe para esse seletor. Os navegadores antigos não suportam a nova sintaxe e o modernos suportam as duas sintaxes.

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Notas:

1 – Esse seletor aplica-se somente a elementos nível de bloco

2 – Somente às propriedades listadas a seguir podem ser estilizadas por esse seletor

  • propriedades para fontes
  • propriedades para cores
  • propriedades para background
  • propriedades para margens
  • propriedades para padding
  • propriedades para bordas
  • text-decoration
  • vertical-align (para elementos não flutuados)
  • text-transform
  • text-shadow
  • line-height
  • float
  • clear

conteúdo antes

♦ Casa com o conteúdo gerado antes de um elementoSintaxe: E::before

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

conteúdo depois

♦ Casa com o conteúdo gerado depois de um elementoSintaxe: E:after

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

negação

♦ Casa com o elemento que não casa com determinado seletor simples seletorSintaxe: E:not(seletor)

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor classe

♦ Casa com o elemento que tem determinado valor para o atributo classeSintaxe: E.foo

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor ID

♦ Casa com o elemento que tem determinado valor para o atributo idSintaxe: E#foo

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor descendente

♦ Casa com o elemento que descende de determinado elementoSintaxe: E F

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor filho

♦ Casa com o elemento filho de determinado elementoSintaxe: E>F

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor que imediatamente sucede

♦ Casa com o elemento irmão que imediatamente segue-se a determinado elementoSintaxe: E+F

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

Seletor que sucede

♦ Casa com o elemento irmão que segue-se a determinado elementoSintaxe: E~F

Exemplo:

Ver no jsFiddle um exemplo interativo (abre em nova janela)

O IE outra vez! 😦

Os seletores CSS3 são suportados pelos navegadores modernos. Para servir os seletores das CSS3 aos navegadores Internet Explorer 6 até 8 use uma pequena biblioteca JavaScript (4K) chamada Selectivizr.

Basta adicionar o seguinte código na seção head do documento:

<script type="text/javascript" src="[JS library]"></script>
<!--[if (gte IE 6)&(lte IE 8)]>
  http://selectivizr.js
  <noscript><link rel="stylesheet" href="[fallback css]" /></noscript>
<![endif]-->

Boa sorte com os poderosos seletores das CSS!

Procedimento de gatilho PL/pgSQL para registrar inserção e atualização

O gatilho deste exemplo garante que quando é inserida ou atualizada uma linha na tabela, fica sempre registrado nesta linha o usuário que efetuou a inserção ou a atualização, e quando isto ocorreu. Porém, diferentemente do gatilho anterior, a criação e a atualização da linha são registradas em colunas diferentes. Além disso, o gatilho verifica se é fornecido o nome do empregado, e se o valor do salário é um número positivo. [1]

CREATE TABLE emp (
    nome_emp       text,
    salario        integer,
    usu_cria       text,        -- Usuário que criou a linha
    data_cria      timestamp,   -- Data da criação da linha
    usu_atu        text,        -- Usuário que fez a atualização
    data_atu       timestamp    -- Data da atualização
);

CREATE FUNCTION emp_gatilho() RETURNS trigger AS $emp_gatilho$
    BEGIN
        -- Verificar se foi fornecido o nome do empregado
        IF NEW.nome_emp IS NULL THEN
            RAISE EXCEPTION 'O nome do empregado não pode ser nulo';
        END IF;
        IF NEW.salario IS NULL THEN
            RAISE EXCEPTION '% não pode ter um salário nulo', NEW.nome_emp;
        END IF;

        -- Quem paga para trabalhar?
        IF NEW.salario < 0 THEN
            RAISE EXCEPTION '% não pode ter um salário negativo', NEW.nome_emp;
        END IF;

        -- Registrar quem criou a linha e quando
        IF (TG_OP = 'INSERT') THEN
            NEW.data_cria := current_timestamp;
            NEW.usu_cria  := current_user;
        -- Registrar quem alterou a linha e quando
        ELSIF (TG_OP = 'UPDATE') THEN
            NEW.data_atu := current_timestamp;
            NEW.usu_atu  := current_user;
        END IF;
        RETURN NEW;
    END;
$emp_gatilho$ LANGUAGE plpgsql;

CREATE TRIGGER emp_gatilho BEFORE INSERT OR UPDATE ON emp
    FOR EACH ROW EXECUTE PROCEDURE emp_gatilho();

INSERT INTO emp (nome_emp, salario) VALUES ('João',1000);
INSERT INTO emp (nome_emp, salario) VALUES ('José',1500);
INSERT INTO emp (nome_emp, salario) VALUES ('Maria',250);
UPDATE emp SET salario = 2500 WHERE nome_emp = 'Maria';

SELECT * FROM emp;

 nome_emp | salario | usu_cria |         data_cria          | usu_atu |          data_atu
----------+---------+----------+----------------------------+---------+----------------------------
 João     |    1000 | folha    | 2005-11-25 08:11:40.63868  |         |
 José     |    1500 | folha    | 2005-11-25 08:11:40.674356 |         |
 Maria    |    2500 | folha    | 2005-11-25 08:11:40.679592 | folha   | 2005-11-25 08:11:40.682394
(3 linhas)

Programação, Robótica e Música Para Baixinhos

Exemplo de ensino da programação e robótica em sala de aula. Evidentemente que o primeiro protótipo lhe dará um trabalhão para fazer, porém depois de pronto, você possui matéria para meio ano letivo, nesse pequeno e encantador brinquedinho Cover. A didática fica por sua conta. Quem tiver o interesse em desenvolver esse projeto com Raspberry PI + Arduino Mega + Arduino Nano, estamos aí…

Não esqueça, o Youtube é uma rede Social.

CONTROLANDO ARDUINO COM APLICAÇÕES EM DELPHI

Uma dica para quem quiser obter comunicação entre arduino e o delphi, para desenvolver interfaces que possibilita controlar o arduino através dodelphi, desenvolver aplicações para projetos de automação e outros projetos. Para conseguir esta comunicação com o delphi será necessário ainstalação do componente TComPort, pois é este componente que lhe dará todo suporte para que você consiga obter a comunicação quanto ao envioe o recebimento de dados com arduino.Para instalar o componente TComPort, é preciso fazer o download do componente no LINK: http://www.cuin.com.br/wp-content/uploads/2013/05/COMPONENTE.rar 
Instalando o componente utilizarei a versão Delphi 7:1º Passo:
Depois de baixar o componente, salve ele em uma pasta de preferencia a pasta que você utiliza pra salvar outros componentes.
2º Passo:
 Abra o delphi é necessário encerrar as aplicações abertas para isto clique em FILE e clique em CLOSE ALL

IBM libera seu processador quântico para testes pela nuvem

A IBM anunciou hoje que permitirá que pessoas e instituições testem o seu processador quântico por meio de seus serviços de nuvem, sem nenhum tipo de cobrança. A iniciativa, chamada de IBM Quantum Experience, tem o objetivo de ajudar a divulgar as possibilidades da computação quântica.

De acordo com a empresa, instituições de ensino, pesquisa e outras empresas poderão acessar um processador quântico da IBM. O processador, mostrado acima, poderá ser acionado por meio de qualquer computador ou dispositivo móvel. Os dispositivos enviarão os dados e cálculos desejados para o processador quântico da IBM pela internet, e o computador então devolverá os resultados.

Além de realizar cálculos e executar algoritmos, a plataforma de computação quântica na nuvem da IBM também oferecerá tutoriais e simulações que mostram o que seria possível de se realizar com essa tecnologia. A página do projeto pode ser acessada por meio deste link.

O processador

O processador da IBM utiliza cinco qubits – unidades básicas de processamento de informação no nível quântico – para realizar os cálculos. Por utilizar materiais supercondutores e por ser muito frágil, o processador precisa ser refrigerado a -272,778ºC para funcionar.

Nos computadores tradicionais, cada bit pode ter o valor de 1 ou 0. Os qubits, por sua vez, podem assumir os valores 1, 0 ou os dois ao mesmo tempo, numa condição chamada de “superposição” – um dos pilares fundamentais da mecânica quântica. Por esse motivo, eles conseguem realizar cálculos de maneira muito mais rápida do que os processadores tradicionais.

processador-quantico

Ele utiliza uma tecnologia desenvolvida pela própria IBM para detectar erros de cálculo realizados pelo processador quântico. Segundo a empresa, a arquitetura utilizada nele pode ser eventualmente aumentada para chegar a 50 a 100 qubits. Um processador quântico de 50 qubits seria mais potente que o maior supercomputador disponível atualmente.

A IBM acredita que a computação quântica pode ser a próxima revolução no mundo da tecnologia, por conta da falência cada vez mais aparente da Lei de Moore. Gigantes da tecnologia e da ciência, como o Google e a NASA, também têm investido nesse ramo, e mesmo organizações supranacionais, como a União Europeia, investem em pesquisa nessa área. Outras empresas também apostam no uso de neurônios para criar computadores exponencialmente mais potentes.

Fonte: http://olhardigital.uol.com.br/pro/noticia/ibm-libera-seu-processador-quantico-para-testes-pela-nuvem/57974

The CIPRES Science Gateway V. 3.3

arvore-da-vida

The CIPRES Science Gateway V. 3.3 é um recurso público para a inferência de grandes árvores filogenéticas. Ele é projetado para fornecer à todos os pesquisadores com acesso a NSF XSEDE, grandes recursos computacionais através de uma interface simples navegador. Agora também é possível acessar esses mesmos recursos programaticamente com a CIPRES REST API .

Códigos paralelos de desempenho elevados para o Grande Árvore Inferência e alinhamento de sequências em XSEDE:
RAxML ; MrBayes ; BEAST ; BEAST2 ; Garli ; mafftDPPDIV ; FastTree, jModelTest2 e Migrate-N . Se você precisa de acesso a PhyloBayes , por favor consulte.

Códigos seriais para Tree Inference:
PAUP * (Inferência por Parcimônia); Poy  (alinhamento e inferência);

Códigos de série para Sequence Alignment:
ClustalW ; Contralign ; MUSCULARES ; PROBCONS ; PROBALIGN

Códigos paralelos atualmente suportados pela CIPRES Cience Gateway

Código Versão Língua Compilador Computador Cores
cobrado
biblioteca MPI enfiando outro Software
FERA 1.8.3 Java Cometa 2-48 Java BEAGLE 2.1
BEAST2 2.3.2 Java Cometa 1-3 Java BEAGLE 2.1
DPPDiv 1.0 C ++ GNU Gordon 16 pthreads
FastTree 2.1.8 C Intel Cometa 2 OpenMP
Garli 2.0.1 C ++ Intel Cometa 1 a 24 OpenMPI NCL 2.1.18
jModelTest2 2.1.6 Java Gordon 8 Java PhyML 20120412
mafft 7.187 C Intel Gordon 8 pthreads
MrBayes 3.2.6 C Intel Gordon 8 ou 16 mvapich2 BEAGLE 2.1
Migre-N 3.6.11 C Intel Cometa 1-72 mvapich2
PhyloBayes 1.5a C ++ Intel Gordon 64 mvapich2
RAxML 8.2.8 C Intel Cometa 12, 24, ou 48 OpenMPI pthreads

 

CLIQUE AQUI E DESCUBRA

Mais de 600GB de material para estudo em TI: Cursos, vídeo aulas, livros, apostilas de todas as variantes da Tecnologia da informação:

 60 GB em vídeos aulas de Java 16 DVDS – Senha = pr0mp7.torrent

Tamanho:153 KB
https://mega.co.nz/#!JRgjRLBT!nNg8JO31WWskPXH96xn1efu9mZqfgM%20jVZo24v6CAiLg

Livro Python para Pentester e Hackers

https://mega.nz/#!atQHACib!jff1wMGqCDMq1s8CjGWcbLDAcgol53DXvWYrwehV6tE

Curso de PHP

https://mega.nz/#F!WJVmQI4K!oosRA55mOWFMGR5qu9ssJg

Curso DreamWeaver

https://mega.nz/#F!AUhkiSpK!HlSxR0lexLecXjCowGG3AQ

Curso de Redes

https://mega.co.nz/#F!hZxDHLIZ!Pw8xfRmJirbL9Jvvip_iKw

Segurança em Redes

https://mega.co.nz/#F!cdQWjA5S!cX1sn4-sDpl1iWTH2b8-8w

Banco de Dados

https://mega.co.nz/#F!4R4ywJYb!-QLSTcDQ7GyhLeauC9HOlA

Curso de Eletrônica

https://mega.co.nz/#F!EYplFZRJ!Hd3g53t4SWuZ_ocF1fGLaw

Curso de JOOMLA completo

https://mega.co.nz/#F!kAohEChQ!C0XDspJDpw7tVxAgZizcaw

Curso de Linux

https://mega.co.nz/#F!YNI3kS5R!VsbYhu0sYIidqlKwwnH14Q

Curso Hardware

https://mega.co.nz/#F!EBAUCBDC!M2L3z07ypj05HtAQSeXkGA

Mega pacote de cursos Alura

https://mega.nz/#!FhxXwK7K!-Kzt-IDBs-rhVWC1_DgaULd7vSkZG7dWULCi_99kiOY

Curso Wireless Hacking

https://mega.co.nz/#F!AFJm2TLK!I6f4pZSX2ltoGBs0b1ztsQ

Curso WordPress

https://mega.co.nz/#F!cBIUBDTZ!Qtx1ahx-YeXUPdzIghwatA

Engenharia de software

https://mega.co.nz/#F!gUAmjbpD!BW7cylJHD_rcO1rryJ1sVQ

Hacking

https://mega.co.nz/#F!ER53kboI!H2RKhe5oMegv0APK2cQoFQ

https://mega.co.nz/#F!9QhWHbTI!oarMp7t3tzyY_yu08KHoEQ

Hardware

https://mega.co.nz/#F!oIZW3AzQ!LqcZV5fNLLmsxKfXAl6EtA

Introdução aos Sistemas Operacionais

https://mega.co.nz/#F!oZpVgbTR!MnX35yBQTexHPm4J8nIP2A

Linux

https://mega.co.nz/#F!YNg3xYhY!KQxsOV5rOF4ZhZm5LaiTwQ

Linux Essentials

https://mega.co.nz/#F!sBZhXDAI!NCWJslFznUXBaymdg_kmuA

Lógica de Programação Usando Python

https://mega.co.nz/#F!QAZ31aYY!JtCs0a5who41VK3jNsBa4Q

OYS pentest – Curso Teste de Invasão em Redes e Sistemas

https://mega.co.nz/#F!dVQkDTIQ!MLNKb5ZELHuIarpqHA0HxQ

Programação WEB

https://mega.co.nz/#F!AQQU3LYI!MIYAsxFZtfFTxpIqfHfIBg

Redes

https://mega.co.nz/#F!NMh1SZQC!5CKtEXGJy2JrIafPhvUuew

Segurança

https://mega.co.nz/#F!MN402QIb!_S4Jg-opFAFQVtl3lR4yJQ

Sistemas Operacionais

https://mega.co.nz/#F!JJAVwQAC!FB-jqhynRl_3CUuNzt7oMw

Software Livre

https://mega.co.nz/#F!EMgUkKxI!Wmv2SRC5bQNiLaZdbNBa9w

Teste de Invasão em Redes Sem Fio

https://mega.co.nz/#F!AUQwgIpa!NFW83TBeph3-7A7-LZqy4Q

Apostila HTML CSS

https://mega.co.nz/#!8FpXjbKB!11EMXK2wdfH3OC5BseR0PMbT9MYSGO%20tMtJrfiv5umEE

Artigo – wireshark

https://mega.co.nz/#!pc43VIpR!qy50wLU0yM7TsaeJtNu7RdaFw88BId%20VmDxCqd_E7ouQ

Curso Android Básico

https://mega.co.nz/#!pRAglZqB!hxJ9kG6dvUVukuT5tKQFMzf7_2jKdx%20V4SjM-IFzl2ns

Curso Banco de dados SQL e Modelagem

https://mega.co.nz/#!QYZSlCLB!FudRrApaiBV1oshkcHo2Rm38KeKSk1%20i_WN_0G84Q41M

Curso completo de Python

https://mega.co.nz/#!pEwA1IBL!REq1z_rnrc-ttqhEI-aGnxHcxc__0x%20gix5F98CwCkKI

Curso Linux

https://mega.co.nz/#!JIxVgYTZ!2aVR4SMtttlGoaEbTl7NGXa8n_VuhE%20K9XzjrlchSqss

Curso ipv6

https://mega.co.nz/#!xd50wAjA!sXt5m6tdZkZ_0ppNw7RKAw9gWgNYsM%20qVR12tr9FoTvM

Hackeando Mentes

https://mega.co.nz/#!kIBzmYAQ!VEYe_yI1Q6xBBsq_m5yvv_eIG3DH3n%20Xbp2AKkqLly88

Hacker inside

https://mega.co.nz/#!9ZgSyCCY!sBTV9Mva-fCYw5QKF0TkJfolcDsuox%20KqadjDqrjQTIM

Kevinmitnick a arte de enganar

https://mega.co.nz/#!INJglDRQ!H1KGBLTP9pEWtfZrp5VAbspu0Uo_Me%20_hkvtNh4B3Dm0

Banco de dados

https://mega.nz/#F!edRGmCIC!RS7TIjy7Krd4blcpLk2_hw

Computação Forense

https://mega.nz/#F!LVZgyKxT!0UEl9uphWKK5XN2iHo2ZTg

Curso inglês

https://mega.nz/#F!rMQW2CiD!nUNJvZ1nIeRHBMx33Vw8oQ

DeepWeb

https://mega.nz/#F!SdACSJSL!ck9c2S2FvjdI-L1ji-8JkQ

Edição de imagens

https://mega.nz/#F!vFIGFBpI!eRnEOpNziIS_mZx4IAIUsg

Engenharia de software

https://mega.nz/#F!ScwiGDhY!mFZz6mdkPMGVs5_6ZPOQeQ

Hacking

https://mega.nz/#F!vVoUhSrY!CCRwM3BC7U31BaAFZHl5SQ

Introdução a sistemas operacionais

https://mega.nz/#F!3doigIaC!pbDI81QC_3K2sD-Y08i1_g

Microsoft office

https://mega.nz/#F!KE4h2KQJ!ARugbDhPAqm9WWet6R606g

Normas para a apresentação de trabalhos acadêmicos

https://mega.nz/#F!2YpWWYrQ!njzFN2wdEjcL-n48ouCwvA

Programação WEB

https://mega.nz/#F!Lc4jwILR!YjIOrB8spSKjbwHmNvP8hQ

Redes

https://mega.nz/#F!vdIXgCRB!LpBx2GGbuthGu7FLHL5CsA

Segurança

https://mega.nz/#F!bFgHiBZB!XHC6bDoVYO3JEMJzf3pPmg

Sistemas operacionais

https://mega.nz/#F!fBxDULYK!g6jOZV3cjXwLYzuWhqCUnA

Software Livre

https://mega.nz/#F!HFABDDgQ!eH-cL2wdBu5y_fbY8yV78A

Teoria da computação

https://mega.nz/#F!rRwjTSiC!QOCkako5vL8sIarKYrZHPA

Vídeo aulas

https://mega.nz/#F!iJgkhDRI!LcvTfLA5rRUe1fwdqa1BUA

São tantos cursos que não dá nem pra mencionar aqui do que eles tratam, mas tem coisa muito boa lá, e grande parte deles são bem atuais, tratando sobre Web, Deepweb, Programação, Pentest, Hacker, Linux. Office, Idiomas, e muitos mais.

+BONUS DE MAIS 380GB em cursos ainda não catalogados:

https://mega.co.nz/#F!98cg2TSR!1q1OctEo3sOq25J11JAbOg

https://mega.nz/#F!V55BFDbD!3cBs3zMuk168LXfhfRmm-g
https://mega.nz/#F!wVsCjS7A!K7jrAMW6b7RX_AC6TT3msA!tZcAXCrK
https://mega.nz/#F!mIcTSRgJ!or6uaG2MJdh4jEKuHPYo_g!SAEDHBbB
https://mega.nz/#F!wVsCjS7A!K7jrAMW6b7RX_AC6TT3msA!ARcBlRhZ
https://mega.nz/#F!WJVmQI4K!oosRA55mOWFMGR5qu9ssJg
https://mega.nz/#F!wVsCjS7A!K7jrAMW6b7RX_AC6TT3msA
https://mega.nz/#F!WcBzgZhK!pJ1WsYkq8Evo1EhJi5oiJA
https://mega.nz/#F!mBB1BSrJ!RPojuKs757rJAIk-hVo4vw

https://mega.nz/#F!khhRAbwa!W5xZdG5Yat_y10Em_rmCng

https://mega.nz/#F!AE9GlDRT!mQQ1laUDxLw52-q1DljDsg

https://mega.nz/#F!CV9WFJYK!cjNuwXYg5wm6rc0YZTqaIg

https://mega.nz/#F!YF12iJ6B!933zM4O_EAxQWR16jC7I3Q

https://mega.nz/#F!ml8xGDYT!8LXsPyDMvQj8jWaM1k4rYQ

https://mega.nz/#F!tsNijbTR!Qj–39YrI4RsIwu6NTrfTQ

http://suporteninja.com/mais-de-300gb-de-cursos-em-ti-para-download-no-mega/

( Na verdade tem mais de 600GB de conteúdo)

Projeto Valkyrie

Você pode usá-lo para automação residencial, bem como controlar dispositivos como braço robo, robôs etc. Valkyrie está ligado à IOT usando Wi-Fi, BLE, Bluetooth clássico, UHF RF Transceiver e XBee, usando o protocolo universal chamado V-API. Este é Valkyrie o caminho futuro do gesto e voz controle.

Características do projeto Valkyrie:

  • processamento de movimento em tempo real inovadora
  • serviço de controle de voz
  • detecção de controle por gestos inteligentes
  • aplicações para smartphones
  • funcionalidade de Bem-Estar
  • API aberta para desenvolvedores
  • Várias interfaces de comunicação

Luva: Projeto Valkyrie é destinado a completar o desafio “SpaceGlove”. Para os 2 dias que trabalharam nesse projeto nós fizemos uma luva de couro e material elástico que é confortável para o uso diário e trabalha cerca de 70 horas em modo de transmissão de energia integral.

Com essa luva, fizemos experiências para controlar muitos dos dispositivos domésticos padrão (lâmpadas, luzes, aquecedor de fã, tiras de luz LED, TV, caixa de configuração) com gestos baseados tais como slide, de cima para baixo, para baixo-up etc Depois que fizemos um serviço que está transmitindo dados a partir da luva a um iPhone, e nós temos modificado a base de dados gesto, e acrescentou gestos personalizados. Com precisão de 10% que têm distinguido com sucesso 16 gestos diferentes e adicionou suporte para mais de 60.

Centro de controle: . Para controlar muitas interfaces precisamos de um centro de controle que está repetindo sinais recebidos a partir de qualquer das interfaces de comunicação e enviá-lo para as outras interfaces
As seguintes interfaces são suportados:

  • Wi-fi
  • Bluetooth Low Energy
  • Classi Bluetooth
  • XBee (ZigBee)
  • 433 MHz transceptor de rádio, e
  • comunicação USB

 Nós integramos muitas bibliotecas e de comunicação único e universal e implementou-lo em um V-API (Valkyrie API). A ideia na V-API é que é pode ser usado com qualquer tipo de dispositivos e usando o protocolo universal você pode facilmente escrever os códigos para a comunicação. O V-API é explicado em detalhes no slide 17 da documentação de hardware e firmware incluídos nos recursos.

Luva das posições dos sensores e descrições:

AccGyro

force-sensor graphic

heart-rate-sensor

As aplicações móveis: Nós desenvolvemos 2 aplicações de interface com o centro de comando (e a luva) – uma para Android e um para iOS. O aplicativo Android usa apenas o serviço de detecção de voz usando o google agora pesquisar e se o comando é reconhecido que envia a solicitação HTTP POST para o nosso serviço on-line (imp elétrica). O serviço Android está trabalhando no telefone, bem como no relógio Android. O aplicativo iOS suporta serviço feito sob encomenda Reconhecimento de voz, controle de automação residencial usando a voz ou entrada directa na aplicação, e informações da estação meteorológica. O nosso serviço de bem-estar está verificando a sua frequência cardíaca automaticamente a cada 30 minutos ou continuamente enquanto você está treinando. Ele também pode contar seus passos e detectar sua qualidade de sono. O aplicativo também pode ser usado para upload de novo firmware para a luva e para criar mais gestos de ser reconhecidos pela luva e ligá-los para executar uma variedade de ações.

iPhoneScreens

No momento, temos uma luva totalmente funcional, a aplicação iOS com todas as propriedades que precisamos, controles remotos para computadores (luva agindo como dispositivo HID), controle de telefone embora o serviço HID BLE, controle de casa inteligente com os hábitos e gestos já implementadas, controle robo braço, controle de jogo de computador, controle rover / carro gesto, controle remoto da TV inteligente e muitos mais por causa do protocolo V-API universal que pode ser usado em muitos lugares.

Q & A:

  • Não há gravidade no espaço aberto – podemos usar um transmissor magnético para determinar o ponto “zero” no espaço e usá-lo para calibrar e sentir a gravidade pseudo e velocidade angular.

  • É difícil usar a maioria dos dispositivos de comunicação GHz no espaço – É por isso que nós temos transceptores de 433 MHz  no Centro de Controle. As bandas de VHF e UHF são capazes de penetrar na atmosfera terrestre e transmitir a comunicação de baixo ruído da terra para o espaço. Isto é usado pelos radioamadores para fazer QSOs utilizando as estações espaciais internacionais como repetidor.

  • velocidade de dados de baixo se o dispositivo controlado é muito longe da terra – não há muito que possamos fazer sobre isso, então decidimos fazer macros personalizadas (por exemplo, se você está controlando braço robótico), você faz o movimento uma vez com a mão então este é enviado para o braço robótico, que memoriza o movimento e fazê-lo pelo comando. Por exemplo no vídeo temos usado este sistema para agarrar a caixa e movê-lo algumas polegadas atrás.
  • Conexão cai enquanto controla algo – Se não há nenhuma conexão para 300 ms, a operação pára até que a ligação não for retomada.
  • Carregar – estamos considerando o carregamento sem fio, porque com as novas tecnologias no carregamento sem fio é possível cobrar 800 mAh por menos de 40 min.
  • Consumo de energia – é 13 – 15 mA no modo de transmissão.
  • você pode usar dispositivos externos (como celulares com Android, Bluetooth Joystic) para controlar dispositivos periféricos Control Center – Sim, pode-V API é um protocolo universal para comunicação, todos os relatórios recebidos são repetidos para as outras interfaces de comunicação.

Imagens da luva feita durante os 2 dias do desafio Apps Space: sistema de sensor de pressão real.

IMG_2025_photoshop

 

Desenvolvimento futuro

  • Para tornar totalmente funcional Aplicativo para Android
  • Para adicionar mais sensores para a estação de controle
  • Para melhorar e tornar as bibliotecas V-API claramente legíveis para C, C ++, C #, Java, Java Script, Objective C
  • A cooperar com muitas universidades e outras instituições de ciência em todo o worlд
  • Para tornar a placa de circuito impresso flexível para a luva
  • Para desenvolver personalizados Bluetooth Serviços de Energia baixa para ser fácil de usar por desenvolvedores Android / iOS
  • Para adicionar mais documentação e estabelecer centro de suporte para suportar os desenvolvedores usando o nosso V-API
  • Para fazer algumas variações a luva por exemplo, negócios, esporte, casual e fazer o hardware para ser fácil mutável
  • Testes oficiais
  • Lançamento do projeto (Se começarmos em 2015/06/01 até o final de setembro ’15 teremos um produto)

 

https://open.nasa.gov/innovation-space/valkyrie/

Como criar UIPageViewController Usando Storyboard

We’ve covered UIPageViewController before. The original tutorial demonstrates how to create UIPageViewController using Interface Builder. To make it compatible with iOS 7 and Xcode 5, we completely rewrite the whole tutorial. In addition, we’ll use Storyboard to create UIPageViewController.

For the very first time you launch an app, you’ll probably find a series of walkthrough (or tutorial) screens to give you a brief introduction of the features. It’s a common practice to explain how the app works. In this tutorial, we’ll show you how to build a similar type of walk through screens by using UIPageViewController.

The UIPageViewController class was first introduced in iOS 5 SDK that lets developers build pages of content, where each page is managed by its own view controller. The class was further improved in iOS 6 to support the scrolling transition. With page view, users can easily navigate between multiple pages through simple gesture. The page view controller is not limited to create walkthrough screens. You can find examples of page view implementation in games like Angry Birds to show the available levels or book apps to display pages of content.

page-view-controller-nilton-felipe

The UIPageViewController is a highly configurable class. You’re allowed to define:

  • the orientation of the page views – vertical or horizontal
  • the transition style – page curl transition style or scrolling transition style
  • the location of the spine – only applicable to page curl transition style
  • the space between pages – only applicable to scrolling transition style to define the inter-page spacing

We’ll create a simple app together in order to demonstrate how UIPageViewController works. However, we’ll not demonstrate every option of UIPageViewController. We’ll just use the scrolling transition style to display a series of walkthrough screens. Don’t worry. With the basic understanding of the UIPageViewController, I believe you should be able to explore other features in the page view controller.

Let’s get started.

A Glance at the Demo App

The demo app we are going to create is very simple. It displays 4 pages of screens to give users a brief introduction to the user interface. User can navigate between pages by swiping through the screen. Whenever user taps the “Start again” button to go back to the first page of tutorial. This type of walkthrough/tutorial screens shouldn’t be new to you as they are commonly found in apps such as Snapguide and Airbnb.

page-view-controller-1-2-nilton

Creating the Project

Launch Xcode and create a new Project by using the Single View Application template. It might seem a little bit strange to select the Single View Application template as Xcode already comes with a Page-Based Application template, which contains a fully functional app based on the UIPageViewController. However, this template is a little bit complex and it will take us more time to clean-up the code of the template than to start from scratch. Needless to say, we can better grasp the concept behind the UIPageViewController when we start from scratch.

page-view-controller-1-3-nilton

Okay, let’s move on. In the next screen enter PageViewDemo as the product name and set com.appcoda in the company identifier field. Select iPhone for the Devices option. Press next and create the project.

page-view-controller-1-4-nilton

Creating Page View Controller in Storyboard

Next, select the Main.storyboard. As usual, you should find a default view controller generated by Xcode. Leave it as it is. Drag a Page View Controller from the Object Library into the storyboard. Then add another View Controller and put it in the same storyboard.

page-view-controller-1-5-nilton

For this project, the original view controller is used as the root view controller for holding the page view controller. The view controller you’ve just added will be used for displaying the page content. Throughout the article, we refer the original view controller as the root view controller and the other view controller as page content controller.

You may wonder why we just add a single view controller for 4 pages of content. Shouldn’t we use four view controllers instead of one? As you can see from the final deliverable, the walkthrough screens are very similar. It’s better to share the same view controller for different screens.

Next, assign a Storyboard ID for the page view controller and the page content controller. You can simply select the controller and set the ID under Identity Inspector. Set the Storyboard ID of the page view controller as “PageViewController” and name the ID of the page content controller as “PageContentController”. Later we’ll refer to these IDs in our code.

page-view-controller-1-6-nilton

By default, the transition style of the page view controller is set as Page Curl. The page curl style is perfect for book apps. For walkthrough screens, we prefer to use scrolling style. So change the transition style to Scroll under Attribute Inspector.

page-view-controller-1-7-nilton

We’ll design the user interface of page content view controller. Drag an image view and a label into the controller. You’re free to change the font type and size. But your view controller should be similar to the below screenshot.

page-view-controller-1-7-nilton

For the default view controller, add a “Start again” button and put it at the below of the screen.

page-view-controller-1-8-nilton

Creating View Controller Class

The next step is to create view controller class and associate it with the corresponding view controller. From the menu, select File -> New -> File … and choose the “Objective-C class” template. Name the class as PageContentViewController and make it a subclass of UIViewController.

page-view-controller-1-9

Go back to Storyboard. Select the page content view controller and set the custom class to PageContentViewController under Identify Inspector.

page-view-controller-1-10

Next, we’ll create outlets for the image view and label. Switch to the Assistant Editor and make sure the PageContentViewController.h is opened. Control and drag from the image view to the PageContentViewController.h and create an IBOutlet. Set the name as backgroundImageView for the image view. For the label, set the name of the outlet as titleLabel.

page-view-controller-1-11-nilton

After the change, the PageContentViewController.h should look like this:

Next, select the root view controller and make sure the ViewController.h is opened. Create an action for the “Start again” button and name the action as “startWalkthrough”.

page-view-controller-1-12

Okay, we’ve completed the design of user interface and created all the outlets. Let’s move onto the implementation of the view controller classes.

Implementing the Page Content View Controller

It’s very straightforward to implement the page content view controller. First, add the following properties in PageContentViewController.h:

The pageIndex stores the current page index (or page number). The view controller is designed to display an image and a title. So we create two parameters for passing the title text and image file. Next, open PageContentViewController.m and change the viewDidLoad: method:

Implementing the Page View Controller

The UIPageViewController class is classified as a container controller. The container controller is used to contain and manage multiple view controllers shown in the app, as well as, controlling the way one view controller switches to another. Here the UIPageViewController is the container controller that lets the user navigate from page to page, where each page is managed by its own view controller object. The following illustration depicts the relationship between the page view controller and the page content view controller.

page-view-controller-1-13

In order to make UIPageViewController work, we must adopt the UIPageViewControllerDataSource protocol. The data source for a page view controller is responsible for providing the content view controllers on demand. By implementing the data source protocol, we tell the page view controller what to display for each page.

In this case, we use the ViewController class as the data source for the UIPageViewController instance. Therefore it is necessary to declare the ViewController class as implementing the UIPageViewControllerDataSource protocol.

The ViewController class is also responsible to provide the data of the page content (i.e. images and titles). Open the ViewController.h. Modify the @interface declaration, add a new property to hold the UIPageViewController, as well as, properties for both images and titles:

In the ViewController.m, initialize the pageTitles and pageImages in the viewDidLoad method:

Note: You can download image files from here and add them into the Xcode project.

We have created the data model for the page content. Next, we have to implement at least two methods of the UIPageViewControllerDataSource protocol:

  • viewControllerAfterViewController – provides the view controller after the current view controller. In other words, we tell the app what to display for the next screen.
  • viewControllerBeforeViewController – provides the view controller before the current view controller. In other words, we tell the app what to display when user switches back to the previous screen.

Add the following lines of code before the end of the ViewController.m file:

The above methods are very straightforward. First, we get the current page index. Depending the method, we simply increase/decrease the index number and return the view controller to display. Of course, we have to verify if we have reached the boundaries of the pages and return nil in that case.

As you may notice, we haven’t created the viewControllerAtIndex: method. It is a helper method that is designed to create the page content view controller on demand. It takes in the index parameter and creates the corresponding page content controller.
In the ViewController.m, add the helper method:

Recalled that we have set a storyboard ID for the view controllers when designing the user interface. The ID is used as reference for creating the view controller instance. To instantiate a view controller in storyboard, you can use the instantiateViewControllerWithIdentifier: method with a specific storyboard ID.

To display a page indicator, you have to tell iOS the number of pages (i.e. dots) to display in the page view controller and which page must be selected at the beginning. Add the following two methods at the end of the ViewController.m file:

Again the above code is very straightforward. We simply tell iOS that we have the total number of pages to display in the page view controller and the first page should be selected by default.

Note: You must implement both methods in order to display the page indicator. Also the page indicator only works in scroll transition mode.

Initializing the UIPageViewController

The final step is to create and initialize the UIPageViewController. The best place to do that is in the viewDidLoad method. Open the ViewController.m file and change the method to:

Let’s see what the method does. We first create the PageViewController instance. Next we specify the data source, in this case it is the class itself. We then create the first page content controller, add it to an array of controllers and assign it to the page view controller for display.

Lastly, we change the size of the page view controller and add the page controller view to the current view.

Customize the Page Indicator

If you compile and run the app now, your app should run properly but you may find the page indicator missing. Actually the page indicator is there but the color of the dots is the same as the color of the view. So let’s change its color.

In the AppDelegate.m, add the following lines of code in the didFinishLaunchingWithOptions: method:

Compile and Run the App

And there we go, start the application and see how the UIPageViewController works. You should be able to load the page view controller by using the iPhone Simulator. Try to swipe through the screen to navigate between pages.

page-view-controller-1-14-nilton

Back to the First Page

There is still one thing left. The “Start again” is not yet implemented. When tapped, we expect the page view controller will scroll back to the first page. You can use the setViewControllers: method of the UIPageViewController to switch page. To go back to the first page of the page view controller, change the startWalkthrough: method of ViewController.m:

Run the app again. The app will bring you back to the first page when tapping the “Start again” button.

Summary

In this tutorial, we cover the basics of UIPageViewController and demonstrate how to implement the controller by using Storyboard. The UIPageViewController is a very handy class for implementing walkthrough screens in your app. That said, the usage of UIPageViewController is unlimited. You can use it to display whatever information as you like such as pages of web view. The UIPageViewController is highly configurable. This tutorial only covers the scroll transition style. But don’t you know that you can easily use the class to build a simple book app? Simply change the transition style from scroll to page curl and see what you’ll get. So don’t stop here. Try to change the available options and learn about UIPageViewController.

For your complete reference, you can download the Xcode project from here. As always, please leave us comment and share your thought.

Fonte: http://www.appcoda.com/uipageviewcontroller-storyboard-tutorial/

Chartist.js – criando gráficos responsivos com o chartist.js

Outro dia, pesquisando outras bibliotecas para criar gráficos responsivos com HTML5 e javascript, acabei encontrando esta chamada Chartist.js. Inicialmente eu confundi essa biblioteca com a Chart.JS, achava que era uma espécie de major update, mas depois percebi que era uma solução a parte, mas que também fica nem um pouco para trás em termos de funcionalidades modernas e simplicidade. Acabei criando esse post com base nos testes que fiz na ferramenta então sintam-se livres para encaminhar duvidas e testar o demo que está disponibilizado no artigo.

Bom, esse é o primeiro post de 2015 no blog, então um ótimo ano para todos.

Como de costume nos posts do blog, eu sempre crio um demo para tentarexplicar como eu entendi e aprendi a utilizar tal ferramenta. Com essa não vai ser diferente, então segue o link para baixar o demo e o repositório do GitHub.

Introdução ao Chartist.js

O Chartist.js é mais uma solução disponível para facilitar a forma com que trabalhamos com gráficos para web, utilizando HTML5 e JavaScript.

O diferencial do Chartist.js e o motivo que me fez testar a solução foi a questão estética que chama muito a atenção, com um design flat muito bem elaborado, e a simplicidade na utilização da solução, seguindo a documentação (que é tão simples e direta que chega a ser bem curta).

Além disso, os gráficos são renderizados com SVG inline, o que significa que você tem maior controle do gráfico pois as tags SVG que compõem o gráfico estão no DOM. Você pode testar essa funcionalidade visualizando a página do Chartist.js através da ferramenta para desenvolvedores do seu navegador.

Para maiores informações a respeito do Chartist.js, acesse a documentação oficial.

Como utilizar

Bom, como já citei antes, a utilização é muito simples. Primeiro precisamos adicionas os links para os arquivos que presentes nos repositórios, dentro da tag head. No demo ficou algo como:

1
2
<link rel=“stylesheet” href=“//cdn.jsdelivr.net/chartist.js/latest/chartist.min.css”>
<script src=“//cdn.jsdelivr.net/chartist.js/latest/chartist.min.js”></script>

Note que no demo eu utilizei links CDN para os arquivos da biblioteca. Se você quiser testar localmente baixe o repositório do GitHub e substitua os caminhos de apontamento para os arquivos locais, os repositórios CDN precisam de acesso a internet para carregar as funcionalidades da solução.

Após isso podemos declarar as funções para chamar o primeiro gráfico. Antes de criar um gráfico, temos que entender a metodologia de design utilizada pelo Chartist.js para abordar a reponsividade dos gráficos.

Ao invés de utilizar tamanhos fixos para a box (320×320, por exemplo), são utilizadas medidas de proporção, como 4:3, 3:2, 16:9 (famoso widescreen). Com essa técnica fica mais fácil garantir a reponsividade do gráfico em qualquer tamanho de tela.

Com isso em mente, criamos uma box onde o gráfico deve ser renderizado, conforme o exemplo abaixo:

1
<div class=“ct-chart ct-square”></div>

Utilizei a proporção ct-square, que medindo em proporção da um quadrado. Existem diversas medidas na documentação, além dessa do exemplo eu também testei a .ct-perfect-fourth que seria 4:3, e a .ct-golden-ratio.

Se você utilizar uma box com medidas fixas você não precisa declarar uma classe para proporção, basta declarar a função que de fato vai criar o gráfico na box que criamos acima. Utilizamos o seguinte código para criar o gráfico:

1
2
3
4
5
6
7
8
9
window.onload = function() {
var data = {
labels: [‘segunda’, ‘terça’, ‘quarta’, ‘quinta’, ‘sexta’],
series: [
[10, 24, 51, 3, 12]
]
};
new Chartist.Line(‘.ct-chart’, data);
};

Feito isso, e se estiver seguindo o demo, ao carregar a página deve ser apresentado um gráfico similar ao da imagem abaixo.

chartist_js_Nilton_Felipe

Se você criou o gráfico sem uma proporção, você pode utilizar as opções da API para declarar as medidas fixas. Primeiro adicionamos uma variável com as informações de medidas:

1
2
3
4
var options = {
width: 300,
height: 200
};

E depois criamos o objeto com referência a variável:

1
new Chartist.Line(‘.ct-chart’, data, options);

Na documentação oficial, na parte de informações sobre a API você tem todas as informações sobre as opções disponíveis para customização do gráfico. Com o Chartist.js você consegue customizar praticamente qualquer gráfico que você criar, ainda mais utilizando SVG inline para renderizar os gráficos.

Além deste exemplo, no demo que eu criei tem mais três testes, apresentando quatro gráficos em uma mesma página, com diferentes valores e estilos.

As opções de customização do Chartist.js vão ainda muito além, você pode animar a visualização do gráfico, criar sinalizadores para pontos cruciais, tudo isso com recursos disponíveis na própria biblioteca da solução que é toda baseada em JavaScript, mais alguns plugins disponíveis para funções especificas.

Não vou muito a fundo na ferramenta porque a intenção era apenas uma introdução, mas se você conseguiu entender como funciona a biblioteca até aqui, acredite, não vai ter problemas para criar exemplos mais avançados como estes exemplos da documentação, e este exemplo abaixo (visualize no Chrome para um resultado satisfatório).

Fonte: http://websocialdev.com/chartist-js-criando-graficos-responsivos-com-o-chartist-js/