Desmistificando a BIG DATA

Quando iniciei na faculdade, nos final dos anos 90, os mais abastados tinham um computador pessoal em casa, acesso discado a internet e um "tijolão" pendurado na cintura.

Naquela altura, o DOS estava dando lugar ao Windows, os arquivos textos que registravam as informações geradas pelos sistemas de informação, já haviam sido substituídos por banco de dados relacionais. Ao invés de ler ou escrever diretamente em arquivos texto, os sistemas de informação passaram essa responsabilidade para os SGBD's e o acesso aos dados passou a ser feito através de SQL.

Os sistemas de informação já possuíam uma arquitetura cliente servidor (sistema instalado na máquina do usuário e banco de dados instalado em um servidor de banco de dados).

Nessa época, um banco de dados com cinco, dez, cinquenta tabelas, atendiam bem as demandas.

 

O volume de informações crescia exponencialmente. Logo verificou-se que o modelo relacional não servia para um volume grande de informações. As consultas já estavam comprometendo o desempenho dos bancos. Como solução, surgiu a modelagem dimensional e com ela, os conceitos de BI, DATA WAREHOUSE, bases OLAP.

Com a popularização da Internet, os navegadores Web se tornaram os aplicativos mais usados nos computares pessoais. Logo este tipo de aplicação se tornou uma plataforma para o uso dos sistemas de informação.

Os tijolões deram lugar a celulares menores e logo em seguida, aos smartphones. Surgem os aplicativos mobile. 

Lembro de um professor de JAVA entusiasta que falava que nossos eletrodomésticos no futuro, teriam embutidos, sistemas informatizados com funcionalidades, aonde seria possível registrar listas de compras, receitas, bloco de recados, etc.

Como estava iniciando os meus estudos na área de tecnologia de informação, confesso que achava aquilo tudo uma bobagem e ficava me perguntando se aquilo de fato ia acontecer. 

E quanto aos eletrodomésticos informatizados? Aconteceu! Com a popularização da Internet, praticamente TUDO passou a estar conectado a ela. Estamos falando que as coisas passaram a se conectar a Internet, o que ficou conhecido como  INTERNET DAS COISAS. E essas coisas passaram a gerar dados.

Confesso a vocês que não tenho noção do volume de dados que é produzido a cada segundo por esses dispositivos, mas podemos imaginar que é algo astronômico. Pesquisando na Internet sobre o assunto, fala-se em zetabytes de dados.

Sem ir muito longe, pense na quantidade de posts que nós fazemos no Facebook ou ainda na quantidade de pesquisas que realizamos na Internet e multiplique isso pelo número de usuários desses serviços no mundo todo. Imagine ainda, a quantidade de vídeos produzidos e publicados no Youtube a cada minuto.

Levando-se em conta a topologia, a natureza híbrida dos dispositivos conectados a Internet, o grande volume e a alta velocidade com o qual esses dados são produzidos, surgem algumas questões: Aonde armazenar esses dados? Levando-se em conta que os dados produzidos por esses dispositivos nem sempre são estruturados, como processa-los e armazena-los?  E Por fim, como produzir informação com base nesses dados, de modo a gerar insights interessantes? É grande o desafio, não é mesmo? 

BIG DATA foi o termo criado para descrever esse cenário com imenso volume de dados - estruturados ou não - que são gerados a cada segundo e que impactam os negócios no dia a dia.

Num cenário como este, algumas premissas devem ser alcançadas. As tecnologias envolvidas devem ser capazes de suportar grande VOLUME de dados, capazes de armazenar uma grande VARIEDADE de dados (estruturados, semiestruturados e não estruturados) e possuir VELOCIDADE na ingestão, processamento e retorno das informações.

A cada dia, novas tecnologias surgem para solucionar problemas relacionados ao cenário descrito aqui, mas sobre essas, eu falarei em outros Posts, OK?

Espero ter mais esclarecido do que confundido.

Valeu!

Booleanos em C #

Muitas vezes, na programação, você precisará de um tipo de dados que possa ter apenas um dos dois valores, como:

SIM NÃO
LIGADO DESLIGADO
VERDADEIRO FALSO

Para isso, o C # possui um tipo de dados bool, que pode levar os valores verdadeiro ou falso.

Valores booleanos
Um tipo booleano é declarado com a palavra-chave bool e só pode levar os valores true ou false:

Exemplo
bool isCSharpFun = true;
bool isFishTasty = false;
Console.WriteLine (isCSharpFun); // Saída True
Console.WriteLine (isFishTasty); // Saídas falsas

No entanto, é mais comum retornar valores booleanos de expressões booleanas, para testes condicionais (veja abaixo).

Expressão booleana
Uma expressão booleana é uma expressão em C # que retorna um valor booleano: True ou False.

Você pode usar um operador de comparação, como o operador maior que (>), para descobrir se uma expressão (ou variável) é verdadeira:

Exemplo
int x = 10;
int y = 9;
Console.WriteLine (x> y); // retorna True, porque 10 é maior que 9

Ou ainda mais fácil:

Exemplo
Console.WriteLine (10> 9); // retorna True, porque 10 é maior que 9

Nos exemplos abaixo, usamos o operador igual a (==) para avaliar uma expressão:

Exemplo
int x = 10;
Console.WriteLine (x == 10); // retorna True, porque o valor de x é igual a 10

Exemplo
Console.WriteLine (10 == 15); // retorna False, porque 10 não é igual a 15

O valor booleano de uma expressão é a base para todas as comparações e condições de C #.

C # Strings

As strings são usadas para armazenar texto.

Uma variável de cadeia contém uma coleção de caracteres entre aspas duplas:

Exemplo
Crie uma variável do tipo string e atribua um valor a ela:

string cumprimento = "Olá";

Comprimento da string

Uma string em C # é na verdade um objeto, que contém propriedades e métodos que podem executar determinadas operações nas strings. Por exemplo, o comprimento de uma sequência pode ser encontrado com a propriedade Length:

Exemplo
string txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
Console.WriteLine ("O comprimento da cadeia de caracteres txt é:" + txt.Length);

Outros métodos
Existem muitos métodos de sequência disponíveis, por exemplo, ToUpper () e ToLower (), que retornam uma cópia da sequência convertida em maiúsculas ou minúsculas:

Exemplo
string txt = "Olá, mundo";
Console.WriteLine (txt.ToUpper ()); // Saídas "HELLO WORLD"
Console.WriteLine (txt.ToLower ()); // Saídas "olá mundo"

Concatenação de String
O operador + pode ser usado entre cadeias para combiná-las. Isso é chamado de concatenação:

Exemplo
string firstName = "John";
string lastName = "Doe";
nome da string = nome + sobrenome;
Console.WriteLine (nome);

Observe que adicionamos um espaço após "John" para criar um espaço entre firstName e lastName na impressão.

Você também pode usar o método string.Concat () para concatenar duas seqüências:

Exemplo
string firstName = "John";
string lastName = "Doe";
nome da string = string.Concat (nome, sobrenome);
Console.WriteLine (nome);


Interpolação de String
Outra opção da concatenação de strings é a interpolação de strings, que substitui valores de variáveis ​​em espaços reservados em uma string. Observe que você não precisa se preocupar com espaços, como na concatenação:

Exemplo
string firstName = "John";
string lastName = "Doe";
string name = $ "Meu nome completo é: {firstName} {lastName}";
Console.WriteLine (nome);

C # Math

A classe C # Math possui muitos métodos que permitem executar tarefas matemáticas em números.

Math.Max ​​(x, y)
O método Math.Max ​​(x, y) pode ser usado para encontrar o valor mais alto de x e y:

Exemplo
Math.Max ​​(5, 10);

Math.Min (x, y)
O método Math.Min (x, y) pode ser usado para encontrar o valor mais baixo de x e y:

Exemplo
Math.Min (5, 10);

Math.Sqrt (x)
O método Math.Sqrt (x) retorna a raiz quadrada de x:

Exemplo
Math.Sqrt (64);

Math.Abs ​​(x)
O método Math.Abs ​​(x) retorna o valor absoluto (positivo) de x:

Exemplo
Math.Abs ​​(-4,7);

Math.Round ()
Math.Round () arredonda um número para o número inteiro mais próximo:

Exemplo
Math.Round (9,99);

Operadores C #

Operadores são usados ​​para executar operações em variáveis ​​e valores.

No exemplo abaixo, usamos o operador + para adicionar dois valores:

Exemplo

int x = 100 + 50;

Embora o operador + seja frequentemente usado para adicionar dois valores, como no exemplo acima, ele também pode ser usado para adicionar uma variável e um valor, ou uma variável e outra variável:

Exemplo

int sum1 = 100 + 50; // 150 (100 + 50)

int soma2 = soma1 + 250; // 400 (150 + 250)

int soma3 = soma2 + soma2; // 800 (400 + 400)

Operadores aritméticos

Operadores aritméticos são usados ​​para executar operações matemáticas comuns:

+ Adição Adiciona dois valores x + y

- Subtração Subtrai um valor de outro x - y

* Multiplicação Multiplica dois valores x * y

/ Division Divide um valor de outro x / y

% Módulo Retorna o restante da divisão x% y

Incremento ++ Aumenta o valor de uma variável em 1 x ++

- Decremento Diminui o valor de uma variável em 1 x--

Operadores de atribuição C #

Operadores de atribuição são usados ​​para atribuir valores a variáveis.

No exemplo abaixo, usamos o operador de atribuição (=) para atribuir o valor 10 a uma variável chamada x:

Exemplo

int x = 10;

O operador de atribuição de adição (+ =) adiciona um valor a uma variável:

Exemplo

int x = 10;

x + = 5;

Uma lista de todos os operadores de atribuição:

= x = 5 x = 5

+ = x + = 3 x = x + 3

- = x - = 3 x = x - 3

* = x * = 3 x = x * 3

/ = x / = 3 x = x / 3

% = x% = 3 x = x% 3

x = x & 3 = x & 3

| = x | = 3 x = x | 3

^ = x ^ = 3 x = x ^ 3

>> = x >> = 3 x = x >> 3

<< = x << = 3 x = x << 3

Operadores de comparação de c #

Operadores de comparação são usados ​​para comparar dois valores:

Exemplo do nome do operador Experimente

== Igual a x == y

! = Diferente x! = Y

> Maior que x> y

> = Maior ou igual a x> = y

<= Menor ou igual a x <= y

Operadores lógicos em C #

Operadores lógicos são usados ​​para determinar a lógica entre variáveis ​​ou valores:

&& Logical and Returns true se ambas as afirmações forem verdadeiras x <5 amp="" div="" x="">

|| Lógico ou Retorna verdadeiro se uma das instruções for verdadeira x <5 div="" x="">

! Lógico não Inverte o resultado, retorna falso se o resultado for verdadeiro! (X <5 amp="" div="" x="">

Conversão de tipos (Type Casting)

A conversão de tipo ocorre quando você atribui um valor de um tipo de dados a outro tipo.

No C #, existem dois tipos de conversão:

• Transmissão implícita (automaticamente) - convertendo um tipo menor para um tamanho maior char -> int -> long -> float -> duplo
• Transmissão explícita (manualmente) - convertendo um tipo maior para um tipo de tamanho menor double -> float -> long -> int -> char

Conversão implícita

A conversão implícita é feita automaticamente ao passar um tipo de tamanho menor para um tipo de tamanho maior:

Exemplo
int myInt = 9;
double myDouble = myInt; // Conversão automática: int para dobrar

Console.WriteLine (myInt); // Saídas 9
Console.WriteLine (myDouble); // Saídas 9

Conversão explícita

A conversão explícita deve ser feita manualmente, colocando o tipo entre parênteses à frente do valor:

Exemplo
double myDouble = 9,78;
int myInt = (int) myDouble; // Transmissão manual: double to int

Console.WriteLine (myDouble); // Saídas 9.78
Console.WriteLine (myInt); // Saídas 9

Métodos de conversão de tipo

Também é possível converter tipos de dados explicitamente usando métodos internos, como Convert.ToBoolean, Convert.ToDouble, Convert.ToString, Convert.ToInt32 (int) e Convert.ToInt64 (long):

Exemplo
int myInt = 10;
double myDouble = 5,25;
bool myBool = true;

Console.WriteLine (Convert.ToString (myInt)); // converte int para string
Console.WriteLine (Convert.ToDouble (myInt)); // converte int para o dobro
Console.WriteLine (Convert.ToInt32 (myDouble)); // converte double para int
Console.WriteLine (Convert.ToString (myBool)); // converte bool para string

Por que conversão?
Muitas vezes, não há necessidade de conversão de tipo. Mas às vezes você precisa ao trabalhar com a entradas do usuário, para ver um exemplo disso.

Tipos de dados C #

Conforme explicado no post sobre variáveis, uma variável em C # deve ter um tipo de dados especificado:

Exemplo:
int myNum = 5; // Inteiro (número inteiro)
double myDoubleNum = 5.99D; // Número do ponto flutuante
char myLetter = 'D'; // Personagem
bool myBool = true; // Boleano
string myText = "Olá"; // Corda

Um tipo de dados especifica o tamanho e o tipo de valores variáveis. É importante usar o tipo de dados correto para a variável correspondente; para evitar erros, economizar tempo e memória, mas também tornará seu código mais sustentável e legível. Os tipos de dados mais comuns são:

Tipo de dados

• int 4 bytes Armazena números inteiros de -2.147.483.648 a 2.147.483.647
• 8 bytes longos Armazena números inteiros de -9.223.372.036.854.775.808 a 9.223.372.036.854.775,807
• float 4 bytes Armazena números fracionários. Suficiente para armazenar 6 a 7 dígitos decimais
• double 8 bytes Armazena números fracionários. Suficiente para armazenar 15 dígitos decimais
• bool 1 bit Armazena valores verdadeiros ou falsos
• char 2 bytes Armazena um único caractere / letra, entre aspas simples
• string 2 bytes por caractere Armazena uma sequência de caracteres, entre aspas duplas

Números

Os tipos de número são divididos em dois grupos:

• Tipos inteiros armazenam números inteiros, positivos ou negativos (como 123 ou -456), sem decimais. Tipos válidos são int e long. O tipo que você deve usar depende do valor numérico.
• Os tipos de ponto flutuante representam números com uma parte fracionária, contendo uma ou mais casas decimais. Tipos válidos são float e double.

Embora existam muitos tipos numéricos em C #, os mais usados ​​para números são int (para números inteiros) e duplos (para números de ponto flutuante). No entanto, descreveremos todos eles enquanto você continua a ler.

Tipos de número inteiro
Int
O tipo de dados int pode armazenar números inteiros de -2147483648 a 2147483647. Em geral, e em nosso tutorial, o tipo de dados int é o tipo de dados preferido quando criamos variáveis ​​com um valor numérico.

Exemplo
int myNum = 100000;
Console.WriteLine (myNum);

Grandes
O tipo de dados longo pode armazenar números inteiros de -9223372036854775808 a 9223372036854775807. Isso é usado quando int não é grande o suficiente para armazenar o valor. Observe que você deve finalizar o valor com um "L":

Exemplo
myNum longo = 15000000000L;
Console.WriteLine (myNum);

Tipos de ponto flutuante
Você deve usar um tipo de ponto flutuante sempre que precisar de um número decimal, como 9.99 ou 3.14515.

Flutuador
O tipo de dados flutuante pode armazenar números fracionários de 3.4e-038 a 3.4e + 038. Observe que você deve finalizar o valor com um "F":

Exemplo
float myNum = 5,75F;
Console.WriteLine (myNum);

Números científicos
Um número de ponto flutuante também pode ser um número científico com um "e" para indicar a potência de 10:

Exemplo
flutuador f1 = 35e3F;
d1 duplo = 12E4D;
Console.WriteLine (f1);
Console.WriteLine (d1);


Booleanos
Um tipo de dados booleano é declarado com a palavra-chave bool e só pode levar os valores true ou false:

Exemplo
bool isCSharpFun = true;
bool isFishTasty = false;
Console.WriteLine (isCSharpFun); // Saída True
Console.WriteLine (isFishTasty); // Saídas falsas

Os valores booleanos são usados ​​principalmente para testes condicionais, sobre os quais você aprenderá mais em um capítulo posterior.

Char
O tipo de dados char é usado para armazenar um único caractere. O caractere deve estar entre aspas simples, como 'A' ou 'c':

Exemplo
char myGrade = 'B';
Console.WriteLine (myGrade);

strings
O tipo de dados da sequência é usado para armazenar uma sequência de caracteres (texto). Os valores da string devem estar entre aspas duplas:

Exemplo
string greeting = "Olá, mundo";
Console.WriteLine (saudação);