Zehortigoza

by Johan

by fidel

by OWC

by @leecheve

by Sid

http://lavabit.com/

by secondhype

Não sou conhecedor de tudo que o sistema Linux tem , mesmo por que
uso a pouco tempo , mas vou tentar explanar alguns conceitos básicos,
dos quais me deparei no decorrer dos anos.

Kernel do Linux é um programa bem complexo escrito na linguagem “ansi C“,
com algumas partes específicas de cada arquitetura de computador utilizando
“assembly“, sua missão é fazer o elo entre software e hardware. Quem já compilou
o kernel já teve o privilégio de ver uma tela com “ncurses” com uma das opções
“loadable Module”, se você ativar, poderá ativar e desativar drivers e funções,
maioria dos sistemas linux já vem com esta opção ativada , Estes módulos são
partes do “kernel” que possibilitam serem incorporados e removidos,sem a
reinicialização do sistema.

caso queira ver o código do kernel do linux
baixe o AQUI

Syscalls é um ponto de entrada para o kernel Linux, são chamadas indiretas
a maioria das chamadas de sistema têm correspondentes funções da biblioteca
C , um wrapper que executar os passos necessários (por exemplo, prendendo ao modo
kernel). Assim fazendo uma chamada de sistema é o mesmo que chamar uma função
de biblioteca normal.

antes de partir para o rock n roll, vamos entender o básico de inline ASM
__asm__("" : saida : entrada : modificador);

exemplo adição simples com “ADD”

#include <stdio.h>
#include <unistd.h>
 
int main()
{
  int data1 = 8,data2 = 3;
 
  __asm__("addl  %%ebx,%%eax":"=a"(data1):"a"(data1), "b"(data2));
  fprintf(stdout, "data1 + data2 = %d\n", data1);
 
  return 0;
}

Vamos analisar como um código em linguagem C ,interrupção para um syscall
no caso o write() , veja a tabela aqui

 int write(int fd,const char * buf,unsigned int count)
    {
        long __res;
        asm("int $0x80"
            : "=a" (__res)
            : "0" (__NR_write), "b" ((long)fd),
              "c" ((long)buf), "d" ((long)count));
        if ((unsigned long)__res >= (unsigned long)-129) {
            errno = -__res;
            __res = -1;
        }
        return (int) __res;
    }

de onde veio o “__NR_write” ?

$cat unistd_32.h | grep write
#define __NR_write 4

algo equivalente a

  write:
         pushl %ebx              ; adiciona ebx na pilha
         movl 8(%esp), %ebx      ; adiciona primeiro argumento em ebx
         movl 12(%esp), %ecx     ; adiciona segundo argumento ecx
         movl 16(%esp), %edx     ; adiciona terceiro argumento edx
         movl $4, %eax           ; adiciona _ _NR_write em eax
         int  $0x80              ; interrupção para syscall
         cmpl $-125, %eax        ; checa o retorno 
         jbe .PULA               ; se nenhum erro JUMP para PULA
         negl %eax               ; complementa valor em eax
         movl %eax, errno        ; adiciona resultado em errno
         movl $-1, %eax          ; seta eax para -1
  .PULA: popl %ebx               ; tira ebx da pilha
         ret                     ; returna chamando programa

Em caso de erro, a maioria das chamadas do sistema retornam um número
negativo erro (ou seja, o valor negado de uma das constantes descritas
na errno (3)). O wrapper da biblioteca C esconde esse detalhe do chamador,
quando uma chamada de sistema retorna um valor negativo, o wrapper
copia o valor absoluto na variável errno, e retorna -1 como o valor de
retorno do wrapper.

O valor retornado por uma chamada de sistema bem sucedida, varia da chamada,
mais detalhes estão descritos no manual de páginas individuais. GNU C Library (glibc)
fornece a interface de syscall que se conecta ao kernel e fornece o mecanismo
para transição entre o aplicativo de espaço de usuário e o kernel.

mais informações
$ man syscall
$ man libc

Voltando para módulos de kernel

Qual é a vantagem de trabalhar com módulos do kernel ?

Bom você não precisa reiniciar seu sistema operacional toda vez que quiser
testar um driver, fora a transparência em que o linux faz isso, ajuda na
otimização do mesmo.
Vamos na prática

Arquivo que contém o módulo é um “arquivo objeto”, bem como um programa
gerado com GCC para depois compilar,utilizando oa argumento “-c”(compile only),
eles contêm símbolos para ajudar o kernel no percurso de carregamento de registro,
em suma passam pelo filesystem onde esta como “arquivo objeto” para memória RAM na
parte destinada de programas sendo carregados por um syscall, no endereço correto
reservada ao kernel.

vamos fazer nosso primeiro módulo

Makefile:

KDIR := /lib/modules/$(shell uname -r)/build

# Objeto
obj-m = macacos.o

# Regra default do Makefile
default:
        $(MAKE) -C $(KDIR) M=$(PWD) modules
        @rm -rf *.mod* Module.symvers *.o *~ *.markers *.order

# Limpando objetos e afins
clean:
        @rm -rf *~ *.o *.ko

arquivo macacos.c

#include <linux/module.h>

int init_module(void)
{
 printk("macacos me mordam \n");
 return 0;
}

void cleanup_module(void)
{
 printk("saindo\n");
}

MODULE_AUTHOR("Cooler_ ");
MODULE_DESCRIPTION("Just another test");
MODULE_LICENSE("BSD");

Passamos alguns comandos para compilar e instalar nosso módulo
e um comando para conferir se o módulo foi inserido…

$ make; insmod macacos.ko; dmesg | grep macacos
[17205.255807] macacos me mordam

Para remover o módulo
$ rmmod macacos

Olhe que interessante analisando o arquivo “.ko” com comando “strings”
$ strings macacos.ko
macacos me mordam
saindo
srcversion=F9191437D66715B7ADCB1E5
depends=
vermagic=3.0.0-14-generic SMP mod_unload modversions 686
module_layout
Pprintk
mcount
macacos

Bom o “insmod” usamos para instalar módulos e o “rmmod” para remover
como foi mostrado no exemplo, além deles temos o “lsmod” para listar módulos
exemplo

$ lsmod | grep snd
snd_hda_codec_hdmi     31426  1 
snd_hda_codec_realtek   254125  1 
snd_hda_intel          24262  6 
   |                      |    \_referências de outros módulos...
   |_ Nome Modulo         |_memória usada pelo módulo

“modinfo” para se obter informações do módulo
$ modinfo snd_pcm
filename: /lib/modules/3.0.0-14-generic/kernel/sound/core/snd-pcm.ko
license: GPL
description: Midlevel PCM code for ALSA.
author: Jaroslav Kysela , Abramo Bagnara
srcversion: B1C966040673ADEA6AD0FAA
depends: snd,snd-page-alloc,snd-timer
vermagic: 3.0.0-14-generic SMP mod_unload modversions 686
parm: preallocate_dma:Preallocate DMA memory when the PCM devices are initialized. (int)
parm: maximum_substreams:Maximum substreams with preallocated DMA memory. (int)

Isso foi uma breve introdução…

A UART é um velho conhecido de todo engenheiro de sistemas embarcados, é provavelmente o primeiro protocolo de comunicação que aprendemos na universidade. Neste artigo vamos...
veja+

The post Projeto completo de uma UART em MyHDL – Gerando VHDL / Verilog e testando no FPGA appeared first on Embarcados - Sua fonte de informações sobre Sistemas Embarcados.

TLDR

I’ve written a hello world for wayland. It’s available at:

https://gitlab.com/hdante/hello_wayland

Introduction

From the end user perspective it’s very easy to understand what wayland is: it’s a new window system with the display server and window manager merged [1]. From a technical point of view, the goal of wayland is to break from legacy and implement an efficient window system with modern design for modern graphics usage, solving long standing efficiency problems and specific corner cases present in the X Window System [2]. This tutorial shows how to implement a hello world client application for wayland, explaining essential wayland concepts and all the steps required to create any fully working wayland client. The hello world application does not use any GUI toolkit, it directly uses the low level wayland protocol, so that the fundamental parts of wayland are described. The tutorial is a result of my own study of the wayland protocol. The tutorial is divided into 2 posts. This is the first post, that will explain all the concepts and the high level part of the hello world application.

What is wayland again ?

The complete design for the wayland window system is split into several layers. If you download the wayland library source code [3], or take a look at the wayland API [4], you will notice two layers:

1. The most basic layer is an implementation of inter process communication functionality, together with a few utilities, like a main loop dispatcher and some data types. This is nearly all code present in the wayland library (everything inside the src directory [5]) and has almost no code related to window systems.
2. The second layer is the window system protocol. Its description is located in a single file, protocol/wayland.xml [6], which should be considered the protocol written in an interface definition language. The IDL file can be passed through the wayland-scanner tool to generate proxy methods in wayland-client-protocol.h and wayland-server-protocol.h. The protocol defines the essential functionality for client applications and the display server, like providing access to input devices and registering shared buffers for displaying on the screen. The wayland library does not implement this protocol. Instead, implementation is split into a third separate layer. In particular the reference server side implementation is part of the weston display server [7], which in turn defines additional layers, both server and client side, to complete the set of wayland protocols. We don’t need to know anything about weston for the hello world application, though, the IDL file has all we need to implement the client-side protocol.

From the description of the wayland library given above, we have successfully found a third definition of wayland, it’s a (special purpose) IPC library, not unlike the D-Bus library, instead of a display server, and this lack of definition for what wayland really is, and how well defined the wayland protocols are and where, is present everywhere. I believe it’s common for people not understand what wayland is even after reading official documentation. I think that the three definitions given clarify the “what is wayland” problem and each can be used for different contexts.

Hello, World!

The introduction ended up rather large, so lets see the main hello world code at once:

#include 
#include 
#include 
#include 
#include 
#include 

#include "helpers.h"

static const unsigned WIDTH = 320;
static const unsigned HEIGHT = 200;
static const unsigned CURSOR_WIDTH = 100;
static const unsigned CURSOR_HEIGHT = 59;
static const int32_t CURSOR_HOT_SPOT_X = 10;
static const int32_t CURSOR_HOT_SPOT_Y = 35;

static bool done = false;

void on_button(uint32_t button)
{
    done = true;
}

int main(void)
{
    struct wl_buffer *buffer;
    struct wl_shm_pool *pool;
    struct wl_shell_surface *surface;
    int image;

    hello_setup_wayland();

    image = open("images.bin", O_RDWR);

    if (image < 0) {
        perror("Error opening surface image");
        return EXIT_FAILURE;
    }

    pool = hello_create_memory_pool(image);
    surface = hello_create_surface();
    buffer = hello_create_buffer(pool, WIDTH, HEIGHT);
    hello_bind_buffer(buffer, surface);
    hello_set_cursor_from_pool(pool, CURSOR_WIDTH,
        CURSOR_HEIGHT, CURSOR_HOT_SPOT_X, CURSOR_HOT_SPOT_Y);
    hello_set_button_callback(surface, on_button);

    while (!done) {
        if (wl_display_dispatch(display) < 0) {
            perror("Main loop error");
            done = true;
        }
    }

    fprintf(stderr, "Exiting sample wayland client...\n");

    hello_free_cursor();
    hello_free_buffer(buffer);
    hello_free_surface(surface);
    hello_free_memory_pool(pool);
    close(image);
    hello_cleanup_wayland();

    return EXIT_SUCCESS;
}

The wayland protocol is verbose, so I separated the code into two parts, one containing the protocol details and another, the main module, shown above, containing the high level "hello world" implementation. The main() function is written at algorithmic granularity and represents the complete set of steps necessary to communicate with the display server to display the hello world window and accept input from the pointer device, closing the application when clicked. A description of the relevant parts of the code follows:

#include "helpers.h"

The helper module contains the hello_* functions and a set of global objects present in wayland. The root global object is the display object, which represents the connection to the display server and is used for sending requests and receiving events. It is used in the code for running the main loop. The helpers module will be described in details in the next part of this tutorial.

static const unsigned WIDTH = 320;
static const unsigned HEIGHT = 200;
static const unsigned CURSOR_WIDTH = 100;
static const unsigned CURSOR_HEIGHT = 59;
static const int32_t CURSOR_HOT_SPOT_X = 10;
static const int32_t CURSOR_HOT_SPOT_Y = 35;

In this tutorial we display an image as the main window and another for the cursor. Their geometry is hardcoded. In a more general application, though, the values would be dinamically calculated.

void on_button(uint32_t button)
{
    done = true;
}

This is the button callback. Whenever a button is clicked, we set the done flag to true, which will allow us to leave the event loop in the main() function.

    hello_setup_wayland();

We begin the application calling a setup function, which connects to the display server and requests a collection of global objects from the server, filling in proxy variables representing them.

    image = open("images.bin", O_RDWR);

Then we open the image file. This image file contains the hardcoded images for the hello world application, already in a raw format for display: it’s the pixel values for the main window, followed by the pixel values for the cursor.

    pool = hello_create_memory_pool(image);

A main design philosophy of wayland is efficiency when dealing with graphics. Wayland accomplishes that by sharing memory areas between the client applications and the display server, so that no copies are involved. The essential element that is shared between client and server is called a shared memory pool, which is simply a memory area mmapped in both client and servers. Inside a memory pool, a set of images can be appended as buffer objects and all will be shared both by client and server.

In the hello world application we mmap our hardcoded image file. In a typical application, however, an empty memory pool would be created, for example, by creating a shared memory object with shm_open(), then gradually filled with dynamically constructed image buffers representing the widgets. While writing the hello world application I had to decide if I would create an empty memory pool and allocate buffers inside it, which is more usual and simpler to understand, or if I would use a less intuitive example of creating a pre built memory pool. I decided to go with the less intuitive example for an important reason: if you read the whole hello world source code, you’ll notice that there’s no memory copy operation anywhere. The image file is open once, and mmapped once. No extra copy is required. This was done to make clear that a wayland application can have maximal efficiency if carefully implemented.

    surface = hello_create_surface();

Objects representing visible elements are called surfaces. Surfaces are rectangular areas, having position and size. Surface contents are filled by using buffer objects. During the lifetime of a surface, a couple of buffers will be attached as the surface contents and the server will be requested to redraw the surfaces. In the hello world example, the surface object is of type wl_shell_surface, which is used for creating top level windows.

    buffer = hello_create_buffer(pool, WIDTH, HEIGHT);

The buffer object has the contents of a surface. Buffers are created inside of a memory pool (they are memory pool slices), so that they are shared by the client and the server. In our example, we do not create an empty buffer, instead we rely on the fact that the memory pool was previously filled with data and just pass the image dimensions as a parameter.

    hello_bind_buffer(buffer, surface);

To make the buffer visible we need to bind buffer data to a surface, that is, we set the surface contents to the buffer data. The bind operation also commits the surface to the server. In wayland there’s an idea of surface ownership: either the client owns the surface, so that it can be drawn (and the server keeps an old copy of it), or the server owns the surface, when the client can’t change it because the server is drawing it on the screen. For transfering the ownership to the server, there’s the commit request and for sending the ownership back to the client, the server sends a release event. In a generic application, the surface will be moved back and forth, but in the hello application it’s enough to commit only once, as part of the bind operation.

    hello_set_cursor_from_pool(pool, CURSOR_WIDTH,
        CURSOR_HEIGHT, CURSOR_HOT_SPOT_X, CURSOR_HOT_SPOT_Y);

After setting up the main window, we configure the cursor. This configuration is required: the client must configure the cursor. Here we set the cursor to be the preset contents of the memory pool (implicitly right after the main window buffer). The helper module then creates a surface and a buffer for the cursor. I had to decide if I would hide the cursor configuration in the helper module or if I would explicitly add a high level step for it. I dedided to go with the second one to show the division of roles in wayland: the client is given a large control over what and how to draw.

    hello_set_button_callback(surface, on_button);

The last configuration step is to set up a callback: associate a surface click with the on_button callback.

    while (!done) {
        if (wl_display_dispatch(display) < 0) {
            perror("Main loop error");
            done = true;
        }
    }

This calls the main loop with the global display object as the parameter. The main loop exits when the done flag is true, either because of an error, or because the button was clicked.

    hello_free_cursor();
    hello_free_buffer(buffer);
    hello_free_surface(surface);
    hello_free_memory_pool(pool);
    close(image);
    hello_cleanup_wayland();

The application finishes by cleaning up everything.

Conclusion

This was the first part of the hello world tutorial. A discussion abot what is wayland was presented and operation was described with help of a high level example. In the next part I’ll describe the helper functions in detail.

References

[1] http://wayland.freedesktop.org/architecture.html
[2] http://mirror.linux.org.au/linux.conf.au/2013/ogv/The_real_story_behind_Wayland_and_X.ogv
[3] http://cgit.freedesktop.org/wayland/wayland/tree/
[4] http://wayland.freedesktop.org/docs/html/
[5] http://cgit.freedesktop.org/wayland/wayland/tree/src
[6] http://cgit.freedesktop.org/wayland/wayland/tree/protocol/wayland.xml
[7] http://cgit.freedesktop.org/wayland/weston/tree/

O importante é o status.

Ou ainda…

Este vídeo não é de tecnologia ou mobile, mas eu preciso guardar para tentar fazer em casa!

Não é de hoje que os caras do College Humor me surpreende com ótimas produções para a web. Além do volume de produções e da qualidade, eles sempre estão se renovando e brincando com coisas super atuais.

Neste vídeo a zoação da vez é com o novo filme – que ainda nem foi lançado – do Batman com o Superman. Afinal, como seria o papo entre o Homem Morcego e o Homem de Aço para a formação de uma possível Liga da Justiça?

A excelente dublagem ficou por conta dos brasileiros Eduardo Villas, Thiago Souza e Yamy.

O post Como pegar várias mulheres apareceu primeiro em Testosterona.

Eu costumo dizer que uma das primeiras lembranças que tenho com os videogames são as tardes que passava ao lado do meu pai enquanto tentávamos chegar o mais longe possível no River Raid ou no Enduro e como há mais de 20 anos fui privado de ter a sua companhia, sou muito grato por os games serem mais uma maneira de lembrar dele.

Quem também parece ter muitos motivos para agradecer aos jogos eletrônicos é um usuário do Youtube conhecido como 00WARTHERAPY00. Para que você entenda melhor a sua experiência, vou reproduzir o que ele disse, pois acho que é melhor do que tentar explicar a história:

Bem, quando eu tinha 4 anos, meu pai comprou um fiel Xbox. Você sabe, o primeiro, durão e quadrado de 2001. Nós tivemos uma tonelada de diversão jogando todos os tipos de games juntos – até que ele morreu, quando eu tinha apenas 6 anos.

 

Eu não pude tocar naquele console por 10 anos, mas quando o fiz, percebi uma coisa.

 

Nós costumávamos jogar um game de corrida, o Rally Sports Challenge. Na verdade era muito bom para a época e assim que comecei a vasculhar por ali… encontrei um FANTASMA. Literalmente.

 

Sabem quando uma corrida por tempo acontece e a volta mais rápida até então fica gravada como um piloto fantasma? Sim, vocês adivinharam – o seu fantasma continua andando pela pista hoje em dia.

 

E então eu joguei, joguei e joguei, até que quase pudesse derrotar o seu fantasma. Até que um dia eu o ultrapassei e… Parei em frente a linha de chegada, apenas para me certificar de que não o apagaria.

A única coisa que posso dizer neste momento é, obrigado. Obrigado 00WARTHERAPY00, por ter compartilhado essa bela história com a gente. Obrigado por ter a oportunidade de compartilhar histórias assim com outras pessoas e muito, mas muito obrigado pai, por lá no início da década de 80 ter me dado um Atari, ter passado algumas horas jogando comigo e ter feito com que eu me apaixonasse pelos videogames.

Fonte: Motoramic.

The post Um pai que se foi, um carro fantasma e porque amamos os games appeared first on Meio Bit.

Lamento, mas foi melhor assim

Sem sombra de duvida os melhores memes brasileiros estão aí, pqp muito bom!

Android no desktop? Há algum tempo atrás muita gente via isso como uma possibilidade descartável, entretanto o robozinho do Google tem evoluído de forma considerável a fim de que o sistema seja visto como uma alternativa viável para os fabricantes. Ultrabooks e AIOs tem aparecido mas a oferta ainda é bem limitada, ainda mais pelo fato de que ele não escala o suficiente para suportar programas mais pesados, como deve ser num desktop. O projeto Android.org fornece ISOs x86 próprias para rodar no PC, mas elas possuem alguns problemas e só são indicadas a curiosos.

É aí que entra a equipe responsável pelo iConsole.tv com o Console OS, um fork dedicado a levar o Android a outro nível.

Em primeiro lugar, a equipe responsável pelo projeto deixou claro que o Console OS é voltado para oferecer um produto capaz de escalar o bastante para rodar programas pesados e games sem sofrer com as limitações de hardware de um tablet. O trabalho de 18 meses foi minucioso, de forma a adaptar toques em tela de forma a não prejudicar a performance tanto em uso com mouse quanto em desktops com telas de toque, além de manter um performance mais poderosa para games como mostrado no vídeo. Outro objetivo da equipe é integrar o Windows 8.1 com o Android em dispositivos dual-boot, sejam desktops ou tablets: o Android x86 atualmente não é compatível com o secure boot do sistema das janelas, estratégia essa para eliminar a possibilidade de dividir o Windows 8.1 com outros sistemas na mesma máquina. Claro, é possível desligar o recurso mas oferecer um Android compatível é mais simples.

Confira outros recursos que o Console OS terá em comparação a outros projetos:

A Mobile Media Ventures, empresa responsável pelo projeto está pedindo US$ 50 mil dólares para financiar o projeto, mas é bom deixar claro que não se trata de um projeto open source. Diferente de outros forks, como a ideia é fornecer um sistema operacional escalável para o PC ele não será distribuído gratuitamente. A licença custará US$ 20 dólares por ano, mas quem contribuir com US$ 25 (ou US$ 10, limitados a apenas 10 mil contribuintes) terá acesso a ele sem custos pelo resto da vida, com direito a atualizações permanentes. É claro, é bem provável que uma versão livre pela comunidade acabará aparecendo mais cedo ou mais tarde.

Fonte: KS.

The post Console OS promete experiência Android definitiva em PCs appeared first on Meio Bit.

Taí uma notícia que vai deixar todo mundo ouriçado! Háááá… Ok, desculpem.

Mas agora podemos afirmar matematicamente qual é a velocidade máxima que o Sonic pode atingir nos games: 80 metros por segundo, ou 288 km/h. E isso no jogo no qual ele é mais rápido.

Nas primeiras versões ele é bem mais lento. Já explico.

Os caras do Escapist Magazine divulgaram recentemente um vídeo do canal The Game Theorists do Youtube, que contém diversas análises e medidas do personagem e seus ambientes, em vários jogos. E vale à pena trazer isso para nossos leitores do Meio Bit.

Pra começar, eles deixaram claro que o estudo foi feito com base apenas nos games, ignorando os quadrinhos. Bem, eles chegaram à conclusão de que o Sonic mede 1,1 metro de altura.

Então eles mediram o cenário do primeiro ato da fase Green Hill utilizando o próprio ouriço azul como escala, descobrindo assim que ela tem ao todo 259,6 metros de comprimento.

O record de speed run desta fase é de 25 segundos. Isso dá aproximadamente 10 metros por segundo. Peraí: isso dá 36 km/h, se não me falha o meu francês.

Ou seja, ele é muito lento no jogo original. Se ele fosse rápido à ponto de romper a barreira do som, ele terminaria a primeira fase menos de 1 segundo. E o jogo inteiro seria zerado em menos de um minuto.

Para efeito comparativo, vamos analisar seu principal concorrente. Sim, vamos comparar um ouriço que afirma correr na velocidade do som, com um encanador gordinho:

Na primeira fase do Super Mario Bros. do Nintendinho, usando os mesmos métodos para conseguir a escala, temos 98,1 metros de distância entre o ponto de início e o segundo cano verde:

Qualquer gamer consegue fazer o Mario atravessar essa distância em cerca de 5 segundos, em sua velocidade mais lenta, sem contar quando ele pega uma estrela ou outro poder. Isso dá aproximadamente 20 m/s.

É o DOBRO da velocidade do Sonic!

O que faz todo sentido pra mim, afinal em várias partes do jogo o Sonic corre a pé atrás do Dr. Robotnik (ou Dr. Eggman, se você preferir) e não consegue alcançar. Estamos falando de um senhor de meia idade pra lá de obeso. E o Sonic não consegue pegar ele na corrida!

Mas vamos imaginar que o Sonic foi melhorando com o tempo, andou treinando, fez preparação muscular e em Sonic Unleashed conseguimos calcular (usando o mapa da cidade) que o personagem consegue atingir a velocidade de 80 metros por segundo.

Isso equivale a 288 km/h. Muito melhor. Daria pra ir de São Paulo para o Rio de Janeiro em cerca de 1 h 30 min. Nada mal. Ainda assim, muito menos que o necessário para que a gente possa chamar o Sonic de super sônico.

Concluímos portanto que o que nos fez pensar que ele era tão rápido, foi justamente o game e o level design.

E talvez ele até tenha sido projetado para ser mais rápido, mas provavelmente ficaria bem difícil de controlar, certo?

Veja o vídeo da explicação:

Ou à partir deste link.

Fonte: EM.

The post Usando um método matemático para descobrir a real velocidade do Sonic nos videogames appeared first on Meio Bit.

Introdução   O início da carreira de um desenvolvedor de software embarcado é marcado com cicatrizes de guerra. Uma delas é a definição de um microcontrolador...
veja+

The post GNU Cross-toolchain – Processo de build appeared first on Embarcados - Sua fonte de informações sobre Sistemas Embarcados.

Sinta a heroína fluir em suas veias!

Micro infarto instantaneo

Esse cara tem meu respeito! Conseguiu ser mais chato que esses caras que pedem pra entrar em paginas

Eu não sabia sobre o que ia escrever hoje.

Quando isso acontece, normalmente eu pego um café para me ajudar a fazer as ideias fluirem. Mas nos últimos dias em Montreal, ninguém podia beber água devido a uma infiltração bacteriana, o que também significa sem café.

Então, ao invés disso, peguei a próxima melhor coisa para me ajudar: uma cerveja.

Isso me fez pensar sobre café e cerveja e qual poderia me ajudar a ser mais criativo e executar meu trabalho. Quem sabe, esse texto possa ajudar você a decidir quando é melhor tomar aquele expresso triplo ou uma breja bem gelada.

O que realmente é criatividade?

De uma perspectiva científica, criatividade é a sua habilidade de pensar em algo original por conexões feitas entre ideias pre-existentes em seu cérebro.

Essas conexões são controladas por neurotransmissores como adenosina, que alertam seu cérebro quando você está ficando sem energia e reage freando as conexões feitas entre neurônios através da ligação com os receptores de adenosina.

A adenosina é meio que o monitor de status da bateria do seu cérebro. Uma vez que os seus níveis de energia ficam baixos, a adenosina alerta o seu cérebro e começa a diminuir o funcionamento dele.

Esse é o porque depois de algumas horas de trabalho intenso, você começa a se sentir cansado, como se o seu cérebro tivesse sem combustível.

A única forma de recarregar é dar uma pausa. A menos que você tenha uma arma secreta em mãos.

Seu cérebro sob efeito de café

Todo apreciador está familiarizado com o sentimento posterior a uma boa caneca de café.

Eu sei que depois de tomar um latte ou expresso me sinto mais focado.

Se eu estou conversando com alguém, as palavras parecem fluir sem pausas, hms, ou ahs.

Se eu estou escrevendo, meus dedos nunca param de digitar.

Isso acontece por que a cafeína bloqueia os receptores de adenosina, impedindo-a de conectar-se a seus receptores e enganando seu cérebro, fazendo-o pensar que você tem montes de energia.

Aqui uma ilustração do que a cafeína faz com o seu cérebro:

– Esquece esse cara, ele é um quadrado; – Eu nunca gostei desse cara mesmo.; –Estou tão só. | Fonte: The Oatmeal

Esse efeito acontece apenas 5 minutos depois de beber o seu café.

Quando os receptores de adenosina estão bloqueados, componentes químicos que aumentam a performance da sua atividade neural, como glicose, dopamina e glutamato conseguem trabalhar além do tempo.

Então, enquanto você acha que o café está dando mais energia, na verdade, ele está dizendo ao seu corpo que a sua reserva é suficiente, mesmo depois de ela já ter se esgotado.

O café é como um foguete

O pico de cafeína no seu corpo acontece entre 15 minutos e duas horas depois de você consumi-la.

Quando a cafeína do seu café entra na sua corrente sanguínea, você fica mais alerta por causa do aumento na produção dos hormônios adrenalina e cortisol.

O problema é que se essa superestimulação de adrenalina e cortisol ocorre muito regularmente, suas glândulas adrenais, que absorvem a adrenalina para ajudar você a se sentir energizado, gradualmente começam a requerer mais adrenalina para dar a mesma sensação de “agora vai” de antes.

Quando pesquisadores da Johns Hopkins University observaram consumidores leves a moderados de café (doses pequenas como uma caneca de 14 onças ou aproximadamente 400ml por dia), descobriram que mesmo essa pequena quantidade de café pode tornar seu corpo tolerante a cafeína e fazer com que ele precise de mais para ter a mesma estimulação.

Assim como a emoção de acender um foguete e vê-lo explodir em alguns segundos, as sensações positivas associadas ao café têm vida curta e logo você precisa de mais um pouco para se sentir bem de novo.

Por que há tantos artistas famosos bêbados e nenhum contador bêbado famoso?

Enquanto a cafeína ajuda você a sentir como se tivesse mais energia, o álcool tem seu próprio jeito de influenciar sua criatividade.

Depois que você bebeu algumas cervejas, continuar torna você menos focado por que diminui a sua memória de trabalho e você começa a se importar menos com o que está acontecendo ao seu redor. Mas como os pesquisadores na University of Illinois em Chicago descobriram, isso pode ser uma coisa boa para fins de criatividade.

Os pesquisadores desenvolveram um jogo onde 40 homens recebiam três palavras e eram instruídos a pensarem em uma quarta que pudesse fazer uma combinação de duas palavras com todas as três.

Por exemplo, a palavra “pit” funciona com “arm”, “peach”, e “tar”.*

Metade dos homens beberam dois litros de cerveja antes de jogarem, enquanto a outra metade não bebeu nada. Os resultados mostraram que homens que beberam resolveram 40% mais dos problemas que os sóbrios.

Foi concluído que um nível de álcool no sangue de 0.07 (mais ou menos dois drinques) fez dos participantes melhores em resolver problemas criativos, mas não necessariamente o mesmo aconteceu quando eles tiveram de executar tarefas que exigiam da memória de trabalho e atenção ao seu entorno (como dirigir).

Ao reduzir sua habilidade de prestar atenção ao mundo ao seu redor, o álcool liberta seu cérebro, fazendo-o pensar mais criativamente.

Parece que o escritor Ernest Hemingway tinha razão quando disse:

“Quando você trabalha duro o dia todo com a sua cabeça e sabe que você vai ter de trabalhar de novo no próximo dia, o que mais pode mudar suas ideias e fazê-las correrem em um plano diferente como o whisky?”

O álcool produz ideias melhores

Em um estudo interessante sobre o tópico do álcool e seus efeitos na criatividade, o autor Dave Birss reuniu um grupo de 18 diretores criativos de publicidade e os dividiu em dois times.

Um time podia beber quanto álcool quisesse enquanto o outro tinha de permanecer sóbrio.

Os grupos recebiam um briefing e tinha de ter quantas ideias pudessem em três horas. Essas ideias então eram avaliadas por um grupo dos melhores diretores criativos.

O resultado? O time que bebeu não apenas produziu mais ideias como também teve quatro das cinco melhores ideias.

O álcool pode não ser a melhor escolha quando você precisa estar alerta e focado no que acontece ao seu redor, mas parece que alguns drinques podem ser úteis quando você precisa ter novas ideias.

Uma prescrição criativa: a melhor forma de beber café e cerveja

Tanto o café como a cerveja (moderadamente) têm se mostrado úteis quando você está trabalhando em certos tipos de tarefas. Entretanto, você não deve tomar nenhuma delas quando precisa executar tarefas analíticas ou detalhadas como suas finanças.

O aumento na adrenalina da cafeína e a inibição da sua memória de trabalho do álcool vão torná-lo mais suscetível a erros.

Cerveja para ideias

A melhor hora para tomar uma cerveja (ou duas) seria quando você está procurando pela ideia inicial. Uma vez que o álcool diminui sua memória de trabalho (fazendo você se sentir mais relaxado e menos preocupado sobre o que está acontecendo ao seu redor), você vai ter mais poder dedicado a fazer conexões mais profundas.

Neurocientistas vêm estudando o “momento eureka” e descobriram que para produzir momentos de insight, você precisa se sentir relaxado, para que o pensamento processado na parte frontal do cérebro (conexões óbvias) possam se mover para a parte de trás (onde conexões laterais, únicas, são feitas) e ativar o giro temporal superior, um ponto pequeno sobre a sua orelha direita responsável por esses momentos.

Pesquisadores descobriram que cerca de cinco segundos antes de você ter um “momento eureka”, há um elevado aumento nas ondas alfa que ativam o giro temporal superior.

Essas ondas alfa são associadas ao relaxamento, o que explica por que você geralmente tem ideias quando está andando, tomando banho ou no banheiro.

O álcool relaxa você, então produz um efeito similar às ondas alfa e ajudando-nos a alcançar insights criativos.

Café para a execução

O café, entretanto, não necessariamente ajuda você a acessar mais partes criativas do seu cérebro, como um pouco de cerveja.

Se você já tinha uma ideia de onde você queria chegar com seu projeto, uma xícara de café vai fazer maravilhas comparada à cerveja para colocar sua ideia em prática.

O consenso geral pelos estudos da cafeína é que ela pode aumentar a qualidade e performance se a tarefa que você vai executar parece fácil e não exige muito pensamento abstrato.

Em outras palavras, depois de ter uma ideia inicial ou planejar algo, uma xícara de café pode ajudá-lo a executar e seguir seu conceito mais rápido sem comprometer a qualidade.

Essa imagem resume bem quando você deve beber café:

Dica rápida: se você bebe café, faça-o antes do meio-dia, para que isso não afete seu sono. Em média, vai demorar de 5 a 10 hroas para a cafeína sair do seu sistema. Bagunçar seu ciclo de sono pode ter um impacto negativo na sua produção criativa por dias.

Sempre beba com moderação

Se você decidir beber café ou cerveja enquanto trabalha, não ultrapasse mais do que dois drinques por vez e tente não fazer isso mais do que uma ou duas vezes por semana, para prevenir dependência.

Café e cerveja não devem ser pensados como poções mágicas da criatividade.

Há formas de criar mudanças químicas que ocorrem naturalmente no seu corpo com um estilo de vida saudável. Sono de qualidade, uma dieta saudável e dar a si próprio pausas, dividindo seu dia, vão gerar o mesmo resultado.

Mas, se você tiver de escolher entre café ou cerveja, pense em qual tipo de tarefa você está prestes a executar e garanta que não vai beber demais.

O excesso de qualquer um dos dois vai fazer você perder seus benefícios.

* * *

Nota do editor: esse texto foi originalmente publicado no Medium do autor e traduzido por nós mediante autorização. As palavras originais não foram traduzidas para preservar a aglutinação.

Introdução   Um conceito muito importante quando se inicia na programação de device drivers para Linux é saber a diferença entre drivers de plataforma e drivers...
veja+

The post Linux Device Drivers – Diferenças entre Drivers de Plataforma e de Dispositivo appeared first on Embarcados - Sua fonte de informações sobre Sistemas Embarcados.

O pessoal do canal Põe Na Roda, que aborda assuntos do universo Gay, me convidou para um quadro interessante. Se chama “Héteros perguntam e Gays Respondem” e eu fiquei do lado dos héteros, ó que curioso!

Para ver mais conteúdo do Põe Na Roda, clique aqui.

Com aplicativos como o Tinder cada dia mais populares, faz sentido ver os desenvolvedores buscando soluções semelhantes para entregar um pouco mais para os seus usuários, como é o caso do LinkedUp!, que promete promover encontros entre profissionais com perfil no LinkedIn.

Com base nas informações publicadas no LinkedIn você pode escolher a pessoa que mais combina com você baseado nas informações profissionais. Será que a moda pega? Vamos esperar para ver!

Via DesignTaxi.

Assista em tela cheia, com fone e tente não se arrepiar.


Link YouTube

* * *

Essa manhã fria de feriado tem cheiro de domingo. Domingo daqueles nos quais sentava ao lado de meu velho no sofá, aguardando ansioso pelos ruídos de bestas motorizadas. Na época não me dava conta, mas estava assistindo a história ser feita diante de meus olhos.

Mais que ver pontos sendo ganhos, me sentia um molecote na garupa de alguém que guiava pela vitória:

Link YouTube | Sir Jackie Stewart, tricampeão da F1, leva uma cortada ao entrevistar Senna

F1 nunca foi esporte pra torcer por equipes, ao menos pra mim. Torcia pros pilotos, torcia pro Senna. Suas corridas tinham dois narradores: um patriota e histérico Galvão Bueno de quem eu gostava muito pela empolgação; e meu pai. Um e outro ponderavam pontos das disputas, me fazendo sentir em meio a uma perigosíssima e arriscada aventura no asfalto.

No cockpit, Ayrton corria pelo impossível.

Em 1984, guiando uma lenta Toleman em sua temporada de estréia, arrancou um absurdo segundo lugar em Mônaco, em corrida encerrada mais cedo por conta da chuva – e, alguns dizem, para favorecer Prost.

Na Lotus, no ano seguinte, ele teve sua primeira vitória na segunda corrida, em Portugal, deixando todos os demais pra trás em uma volta(!).

Em 1987, ainda na Lotus, ele venceu em Mônaco com mais de 30s de diferença para o segundo colocado.

Em 1988, superou Prost nas qualificatórias de Mônaco por incríveis 1.427s, na experiência transcendental do vídeo que abre esse artigo.

Na temporada de 1988, Senna e Prost guiavam a lendária McLaren MP4/4, o monoposto mais dominante da F1 – vencedor de 15 das 16 provas da temporada, liderando 93% de todas as voltas.

Debaixo de temporal, em 1993, deu aula a Prost e Schumacher numa das voltas mais espetaculares de minha memória.

“O Direito pela Vitória” é, inequivocamente, o título de um dos documentários a seu respeito. Assistir Ayrton era se permitir ser criança. Criança não tem filtros, quer algo e quer, tal qual era o ímpeto de Senna. E por isso chuto tantos homens feitos terem se apaixonado pelas manhãs de domingo.

Acima de todas, sua vitória de 1991 em Interlagos foi a que mais me marcou. A prova tranquila se transformou em drama, quando, a 20 voltas do fim, perdeu a quarta marcha. Depois, nenhuma marcha funcionava sem que tivesse que segurar a alavanca de marchas para que ela permanecesse engatada. Ele precisou segurar a alavanca de câmbio com a mão direita e pilotar com a esquerda.

Ao final, tinha somente a sexta marcha funcionando. A duas voltas do fim, chuva! Cruzou a linha de chegada aos berros e precisou de ajuda para sair do carro, tamanha era a dor que sentia. No pódio, mal conseguia levantar o troféu de sua primeira vitória no Brasil pilotando um F1.

Link YouTube | Assistir os dois primeiros minutos sem chorar, eu não dei conta

Humano, ponderado e sacana

Gosto muito mais do Senna por ser um herói possível do que pelo mito. Tinha medo de morrer e de se machucar, como qualquer um. Foi um tremendo escroto sim, não se enganem: guiou como um maluco, provocou acidentes, levou soco dos adversários, explorou brechas de contrato pra fazer o que achava melhor, retribuiu sacanagens e quebrou acordos.

No Roda Viva em 1986, aos 26 anos, ele falou que o mais importante a um campeão era “calma e tranquilidade. e uma boa assessoria. (…) saber dar uma reduzida quando necessário e entender que tudo tem seu tempo”. Aham, campeão e frear na mesma frase. Por mais que se pinte, ele nunca foi um gênio solitário. Era também falho, calculista e estratégico, ciente de sua imagem pública e da importância de grandes equipes. Narrativas de egos indomáveis alimentam manchetes, mas não vencem campeonatos.

Abaixar a cabeça, aprender e escutar foi dos principais talentos de Ayrton.

A definidora rivalidade com Alain Prost não era, afinal, marcada por ódio. Pouco antes de sua morte, dirigindo em Imola numa transmissão narrada pelo já aposentado Prost, ele disse, “Ao meu amigo Alain, nós sentimos sua falta”. O Senna de minha lembrança não é o campeão supremo. É o homem que buscava ir além de si mesmo, como todos nós. Pra ele, calhava de encontrar isso guiando a 300km/h em busca do pódio.

Senna, seu filho da puta, há 20 anos sentimos saudades.

Essa é nossa homenagem, ilustrada por Felipe Franco, com fala da entrevista “Racing is in my blood”, de 1991.

E pra você, qual seu momento inesquecível com Senna?