Princípios da aviação

Após um longo período de inatividade, vou recomeçar a escrever no Code Wars,  dessa vez sobre assuntos um pouco mais diferentes, que puxam mais para engenharia. Leiam o artigo, me digam se gostaram e me digam que conteúdos gostariam de ver no site, por favor!

Concorde

PRINCÍPIOS DA AVIAÇÃO

A Sustentação

A sustentação é, resumidamente, o que faz o avião levantar vôo e permanecer no ar. A sustentação é formada por uma diferença de pressão entre a parte inferior e a parte superior das asas, mas não entre em pânico! O conceito é bem simples. O fluxo de ar que passa pelas asas é “cortado em dois” ao atravessá-las. Uma parte do fluxo de ar passa por baixo das asas e força a parte inferior das asas para cima, criando uma grande pressão nessa parte, que tende a levantar a asa. Quanto mais reta e uniforme for a parte inferior das asas de um avião, mais pressão será gerada pelo ar que por ali passa, aumentando a sustentação.

Mas só a pressão gerada pelo fluxo de ar inferior não é o suficiente para fazer o avião voar. O fluxo de ar que passa pela parte superior da asa não pode exercer muita pressão sobre a asa, porque, ao contrário do fluxo de ar inferior, a pressão gerada pelo ar que passa por cima da asa não empurra o avião para cima, e sim para baixo. Isso foi resolvido pelo acréscimo de uma curva na asa. Essa curva funciona porque as duas correntes de ar sempre voltam a se unir após passarem pela asa. Assim, a corrente inferior precisa percorrer uma distância menor que a corrente superior e, consequentemente, tem uma velocidade menor, o que lhe permite exercer mais pressão, enquanto a corrente superior tem uma velocidade maior e exerce uma pressão menor. O princípio de que uma corrente de ar a velocidades maiores exerce menos pressão do que uma corrente de ar a uma velocidade menor se chama Princípio de Bernoulli.  A explicação pode ser meio complicada para pessoas que não tem conhecimento avançado em física, mas é basicamente isso: Quando o ar  começa a se mover, os átomos presentes no ar tem uma determinada velocidade. Quando o ar se move lentamente, parte dessa velocidade é utilizada para “acompanhar o grupo de átomos”, por assim dizer, e o resto é desperdiçado em movimentos desordenados que acabam em colisões com outros átomos, o que cria pressão na superfície em que o ar se move. Mas quando o ar está a uma alta velocidade, a maior parte da velocidade de cada átomo é utilizada para “acompanhar o grupo”, diminuindo as colisões e a pressão gerada. Poderíamos dizer que em um movimento de alta velocidade os átomos não tem tempo para colidirem uns com os outros. Se você quiser saber mais, recomendo essa página: http://home.earthlink.net/~mmc1919/venturi.html

A PERDA DE SUSTENTAÇÃO E OS FLAPS

Os aviões precisam adquirir uma velocidade muito alta para que a sustentação seja a suficiente para fazê-lo levantar voo. Por isso é que os aviões sempre precisam percorrer uma longa distância antes de decolar. Você já notou que toda vez que um avião decola ou aterrissa uma estrutura da asa se abaixa? Esses são os flaps. A função dos flaps é aumentar ou diminuir a sustentação, precisando ser utilizados na decolagem, aterrissagem e em manobras para desviar o avião. Seu papel na decolagem e aterrissagem é simples. Os flaps abaixam, aumentando a sustentação, o que permite que o avião mantenha a sustentação a velocidades mais baixas, podendo decolar e aterrissar a uma velocidade menor do que a que seria necessária sem os flaps. Quando o avião é desviado para uma certa trajetória, o flap da asa que está na direção à qual se pretende desviar levanta, diminuindo a sustentação dessa asa, enquanto o flap da asa na direção oposta abaixa, aumentando a sustentação. Durante essa operação, o avião fica inclinado e tende a se desviar para o lado da asa em que o flap está levantado.

Giro para esquerda(esquerda do avião!!!!)

O EMPUXO

A sustentação só tem um efeito considerável no avião a uma determinada velocidade. Por isso é que todos os aviões(exceto alguns modernos aviões militares que tem sistema de decolagem e aterrissagem vertical) precisam percorrer longas distâncias e atingir certa velocidade para levantar voo. Nos aviões que utilizam hélices ou turbinas, essa velocidade é adquirida pela ação de uma força chamada empuxo. O empuxo pode ser entendido desse jeito: Ao girarem, as turbinas “puxam” o ar para trás. Segundo Isaac Newton, “toda ação produz uma reação no sentido contrário”. Portanto, a ação de “puxar” o ar para trás produz uma reação no sentido contrário, sendo o resultado disso o empuxo, que empurra o avião para frente. A ação de “puxar” o ar para trás é chamada de Arrasto, sendo esta uma força oposta ao empuxo.

A FORMA AERODINÂMICA

Por último, e talvez o conceito mais fácil de se entender, é o design aerodinâmico do avião. Não é por acaso que todos os aviões comerciais, jatos privados e a maioria dos aviões militares possuem um formato parecido, com o tronco do avião arredondado, parecendo uma espécie de pílula. Essa forma é crucial para a aerodinâmica do avião, já que é responsável por desviar o ar do corpo do avião gerando a menor resistência e atrito possíveis. A velocidade máxima de um avião também está intimamente ligada com sua forma aerodinâmica. Se o design aerodinâmico é ruim, a resistência do ar será maior, e essa resistência é multiplicada por 4 toda vez que a velocidade dobra, retardando o avião. Isso significa que se o design aerodinâmico não for bom, a potência do motor e das turbinas não importa, porque a resistência do ar sempre irá impor uma barreira para o aumento da velocidade do avião.

Um bom design aerodinâmico

Um bom design aerodinâmico

Code Wars – Blog será atualizado com menos frequência

Bem, eu poderia fazer alguns tutorias básicos sobre Java, C++ ou HTML, mas não faz muito sentido, já que existem ótimos tutoriais sobre isso na Internet.

Categorias:1

Música da Semana

Uma das melhores músicas de uma das melhores bandas de rock. Podemos ver os contrastes entre uma cidade grande e uma pequena nas letras.

Gênero: Hard Rock

Banda: Guns n Roses

Música: Paradise City

Visual C++ – Componentes complexos

Então, quer criar um Media Player, Browser ou algo assim em C++ e não sabe por onde começar? O Visual C++ tem vários componentes para sua aplicação que poderiam ser chamados de complexos escondidos. Se você ainda é novato no Visual C++, pode obter alguma ajuda aqui. Veremos quais são os principais:

WEBBROWSER

Um dos únicos que não está “escondido” e disponível na toolbox de cara. Você pode criar um browser simples com apenas algumas linhas de código. Parece ser o coração do Internet Explorer, porque aqui a fonte do título do meu site apareceu desconfigurada do mesmo jeito nesse browser e no IE. Apesar de algumas incompatibilidades e uma funcionalidade extremamente limitada, esse browser é bem rápido. Se quiser criar seu próprio browser “homemade” siga esse vídeo:

MEDIA PLAYER


Bem, eu so achei tutoriais sobre esse componente em Visual Basic, porém muito pouco muda em C++. Inicie um projeto de Forms no Visual C++. Este componente não está na toolbox por default, então vá em Tools, Choose toolbox items, procure Windows Media Player na aba COM e marque sua checkbox. Arraste para a janela o Media Player e o File Chooser Dialog. Clique duas vezes no Media Player e adicione esse código:

axWindowsMediaPlayer1->URL = openFileDialog1->FileName;

Agora volte ao Design da Form, clique duas vezes no File Chooser e adicione esse código:

openFileDialog1->ShowDialog();

Pronto! Já tem um Media Player funcionando. Se quiser ver o vídeo do Visua Basic aqui está:


Nanotecnologia – Promessas e Complicações

O domínio da nanotecnologia pela humanidade poderia trazer inúmeros benefícios. Desde processadores minúsculos com a capacidade de 100 processadores atuais juntos até inovações na área de tratamento de doenças na Medicina. Porém, essa área da tecnologia é absurdamente complicada. Veremos as principais dificuldades e promessas da nanotecnologia.

COMPLICAÇÕES


NANOMOTORES

Bem, como poderíamos fazer para um robô com muito menos de um milímetro se movimentar? Detalhe: No mundo dos nanorobôs, aqueles princípios da Física que te pareceram malucos valem, como o movimento browniano, então o nanomotor deve ter força o bastante para vencer esse movimento. Pense bem. Se o motor for elétrico, será preciso conseguir uma fonte de eletricidade para ele. Se for um esquema simplificado e em miniatura dos motores de carros precisaria de combustível. E então? A resposta é criar um mecanismo que consegue energia de um a fonte comum e natural. Água! Cientistas já tem uma idéia de como criar o mecanismo, e seu nome é mecanismo catalítico, vamos analisá-lo: O nanorobô se auto-impulsionaria  por água e água-oxigenada empurrando o fluido pela lateral através de reações químicas(não vou entrar em detalhes porque há mais coisas a falar), superando a viscosidade aquosa. Perfeito não é? O nanorobô estaria mergulhado no próprio combustível dentro do corpo humano. Mas isso é só parte do problema. Precisamos também manter o nanorobô controlado e com uma rota uniforme para chegar ao seu objetivo. Está um estudo o uso de nanobússolas para fazer o robô se mover perpendicularmente ao campo magnético, evitando que se mova aleatoriamente ou sofra giros por causa do movimento browniano. Agora só faltam os circuitos para controlá-los. Abaixo um esquema de mecanismo catalítico:

NANOCATÁSTROFES

Imagine o seguinte: Cientistas conseguem criar um nanorobô que consegue se autoreplicar e o testam pela primeira vez para construir um tijolo(hehe). Mas algo dá terrivelmente errado! Os nanorobôs não param de se replicar e rapidamente o país inteiro está preenchido por nanorobôs, e depois ocupariam o planeta inteiro, uma cena parecida com a quase-destruição da Terra em O Dia em que a Terra parou. nanorobôs que se auto-replicam poderiam servir para inúmeras funções. Mas esse tipo de nanorobôs deve ser intensamente estudad0 antes de ser posto em prática. Outro perigo é a facilitação da criação de vírus modificados para destruir a humanidade por terroristas ou qualquer outro mecanismo de destruição em massa facilitado pela nanotecnologia.

Não, isso não é um avião derrubando o prédio e sim, nanorobôs!

Não, isso não é um avião derrubando o prédio e sim, nanorobôs!

PROMESSAS

NANOMEDICINA

Se conseguirmos dominar a nanotecnologia, a medicina sofrerá uma revolução. Poderíamos usar nanorobôs programados especialmente para combater uma determinada doença, portanto, esqueça quimioterapia e etc…, porque os nanorobôs identificarão e destruirão apenas as células cancerosas. Nós também poderemos ser imortais, ou super-humanos. Segundo teses, o envelhecimento é apenas o acúmulo de erros aleatórios no organismo, e os nanorobôs poderão corrigi-las daqui a algum tempo.

AVANÇOS TECNOLÓGICOS

Bem, se dominarmos a nanotecnologia completamente poderemos ter gadgets tecnológicos de qualquer tamanho e computadores absurdamente potentes. Use sua imaginação, pois praticamente qualquer tipo de equipamento tecnológico poderá ser feito.

Música da semana

Para descontrair um pouco, estou lançando uma série de posts semanais com uma música legal. Aí vai a primeira:

Cantada por: Judas Priest

Gênero: Heavy Metal

Digam-me o que acham!

Categorias:Música Tags:, , , , , , , , ,

Java – A grande Tabela das keywords

setembro 24, 2009 1 comentário

Como meu primeiro post sobre Java, resolvi criar uma tabela para consulta rápida que lista as palavras-reservadas dessa linguagem e explica sua finalidade e seu uso. Aqui está ela:

Código Utilidade Exemplo
abstract Usado para declarar classes abstratas que não podem ser instanciadas. abstract class AbstractClass  {

}

assert Usado para checar se alguma variável tem um valor inesperado durante o tratamento de erros. assert IsMinus != false;
boolean Usado para declarar variáveis do tipo boolean. boolean variable = true;
break Usado para encerrar loops antes do término normal do mesmo. for(int i = 0; i < 10; i++) {

if(i = 5) break;

}

byte Usado para declarar variáveis do tipo byte. byte six = 6;
case Usado para declarar condições dentro de uma condição switch. Switch(Id) {

case  45:

System.out.println(“Id 45 não é aceito.”);

catch Usado para capturar exceções dentro de um bloco try { catch(NumberFormatException nfexc) {
char Usado para declarar variáveis do tipo char. Char e = ‘e’;
class Usado para declarar classes. public class Example {
const Usado para declarar uma constante. const int MyConstant = 70;
continue Pula o fim de uma iteração de um laço, indo para o começo da próxima iteração. for(int i = 0; i < 5; i++) {

if(i = 3) continue;

default Usado para definir uma situação default em uma condição switch. switch(defaultSample) {

default: System.out.println(default);

do Usado para iniciar loops do-while. do{

i++;

}while(i < 10);

double Usado para declarar variáveis do tipo double double d = 76.45;
else Usado para começar uma condição else ou else if. if(i ==1) System.out.println(“1 código”);

else if(I == 0) System.out.println(“Nada”);

else System.out.println(i + “códigos”);

enum Usado para declarar uma enumeração. public enum AD { A, B, C, D }
extends Usado para declarar que a classe é derivada de uma classe-base. public class Son extends Father {
false Usado para inicializar ou comparar uma variável lógica com o valor falso. boolean b = false;
final Usado em três casos:

Variável: Garante que seu valor não será mudado.

Classe: Garante que não poderá ter subclasses.

Funções: Não poderam ser sobrecarregadas.

public final class FinalClass {

public final int FinalFunction() {

public final String finalString;

}

}

finally Usado para garantir a execução de um trecho final no tratamento de exceções. try {

}finally { System.out.println(“Finally”); }

float Usado para declarar variáveis do tipo float. float PI = 3.14;
for Usado para iniciar um loop for. for(int i = 0; i < 100; i++) {
if Usado para declarar uma condição if. if(Pi != 3.14) {
implements Usado para implementar funções de uma classe em outra. public class Square implements Shapes {
import Usado para importar classes e pacotes para seu programa. import javax.swing.*;
instanceof Usado para determinar a classe de uma instância if(Xinstance instanceof X) {
int Usado para declarar uma variável do tipo int. int Number = 90;
interface Usado para declarar uma classe abstrata que outras classes deverão implementar. public interface MyInterface {
long Usado para declarar uma variável do tipo long. long Number = 90000;
native Usado para dizer que um método esta implementado em outra linguagem de programação. public static native int NativeMethod();
new Usado para inicializar uma variável na memória do sistema. public String newStr[] = new String[5];
null Usado para declarar ou comparar uma variável como null. String NullStr = null;
package Usado para declarar um pacote, ou seja, um conjunto de classes. package Website;
private Usado para declarar o modo de acesso de uma variável como privado. private double result = 76.45;
protected Usado para declarar o acesso de uma variável/função como protegido. protected int Nine = 9;
public Usado para declarar o acesso de uma variável/função como público. public char t = ‘t’;
return Usado para retornar um valor a partir de uma função. public int returnTen() {

return 10;

short Usado para declarar uma variável do tipo void. void value = 5;
static Usado para garantir que uma variável terá apenas uma referência na memória. static float PI = 3.14;
strictfp Usado para garantir resultados mais precisos nos cálculos com valores de ponto flutuante. public strictfp double calc() {

return 67.3434 * 45.6575;

}

super Usado para chamar o construtor da classe base de uma classe derivada. public class AppSwing extends JFrame {

public AppSwing() { super(“App”); }

switch Usado para iniciar uma condição switch(); switch(counter) {
synchronized Usado para sincronizar o acesso a uma classe/função/variável ou código. synchronized int SyncFunction() {
this Usado como uma referência para a própria classe. double result = this.calc();
throw Usado para lançar exceções. throw new Exception();
throws Usado para declarar que uma função lança certa exceção. public int Function() throws IOException {
transient Usado para garantir que uma variável não será serializada. transient double Pi = 3.14;
true Usado para inicializar ou comparar valores booleanos como verdadeiros. boolean TrueValue = true;
try Usado para iniciar um bloco de tratamento de exceções. try {

} catch(Exception exc) {

void Usado para declarar uma função/variável como void. void MyVoidVar;
volatile Usado para garantir que múltiplas threads poderão acessar o objeto simultaneamente. volatile int Products;
while Usado para iniciar um loop while. while(Products < 40) {

O arquivo(doc) para baixar segue abaixo:

http://www.4shared.com/file/135075457/7ecd790f/palavras_reservadas.html

Código

Utilidade

Exemplo

abstract

Usado para declarar classes abstratas que não podem ser instanciadas.

abstract class AbstractClass  {

}

assert

Usado para checar se alguma variável tem um valor inesperado durante o tratamento de erros.

assert IsMinus != false;

boolean

Usado para declarar variáveis do tipo boolean.

boolean variable = true;

break

Usado para encerrar loops antes do término normal do mesmo.

for(int i = 0; i < 10; i++) {

if(i = 5) break;

}

byte

Usado para declarar variáveis do tipo byte.

byte six = 6;

case

Usado para declarar condições dentro de uma condição switch.

Switch(Id) {

case  45:

System.out.println(“Id 45 não é aceito.”);

catch

Usado para capturar exceções dentro de um bloco try {

catch(NumberFormatException nfexc) {

char

Usado para declarar variáveis do tipo char.

Char e = ‘e’;

class

Usado para declarar classes.

public class Example {

const

Usado para declarar uma constante.

const int MyConstant = 70;

continue

Pula o fim de uma iteração de um laço, indo para o começo da próxima iteração.

for(int i = 0; i < 5; i++) {

if(i = 3) continue;

default

Usado para definir uma situação default em uma condição switch.

switch(defaultSample) {

default: System.out.println(default);

do

Usado para iniciar loops do-while.

do{

i++;

}while(i < 10);

double

Usado para declarar variáveis do tipo double

double d = 76.45;

else

Usado para começar uma condição else ou else if.

if(i ==1) System.out.println(“1 código”);

else if(I == 0) System.out.println(“Nada”);

else System.out.println(i + “códigos”);

enum

Usado para declarar uma enumeração.

public enum AD { A, B, C, D }

extends

Usado para declarar que a classe é derivada de uma classe-base.

public class Son extends Father {

false

Usado para inicializar ou comparar uma variável lógica com o valor falso.

boolean b = false;

final

Usado em três casos:

Variável: Garante que seu valor não será mudado.

Classe: Garante que não poderá ter subclasses.

Funções: Não poderam ser sobrecarregadas.

public final class FinalClass {

public final int FinalFunction() {

public final String finalString;

}

}

finally

Usado para garantir a execução de um trecho final no tratamento de exceções.

try {

}finally { System.out.println(“Finally”); }

float

Usado para declarar variáveis do tipo float.

float PI = 3.14;

for

Usado para iniciar um loop for.

for(int i = 0; i < 100; i++) {

if

Usado para declarar uma condição if.

if(Pi != 3.14) {

implements

Usado para implementar funções de uma classe em outra.

public class Square implements Shapes {

import

Usado para importar classes e pacotes para seu programa.

import javax.swing.*;

instanceof

Usado para determinar a classe de uma instância

if(Xinstance instanceof X) {

int

Usado para declarar uma variável do tipo int.

int Number = 90;

interface

Usado para declarar uma classe abstrata que outras classes deverão implementar.

public interface MyInterface {

long

Usado para declarar uma variável do tipo long.

long Number = 90000;

native

Usado para dizer que um método esta implementado em outra linguagem de programação.

public static native int NativeMethod();

new

Usado para inicializar uma variável na memória do sistema.

public String newStr[] = new String[5];

null

Usado para declarar ou comparar uma variável como null.

String NullStr = null;

package

Usado para declarar um pacote, ou seja, um conjunto de classes.

package Website;

private

Usado para declarar o modo de acesso de uma variável como privado.

private double result = 76.45;

protected

Usado para declarar o acesso de uma variável/função como protegido.

protected int Nine = 9;

public

Usado para declarar o acesso de uma variável/função como público.

public char t = ‘t’;

return

Usado para retornar um valor a partir de uma função.

public int returnTen() {

return 10;

short

Usado para declarar uma variável do tipo void.

void value = 5;

static

Usado para garantir que uma variável terá apenas uma referência na memória.

static float PI = 3.14;

strictfp

Usado para garantir resultados mais precisos nos cálculos com valores de ponto flutuante.

public strictfp double calc() {

return 67.3434 * 45.6575;

}

super

Usado para chamar o construtor da classe base de uma classe derivada.

public class AppSwing extends JFrame {

public AppSwing() { super(“App”); }

switch

Usado para iniciar uma condição switch();

switch(counter) {

synchronized

Usado para sincronizar o acesso a uma classe/função/variável ou código.

synchronized int SyncFunction() {

this

Usado como uma referência para a própria classe.

double result = this.calc();

throw

Usado para lançar exceções.

throw new Exception();

throws

Usado para declarar que uma função lança certa exceção.

public int Function() throws IOException {

transient

Usado para garantir que uma variável não será serializada.

transient double Pi = 3.14;

true

Usado para inicializar ou comparar valores booleanos como verdadeiros.

boolean TrueValue = true;

try

Usado para iniciar um bloco de tratamento de exceções.

try {

} catch(Exception exc) {

void

Usado para declarar uma função/variável como void.

void MyVoidVar;

volatile

Usado para garantir que múltiplas threads poderão acessar o objeto simultaneamente.

volatile int Products;

while

Usado para iniciar um loop while.

while(Products < 40) {