Tecnologia

Comando para abrir página da intenet via terminal Linux

2013-07-05T11:19:00.000-07:00

gnome-open

gnome-open http://www.junior310.blogspot.com

LinuxJarvis

2013-07-02T16:27:00.001-07:00

Ativando a conta root no Ubuntu Essa dica é para habilitar a conta root no Ubuntu, não sendo mais necessário ficar usando o comando "sudo" toda vez que for necessário dar um comando como super usuário. Mas porque habilitar ou desabilitar a conta de super-usuário? Essa pergunta pode ser respondida da seguinte forma: a conta vem desabilitada por padrão porque não é seguro trabalhar como root o tempo todo, pois algum arquivo poderá ser movido ou editado de forma equivocada, sendo assim a conta fica restrita a ser usada com o comando sudo antes de cada comando para justamente evitar equívocos, porém quando estamos trabalhando montando serviços, programando ou fazendo alguma outra tarefa que exija poder de super-usuário, é super desagradável ficar usando o sudo, por isso é viável a habilitação do root, sendo necessário somente abrir um terminal, digitar "su" e colocar a senha do root. 1a. forma Para habilitar dê o comando abaixo um terminal: $ sudo passwd root Digite e confirme a senha. Pronto, agora para utilizar o usuário root basta se logar em um terminal e: $ su root e digitar a senha escolhida. Para desabilitar a conta do root basta: $ sudo passwd -l root Aí a conta será desabilitada. 2a. forma Outra forma de habilitar a conta é: $ sudo su $ passwd Digite e confirme a senha. (Essa segunda forma foi contribuída pelo moderador chemonz) ATENÇÃO: Muito cuidado ao usar a conta de ROOT, tenha certeza do que você faz, pois pode estragar o sistema. Muito obrigado pelo espaço. :) Felicidades a todos.

Álgebra Booleana

2012-09-06T05:40:00.000-07:00

Introdução à Álgebra Booleana

A lógica matemática pode ser considerada como a ciência do raciocínio e da demonstração. Este ramo da Matemática foi desenvolvido pelo matemático inglês George Booole (1815-1864) no século XIX, que criou a álgebra que leva seu nome, a Álgebra Booleana, que utiliza-se de símbolos e operações algébricas para representar as relações entre proposições.

Proposição

Uma proposição é uma sentença declarativa, normalmente implicando na relação entre dois elementos, à qual pode ser atribuido um valor lógico VERDADEIRO (V, ou 1 na Álgebra Booleana) ou FALSO (F, ou 0). Uma proposição deve satisfazer aos dois seguintes princípios fundamentais:

Ø Princípio do terceiro excluído: uma proposição só pode ser verdadeira ou falsa, não havendo outra alternativa possível.

Ø Príncipio da não contradição: uma proposição não pode ser ao mesmo tempo verdadeira e falsa.

Uma proposição é usualmente indicada pelas letras maiúsculas (A, B, C, …). A tabela a seguir ilustra alguns exemplos de proposições (com seu valor lógico entre parênteses) e algumas afirmações que não podem ser consideradas proposições.

PROPOSIÇÃO
NÃO PROPOSIÇÃO
2 + 4 = 7 (F)
3 + 6
Um retângulo é um polígono de 4 lados (V)
x + 8 = 10
A Terra não é um planeta (F)
Está chovendo

Operadores Lógicos

A Lógica Matemática se utiliza de diversos operadores para correlacionar as proposições entre si. A tabela a seguir ilustra os principais operadores e seus símbolos. Cada um desses operadores será detalhado mais adiante.

Símbolo
Operador
~
Não (negação)
^
E
ν
Ou
Ou Exclusivo

Operador “Negação”

A negação inverte o valor lógico de uma proposição. Sua notação é ~A (lê-se “não A” ou “negação de A”). A tabela a seguir ilustra os possíveis valores lógicos de uma proposição A e de sua negação:

A

~A

1

0

0

1

É importante observar que a negação da negação corresponde à própria proposição, ou seja, ~(~A) = A.

Operador “E”

A operação lógica E associa duas proposições na forma A ^ B (lê-se “A e B”). Esta operação somente terá valor lógico verdadeiro quando ambas proposições forem verdadeiras. Na Álgebra Booleana, esta operação pode ser representada por uma operação de multiplicação entre os valores lógicos da duas proposições, como fica claro na tabela abaixo:

A

B

A ^ B

1

1

1

1

0

0

0

1

0

0

0

0

O operador E é comutativo, ou seja, A ^ B = B ^ A.

Operador “OU”

A operação lógica OU associa duas proposições na forma A ν B (lê-se “A ou B”). Esta operação terá valor lógico verdadeiro quando pelo menos uma das proposições for verdadeira, sendo falsa apenas quando ambas forem falsas. Na Álgebra Booleana, esta operação pode ser representada por uma operação de adição entre os valores lógicos das duas proposições, como fica claro na tabela abaixo:

A

B

A ν B

1

1

1

1

0

1

0

1

1

0

0

0

O operador OU é comutativo, ou seja, A ν B = B ν A.

Circuitos Lógicos

Os operadores lógicos E e OU podem ser representados por meio de associações de chaves (ou “interruptores”) em um circuito análogo a um circuito elétrico, sendo que um interruptor fechado representa o valor lógico verdadeiro (1) para uma proposição e um interruptor aberto representa o valor falso (0) para esta mesma proposição. Desta forma temos:

Valores Lógicos:

Valor Lógico

Estado

Representação

Verdadeiro (1)

Fechado

Falso (0)

Aberto

Operadores Lógicos

Operador

Associação

Representação

E

Série

OU

Paralelo

Facebook

2012-09-04T11:31:00.002-07:00

https://www.facebook.com/juniorjr.ti

Fatorial de um número escrito em java!!!! Ex 2

2012-09-04T08:21:00.000-07:00

public class FatorialExpressao
{

int fatorial1=6;
int vezes1 = fatorial1 -1;
int fatorial2=4;
int vezes2 = fatorial2 -1;
int div;

public void calcular()
{

for(int n=fatorial1; vezes1>=2; vezes1 -- )
{
fatorial1=(fatorial1 * vezes1);

}
System.out.println(fatorial1);

for(int n=fatorial2; vezes2>=2; vezes2 -- )
{
fatorial2=(fatorial2 * vezes2);

}
System.out.println(fatorial2);

System.out.println();
System.out.println();
div = fatorial1/fatorial2;
System.out.println(div + " divisão de : " + fatorial1 + " / " + fatorial2);

}

public static void main(String[] args)
{

FatorialExpressao fe= new FatorialExpressao();
fe.calcular();

}
}

OBS * resultado

720
24

30 divisão de : 720 / 24

Fatorial de um número escrito em java!!!!

2012-09-04T08:13:00.000-07:00

public class Fatorial
{

int fatorial=5;
int vezes=fatorial -1;

public void calcular()
{
if (fatorial ==0)
{
System.out.println("1");
}
if(fatorial==1)
{
System.out.println("1");
}
for(int n=fatorial; vezes>=2; vezes -- )
{
fatorial=(fatorial * vezes);

System.out.println(fatorial);

}

}

public static void main(String[] args)
{

Fatorial f = new Fatorial();
f.calcular();
}

}

Obs * Resultado

20
60
120

Primeira aula de Java ( escola )

2011-02-22T10:50:00.000-08:00

import javax.swing.JOptionPane;

public class Matematica
{
int x,y, resultado;
void somar()
{
resultado = x +y;
System.out.println("Resultado da soma : " + resultado);
}
void subtrair(int x, int y)
{
resultado = x-y;
JOptionPane.showMessageDialog(null, "O valor da subtração : " + resultado );
}

public static void dividir(int w, int l)
{
int resultado;
if(w == 0)
{
System.out.println("Impossível dividir por : " + w);
}else {
resultado = w/l;
System.out.println("O valor da divisão de : " + w + " por " + l + " é igual : " +resultado);
}
}

public static int multiplicar (int d, int k)
{
int resultado;
resultado = d * k;
System.out.println("O valor da multiplicação é : " + resultado);
return resultado;
}
}

***********************************************************************************************

public class MatematicaExe
{

public static void main(String args[])
{
Matematica m1 = new Matematica();
Matematica m2= new Matematica();
Matematica m3 = new Matematica();
Matematica m4 = new Matematica();

m2.subtrair(100, 99);
m1.subtrair(12, 2);
m3.dividir(100, 2);
m4.multiplicar(3, 8);
}
}

Construtor Java

2011-01-14T13:11:00.000-08:00

Construtores : até o presente momento, em todas as instanciações (ou inicializações) de objeto foi usada a palavra reservada "new" da seguinte forma:
Veiculo v1= new Veiculo ();

Conforme comentado anteriormente , o operador "new" é responsável pelo processo de instanciação do objeto. A declaração anterior pode ser lida como : construa o objeto v1 (do tipo Veiculo) com valores default.

Como o próprio nome diz, o método construtor é responsável por construir um objeto com determinados valores. Se o construtor não for declarado , é assumido um construtor default da linguagem Java, em que as variáveis são inicializadas com valores default (variáveis númericas recebem 0, valores lógicos recebem false e os objetos recebem null). Quando declarado, ele deve possuir, obrigatoriamente , sempre o mesmo nome (idêntico) da classe em que se localiza. Dependendo das necessidades , uma classe pode conter de 0 a N construtores.

O método construtor é responsável por alocar espaço na memória para a manipulação do novo objeto que está sendo criado. O método construtor pode conter também a chamada para outros métodos, possibilitando a criação de objetos mais complexos. Na criação das janelas(frames), por exemplo, o método construtor pode definir todas as propriedades dos objetos (cor, tamanho, formulário, tamanho dos botões, etc...)

public class Cliente
{

String nome;
int idade;
int rg;
public Cliente(String nome, int idade, int rg)
{
this.nome=nome;
this.idade=idade;
this.rg=rg;
System.out.println("Nome :" + nome+ ", idade : "+ idade + ", RG : " + rg);
}
}

public class UsaCliente
{
public static void main(String[] args)
{
Cliente c1=new Cliente("Gilberto Messias da Costa Junior", 25, 89898989);
Cliente c2=new Cliente ("Claudia Soares ", 19,8989898);
Cliente c3=new Cliente ("Luana Soares ", 28 ,89898);
}
}

// Resultado :
Nome :Gilberto Messias da Costa Junior, idade : 25, RG : 89899
Nome :Claudia Soares , idade : 19, RG : 8989898
Nome :Luana Soares , idade : 28, RG : 89898

Sintax Método em Java

2011-01-13T15:34:00.000-08:00

Métodos são trechos de códigos que permitem modularizar um sistema. isto é, são pequenos blocos que, juntos, compões um sistema maior. Os métodos recebem um determinado nome e podem ser chamados várias vezes durante a execução de uma classe, ou seja, é uma sub-rotina que pode ser invocada toda vez que sua funcionalidade for necessária em um trecho da classe ou ainda a partir de outra class. Os principais motivos que levam utilizar métodos se refere a redução do código de um sistema(cada trecho de código realiza uma tarefa)
Um método pode ser comparado a um setor de uma empresa especializado em uma determinada tarefa.
Ex :
qualificador tipo-de-retorno nome-do-método([lista de argumentos])
{
códigos a serem executados
}

Qualificador : conhecido também por modificador , define a visibilidade do método
public, visivel para qualquer classe
private, esse modificar restringe o método para ser utilizado apenas própria classe
protected, visível apenas pela própria classe por suas subclasses e pelas classes do mesmo pacóte.

Tipo-de-retorno : refere-se ao tipo de dado retornado pelo método . Métodos que não retornam valores devem possuir nesse parâmetro a palavra void. Sempre que void for usada na declaração de um método, nenhum valor será retornado após a execução do método.

Nome-do-método : pode ser qualquer palavra ou frase desde que seja iniciada com uma letra. Se o nome for uma frase não pode existir espaços em branco entre as palavras. Como padrão da linguagem Java, o nome de método sempre inicia com letras minúsculas . Se outras palavras forem necessárias, então elas devem iniciar com maiúsculas
Ex:
nomeFuncionario, matrizSetor...
OBS : utilize sempre nomes sugestivos para a ação do método.

Lista-de-argumentos : trata-se de uma lista de variáveis opcionais que podem ser recebidas pelo método para tratamento interno. quando um método é invocado(chamado) ele pode receber valores de quem chamou. Esses valores podem ser manipulados internamente e ser devolvido ao emissor da solicitação. Esse processo pode ser comparado ao processo de fabricação industrial : entra matéria prima (os valores passados) e sai um produto acabado(o retorno do método). Um mesmo método pode receber diversos tipos de variáveis, desde tipos primitivos até objetos complexos.

Códigos-do-corpo : trata-se dos códigos em Java que realizam os processos internos e retornam os valores desejados, isto é, constituem o programa do método.
O tipo-de-retorno o nome-do-método e a lista de argumentos formam a assinatura do método, algo que identifica de maneira única

Método sem retorno : os métodos sem retorno não retornam valores, semelhante às procedures encontradas nas maiorias das linguagens de programações, métodos que não retornam valores devem conter o nome void na declaração do método.

Métodos que retornam argumentos : Na declaração do método deve conter um tipo de dado e os argumentos devem também conter um tipo de dado, não necessariamente o mesmo que foi usado na declaração
Ex: public double soma(double j, int c)

-----------------------------------------------------------------------------------------------

import java.util.*;
public class Metodos_Java
{
public static void soma (double num1, int num2)
{
double resultado=0;
resultado = num1 + num2;
System.out.println("O resultado é : " + resultado);
}

public double soma1(double num3, int num4)
{
double resultado = 0;
resultado = num3 + num4;
System.out.println("O Resultado é : " + resultado);
return resultado;
}
public void soma()
{
int numero1, numero2;
Scanner entrada=new Scanner (System.in);
System.out.print("Digite o valor");
numero1=entrada.nextInt();
System.out.print("Digite outro valor");
numero2=entrada.nextInt();
System.out.println("O Valor da soma é : " +( numero1 + numero2));
}
public static void main(String[] args)
{

Metodos_Java MJ = new Metodos_Java();

MJ.soma(1.99, 1);
MJ.soma1(10.34, 2);
MJ.soma();

}
}

// resultado
O resultado é : 2.99
O Resultado é : 12.34
Digite o valor 12
Digite outro valor 12
O Valor da soma é : 24

Class Abstract em Java

2011-01-06T08:47:00.000-08:00

class abstract
Uma class abstract tem a flexibilidade de conter métodos concretos.
Uma class abstract não pode conter nehuma instancia da mesma class.
Em uma class abtract, quando recebe um implements de uma inteface não é necessário que seja
sobrescrito os métodos que possui a interface, mas cabe uma ressalva, lembrando que em algum momento
deverá ser sobrescrito os métodos em alguma class "CONCRETA".
Um método abstract não pode conter o modificador STATIC.
As váriaveis que são declaradas nas class abstract pode conter o modificador STATIC,
SENDO POSSÍVEL QUE EM OUTRAS CLASS ESSE ATRIBUTO SEJA REAPROVEITADO E SEU VALOR MODE SER MODIFICADO.

Interface Java

2011-01-04T12:17:00.001-08:00

package Interface;

public interface Familia
{
public abstract void pai();
abstract public void mae();
}

---------------------------------------------------------------------------------

public class Filho implements Familia
{
public void pai()
{
System.out.println("pai");
}
public void mae()
{
System.out.println("mae");
}
public static void main(String[] args)
{

Filho f= new Filho();
f.mae();
f.pai();
}

}

Interface : ao criar um interface você, estará definindo um contrato com o que a classe deve fazer, sem mencionar
nada como a classe o fará.

A interface pode ser implementada por qualquer classe de qualquer arvore de herança. Isso permitirá que você use
classes radicalmente diferentes e forneça a elas uma caracteristica em comun.
Por exemplo :
Vamos criar uma inteface Voavel. Ela poderia ser implementada por uma mosca, por um avião e por uma classe chamada tiro de canhão.

Uma interface deve ser considerada como uma classe totalmente ABSTRACT.
Uma interface só pode definir métodos ABSTRACT
As interfaces são implicitamente ABSTRACT, colocar esse modificador é opcional;
Uma interface NÂO pode ter o modificador PRIVATE ou PROTECTED;
Uma interface pode estender várias interfaces isso mesmo, a palavra usada é "extends";
Uma interface NÂO pode implementar outra interface ou classe (parece estranho, mas uma interface estende outras interfaces);
Uma classe que implementa uma interface não pode declarar nenhuma EXCEÇÃO "EXCEPTION" nova, ou mais abrangente, mas pode declarar exceções de tempo de execução em qualquer método;
Os métodos declarados em uma interface não podem ser STATIC;
Os métodos da interface não podem ser marcados com FINAL, NATIVE, STRICTFP ou SYNCHRONIZED ;
As declarações public, static e final são opcionais;
uma interface pode ser extendida por outra interface.

uma interface com o modificador PUBLIC possui visualidade total
uma interface sem o modificador PUBLIC, é atribuida como DEFAULT, e só é visivel apenas para classes e interfaces que estão
no mesmo pacote "PACKAGE".

Métodos em interface sempre são PUBLIC ABSTRACT, quando não escrito, está implicito.

Todas as váriaveis que são declaradas em uma interface são constantes(PUBLIC STATIC FINAL), é possível
reaproveitar os valores das constantes declaradas
em interfaces apenas como valores para leitura, lembrando, como são constantes após atribuido os valores
não é possível ser alterado.

Todo método de interface é terminado com parenteses e ponto virgula();

public interface Filho extends Familia
OBS : Filho estará herdando todos os atributos e métodos da interface Familia

Formas que são possível declarar constantes :

public static final String nome ="Gilberto";
static public final String sobrenome = "Messias";
public final String sobrenome1 = "Da Costa Junior";
static boolean sexo = true;

Sobrecarga de métodos em Java

2011-01-03T13:34:00.001-08:00

/*
Java nos permite criar vários métodos com o mesmo nome desde que tenham parâmetros diferentes. Isso é o que chamamos de sobrecarga de métodos.
A sobrecarga de métodos consiste em criarmos o mesmo método com possibilidades de entradas diferentes.
Essas entradas, caracterizadas como parâmetros, devem sempre ser de tipos diferentes, quantidades de parâmetros diferentes ou posições dos tipos diferentes.
*/

// então. sobrecarga de metodos é quando metodo possui o mesmo nome porém, os parametros devem ser diferentes

public class Sobrecarga_Metodos
{

    public static int soma(int x, int y)
    {
        int resultado;
        resultado = x+y;
        System.out.println("Método 1\n" + resultado);

        return x+y;
    }
    public int soma(int x, int y, int z)
    {
        int resultado;
        resultado = x=y+z;
        System.out.println("Método 2\n" + resultado);
        return x+y+z;
    }

    public double soma( double x, double y)
    {
        double resultado;
        resultado = x+y;
        System.out.println("Método 3\n " + resultado);
        return x+y;

    }

    public static void main(String args[])
    {
        Sobrecarga_Metodos sm= new Sobrecarga_Metodos();

        sm.soma(12, 3);
        sm.soma(12, 23, 5);
        sm.soma(10, 10.9);

    }

}

Código para extender tela da virtualbox utilizando linux

2011-01-03T13:22:00.000-08:00

Acesse o terminal com senha de administrador e execute o comando abaixo :

sudo apt-get install virtualbox-ose-guest-x11

int, short, long, char, String

2011-01-03T07:15:00.000-08:00

public class Tipo_De_Dado
{
public static void main(String[] args)
{

/*O tipo byte é o de menor alcance entre os inteiros.
Como o próprio nome sugere, ele consome apenas um byte (8 bits)
e pode guardar valores entre -128 e 127 */
byte a = -128;
byte b= 127;
System.out.println("byte :" + a + " até " + b);

//O tipo short guarda inteiros de 2 bytes (16 bits) e pode guardar
números entre -32.768 a 32.767.
short c = -32768;
short d = 32767;
System.out.println("short : " + c + " até " + d);

/* O tipo int é o tipo de dado mais comum. Ele consome 4 bytes (32 bits)
* e guarda valores entre -2.147.483.648 e 2.147.483.647.
*/
int e=-2147483648;
int f= 2147483647;
System.out.println("int : " + e + " até " + f);

/*Long é o tipo de dado com maior alcance entre os inteiros. Consequentemente,
* também é o que ocupa mais espaço (8 bytes ou 64 bits).
* Tem um grande alcance que fica entre -9,22E+18 (exatos
-9.223.372.036.854.775.808)
* e 9,22E+18 (exatos 9.223.372.036.854.775.807).
*/
//long g= -9.223.372.036.854.775.808;
//long h = 9.223.372.036.854.775.807;
System.out.println("long : -9.223.372.036.854.775.808 até
9.223.372.036.854.775.807; ");

/*Existe os tipos de dados próprios para caracteres que é o char.
O tipo char ocupa 2 bytes, o que torna Java ideal para programar em
língüas latinas,
asiáticas ou qualquer outra que utilize caracteres diferentes do
padrão ASCII. */

char i='j';
char j='ú';
System.out.println( "char :"+ i + "" +j);

// String é uma conjunto de caracteres...
String nome= "Gilberto ";
String sobre = "Júnior";
System.out.println( "String : " +nome + sobre);

/* Double é o tipo de dado mais complexo que há em Java e o
maior valor possível
* de se armazenar é 1,797.693.134.862.315.7E+308. Muito mais
do que qualquer programador precisa.
*/
System.out.println("double : 1,797.693.134.862.315.7E+308");

}
}

------------------------------------------------------------------------------------------------
saida na console

byte :-128 até 127
short : -32768 até 32767
int : -2147483648 até 2147483647
long : -9.223.372.036.854.775.808 até 9.223.372.036.854.775.807;
char :jú
String : Gilberto Júnior
double : 1,797.693.134.862.315.7E+308

Tipo de dados em Java

2011-01-03T06:04:00.000-08:00

Tipos de Dados Vamos iniciar com os tipos de dados inteiros que são os mais simples. Em Java, os números inteiros são divididos em quatro tipos: byte, short, int e long. Esses quatro guardam o mesmo tipo de dado, mas ocupam espaços de memória diferente, o que afeta em seu alcance. O tipo byte é o de menor alcance entre os inteiros. Como o próprio nome sugere, ele consome apenas um byte (8 bits) e pode guardar valores entre -128 e 127. O tipo short guarda inteiros de 2 bytes (16 bits) e pode guardar números entre -32.768 a 32.767. O tipo int é o tipo de dado mais comum. Ele consome 4 bytes (32 bits) e guarda valores entre -2.147.483.648 e 2.147.483.647. Long é o tipo de dado com maior alcance entre os inteiros. Consequentemente, também é o que ocupa mais espaço (8 bytes ou 64 bits). Tem um grande alcance que fica entre -9,22E+18 (exatos -9.223.372.036.854.775.808) e 9,22E+18 (exatos 9.223.372.036.854.775.807). Existe os tipos de dados próprios para caracteres que é o char. O tipo char ocupa 2 bytes, o que torna Java ideal para programar em língüas latinas, asiáticas ou qualquer outra que utilize caracteres diferentes do padrão ASCII. O padrão ASCII utiliza apenas um byte que fornece 256 letras diferentes, mas o padrão utilizado em Java (ISO) nos dá a possibilidade de até 65.536 caracteres diferentes. Para números decimais utilizamos dois tipos de dados, dependendo da necessidade de seu alcance e precisão (números após a vírgula). O tipo de dado mais comum para número decimal é o float. Em um tipo de dado float, podemos guardar números grandes que vão desde 1,4E-45 até 3,4028235E+38 Para número decimais com grande precisão ou valores extraordinários (geralmente utilizados em matemática aplicada e complexa como cálculos físicos, químicos, astrológicos, meteorológicos, etc) utilizamos o tipo de dado double. Double é o tipo de dado mais complexo que há em Java e o maior valor possível de se armazenar é 1,797.693.134.862.315.7E+308. Muito mais do que qualquer programador precisa.

Tecnologia: Tecnologia

2011-01-02T08:27:00.000-08:00

Técnologia: Tecnologia

Tecnologia na antiguidade

2011-01-02T08:07:00.001-08:00

Na antiga Grécia a educação do povo passava pelos preceptores que possuíam os saberes e os passavam aos seus discípulos (alunos), a informação vinha dos escritos e da transmissão da cultura popular divulgada pelo Teatro e em Praças públicas. Analisando os meios educacionais tecnológicos dos dias atuais e comparando-os com a busca do conhecimento na Grécia antiga, podemos identificar pontos que nos dão a dimensão da necessidade de utilizar as possibilidades do desenvolvimento aplicadas ao ensino-aprendizagem nos dias de hoje.
Os teatros gregos eram construídos de forma a aproveitar as encostas das colinas para que a acústica fosse melhor ao espectador, não havia aparatos tecnológicos para ampliação da voz, as peças eram apresentadas durante o dia, pois não havia iluminação artificial; as peças retratavam os personagens da história e os mitos, já conhecidos do povo e em nossos dias, só que a cada festival os autores buscavam novas formas de interpretação e adaptação, bem como de máscaras mais eficientes para difusão da voz, cenários móveis, figurinos e aparatos mais atraentes à visão e aos poucos foram se introduzindo formas de iluminação como velas e tochas.
Pode se perguntar o leitor: como isso se relaciona com as TICs na educação do século XXI? Minha comparação se faz para que se veja que a tecnologia avança a cada momento, a informação e a comunicação são necessidade do ser humano e a difusão das ideias precisa ser sempre mais atraente e inovadora. Quando falamos de Educação, falamos de busca e transmissão de conhecimentos, seja este de mitos, matemáticos ou de linguagem; o Teatro grego difundia o pensamento de uma cultura que ao longo dos séculos influencia a história da humanidade, tem-se conhecimento da filosofia de Sócrates e Platão, estuda-se história da humanidade através da arquitetura daquele povo e sabe-se o que é democracia em função da busca de inovações tecnológicas de uma civilização que queria mostrar seus ideais. A tecnologia não está apenas nos modernos computadores ou na maior velocidade da web, ela está presente na melhor forma que se encontra para facilitar as ações diárias, exemplo disso é a escrita que já foi em pedras e rolos de pergaminho e que evolui a cada dia.
A Educação precisa ser dinâmica, a forma que se ensina hoje pode mudar no dia de amanhã, isso porque trabalha-se com seres humanos diferentes; a produção e utilização de material pedagógico deve acompanhar a velocidade com que as inovações acontecem em todos os setores da sociedade. O educador do século XXI precisa de capacitação constante. E essa capacitação pode ser adquirida com maior facilidade através dos meios que se possuí nos dias atuais; tem-se acesso imediato a publicações que remetem aos escritos dos dramaturgos gregos, diferentemente da época em que viviam, quando era preciso esperar acontecerem os festivais teatrais para conhecerem as novas falas e personagens deles. O Professor precisa estar consciente de que não é mais a única fonte de instrução dos seus alunos, ele atua como um mediador do conhecimento e que este se faz no dia a dia. A atualização e o domínio de novas ferramentas de auxílio ao ensino é importante para que o educador traga motivação e prazer em sua matéria para o melhor aprendizado. O papel do educador na sociedade atual não se limita apenas a ensinar a ler e escrever como mecanismo de superação pessoal, faz-se necessário preparar nosso educando para uma sociedade em que o desenvolvimento integral do ser humano é desenvolver habilidades para inserção no mundo de informação e comunicação. O grande desafio do professor é saber introduzir as novas TICs com objetivos planejados dentro do processo educativo, para tanto é necessário que, de acordo com o que diz LLANO & ADRIÁN “o compromisso está em criar situações educativas que tirem proveito dessas tecnologias e desenvolvam meios de aprendizagem eficazes.” (p. 51, 2006), não se utilizem ferramentas simplesmente para que se diga que está atualizado ou porque elas foram instaladas na escola; é preciso ter em mente que vão auxiliar no desenvolvimento pedagógico da disciplina e dentro de um contexto em que os recursos são complementos para melhoria do entendimento do educando.
Os recursos disponíveis para a produção de materiais pedagógicos são grandes e cada dia se desenvolvem mais, deve-se buscar aprendê-los e adaptá-los aos objetivos educacionais e é bom reforçar que nesse momento a interação com o aluno valoriza e enriquece o trabalho, pois o tempo disponível e o acesso a novos softwares é maior por parte deles, o que permite novas descobertas e integração aos conteúdos em estudo. A utilização de sites, blogs e ferramentas interativas faz com que a informação e a comunicação sejam rápidas, prazerosas e alcancem possibilidades de aprendizado. Recursos visuais e sonoros que se adequem à sala de aula podem ser mais eficientes que giz e quadro negro e cabe ao professor aplicar estes novos meios para transformar o ambiente escolar, não ficar esperando que superiores ou o Estado venham oferecer as novidades, partindo de cada educador para influenciar os gestores é que se poderá buscar as inovações, sempre demonstrando as possibilidades de melhoria da qualidade educacional.
Concluindo, vê-se que a tecnologia esteve presente na Educação dos gregos na antiguidade através do desenvolvimento e da divulgação dos seus ideais, na forma com que o teatro buscou aperfeiçoar as técnicas para transmitir as histórias e as emoções; e a mesma tecnologia vem se transformando através dos séculos, evoluindo e criando novas formas de possibilitar maior informação e comunicação. A Educação estava presente nas ideias dos dramaturgos e filósofos gregos e se expandiu trazendo a cultura clássica para o conhecimento dos dias atuais, e a mesma educação se apropria das novas tecnologias para transformar a relação ensino-aprendizagem em uma busca constante de conhecimento e formação do cidadão de forma prazerosa e dinâmica; cabe aos educadores do século XXI capacitarem-se para utilizar os meios disponíveis e transformá-los em eficientes ferramentas educativas visando à continuidade da dinâmica do saber.

Fonte: http://www.webartigos.com/articles/53560/1/Educacao-atraves-da-Tecnologia-da-Antiguidade-classica-a-Modernidade/pagina1.html#ixzz19tXG8V9K

Tecnologia

2010-12-31T09:19:00.000-08:00