Todos os post de NetSySoft

Carnaval confunde Windows sobre novo horário

de-201002171815421

Uma mudança na data em que acaba o horário de verão no Brasil causou confusão entre usuários que não mantêm sua versão do Windows atualizada.

Inicialmente, o governo brasileiro planejou o fim do horário de verão para o último domingo, dia 14, à zero hora. Esta informação consta no calendário do Windows, que muda os horários dos PCs automaticamente.

Em função da data cair em pleno feriadão de Carnaval, o fim do horário de verão foi adiado para o próximo domingo, dia 21. Usuários que não mantêm o Windows atualizado ficaram sem acesso à correção da Microsoft e viram suas máquinas exibir o novo horário com uma semana de antecedência.

Quem sofreu com o problema, que afetou usuários do XP, Vista e Windows 7, deve realizar as atualizações obrigatórias oferecidas pela Microsoft para assegurar que o relógio de seu Windows só mude o horário à zero hora do dia 21.

Outra opção é clicar sobre o relógio do Windows e desabilitar a característica “Ajustar automaticamente o relógio para o horário de verão“.

Hypnosis animation

import java.awt.Color;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.geom.GeneralPath;

import javax.swing.JComponent;
import javax.swing.JFrame;

public class Hypnosis1 extends JComponent implements Runnable {
private int[] coordinates;

private int[] deltas;

private Paint paint;

public Hypnosis1(int numberOfSegments) {
int numberOfCoordinates = numberOfSegments * 4 + 2;
coordinates = new int[numberOfCoordinates];
deltas = new int[numberOfCoordinates];
for (int i = 0; i < numberOfCoordinates; i++) {
coordinates[i] = (int) (Math.random() * 300);
deltas[i] = (int) (Math.random() * 4 + 3);
if (deltas[i] > 4)
deltas[i] = -(deltas[i] - 3);
}
paint = new GradientPaint(0, 0, Color.blue, 20, 10, Color.red, true);

Thread t = new Thread(this);
t.start();
}

public void run() {
try {
while (true) {
timeStep();
repaint();
Thread.sleep(1000 / 24);
}
catch (InterruptedException ie) {
}
}

public void paint(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Shape s = createShape();
g2.setPaint(paint);
g2.fill(s);
g2.setPaint(Color.white);
g2.draw(s);
}

private void timeStep() {
Dimension d = getSize();
if (d.width == 0 || d.height == 0)
return;
for (int i = 0; i < coordinates.length; i++) {
coordinates[i] += deltas[i];
int limit = (i % 2 == 0) ? d.width : d.height;
if (coordinates[i] < 0) {
coordinates[i] = 0;
deltas[i] = -deltas[i];
else if (coordinates[i] > limit) {
coordinates[i] = limit - 1;
deltas[i] = -deltas[i];
}
}
}

private Shape createShape() {
GeneralPath path = new GeneralPath();
path.moveTo(coordinates[0], coordinates[1]);
for (int i = 2; i < coordinates.length; i += 4)
path.quadTo(coordinates[i], coordinates[i + 1], coordinates[i + 2], coordinates[i + 3]);
path.closePath();
return path;
}

public static void main(String[] args) {
JFrame f = new JFrame("Hypnosis");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.add(new Hypnosis1(4));
f.setSize(300, 300);
f.setVisible(true);
}
}

Font size animation

import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

public class FontSizeAnimation extends JPanel implements ActionListener {
Timer timer;
int x = 1;
float alpha = 1;

public FontSizeAnimation() {
timer = new Timer(8, this);
timer.setInitialDelay(190);
timer.start();
}

public void paint(Graphics g) {
super.paintComponent(g);
Graphics2D g2d = (Graphics2D) g;

Font font = new Font("Dialog", Font.PLAIN, x);
g2d.setFont(font);

FontMetrics fm = g2d.getFontMetrics();
String s = "Java";

int w = (int) getSize().getWidth();
int h = (int) getSize().getHeight();

int stringWidth = fm.stringWidth(s);

g2d.drawString(s, (w - stringWidth) / 2, h / 2);
}

public static void main(String[] args) {
JFrame frame = new JFrame("FontSizeAnimation");
frame.add(new FontSizeAnimation());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(400, 300);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}

public void actionPerformed(ActionEvent e) {
x += 1;
alpha -= 0.0001;
repaint();
}
}

Fade out de uma imagem: a imagem vai ficando transparente gradualmente até que esteja completamente invisível

import java.awt.AlphaComposite;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

public class FadeOutImage extends JPanel implements ActionListener {
Image myImage = new ImageIcon("a.jpg").getImage();

Timer timer = new Timer(20, this);

private float alpha = 1f;

public FadeOutImage() {
timer.start();
}

public void paint(Graphics g) {
super.paint(g);
Graphics2D g2d = (Graphics2D) g;

g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha));
g2d.drawImage(myImage, 10, 10, null);
}

public void actionPerformed(ActionEvent e) {
alpha += -0.01f;
if (alpha <= 0) {
alpha = 0;
timer.stop();
}
repaint();
}
public static void main(String[] args) {
JFrame frame = new JFrame("Fade out");
frame.add(new FadeOutImage());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(300, 250);
frame.setVisible(true);
}

}

A rotating and scaling rectangle

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

public class SwingTimerBasedAnimationScaleRotate extends JPanel implements ActionListener {
Timer timer;
private double angle = 0;
private double scale = 1;
private double delta = 0.01;
Rectangle.Float r = new Rectangle.Float(20, 20, 200, 200);
public SwingTimerBasedAnimationScaleRotate() {
timer = new Timer(10, this);
timer.start();
}

public void paint(Graphics g) {
int h = getHeight();
int w = getWidth();

Graphics2D g2d = (Graphics2D) g;

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

g2d.translate(w / 2, h / 2);
g2d.rotate(angle);
g2d.scale(scale, scale);

g2d.fill(r);
}

public static void main(String[] args) {

JFrame frame = new JFrame("Moving star");
frame.add(new SwingTimerBasedAnimationScaleRotate());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(420, 250);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}

public void actionPerformed(ActionEvent e) {

if (scale < 0.01) {
delta = -delta;
else if (scale > 0.99) {
delta = -delta;
}

scale += delta;
angle += 0.01;

repaint();
}
}

Timer based animation

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.Ellipse2D;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

public class TimerBasedAnimation extends JPanel implements ActionListener {
private Ellipse2D.Float ellipse = new Ellipse2D.Float();

private double esize;

private double maxSize = 0;

private boolean initialize = true;

Timer timer;

ActionListener updateProBar;

public TimerBasedAnimation() {
setXY(20 * Math.random(), 200, 200);

timer = new Timer(20, this);
timer.setInitialDelay(190);
timer.start();
}

public void setXY(double size, int w, int h) {
esize = size;
ellipse.setFrame(10, 10, size, size);
}

public void reset(int w, int h) {
maxSize = w / 10;
setXY(maxSize * Math.random(), w, h);
}

public void step(int w, int h) {
esize++;
if (esize > maxSize) {
setXY(1, w, h);
else {
ellipse.setFrame(ellipse.getX(), ellipse.getY(), esize, esize);
}
}

public void render(int w, int h, Graphics2D g2) {
g2.setColor(Color.BLUE);
g2.draw(ellipse);
}

public void paint(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D) g;

RenderingHints rh = new RenderingHints(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);

rh.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

g2.setRenderingHints(rh);
Dimension size = getSize();

if (initialize) {
reset(size.width, size.height);
initialize = false;
}
this.step(size.width, size.height);
render(size.width, size.height, g2);
}

public void actionPerformed(ActionEvent e) {
repaint();
}

public static void main(String[] args) {
JFrame frame = new JFrame("TimerBasedAnimation");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(new TimerBasedAnimation());
frame.setSize(350, 250);
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}

Is Event Dispatcher Thread

import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

import javax.swing.AbstractAction;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTable;
import javax.swing.SwingUtilities;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableCellRenderer;

public class IsEDTExample extends JPanel {
private boolean keepRunning;

private static int RED = 0;

private static int BLUE = 1;

private static int GREEN = 2;

private static int VARIABLE = 3;

private static int SIZE = 3;

private int threadShade;

private ColorTableModel tableModel= new ColorTableModel();

private Thread colorShadeThread;

public IsEDTExample() {
JTable table = new JTable(tableModel);
table.setRowHeight(100);
table.setDefaultRenderer(Object.class, new ColorRenderer());
add(table);

add(new JLabel("Thread Color Shade:"));
ButtonGroup group = new ButtonGroup();
JRadioButton redOption = new JRadioButton("Red");
group.add(redOption);
redOption.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
threadShade = RED;
}
});

JRadioButton blueOption = new JRadioButton("Blue");
group.add(blueOption);
blueOption.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
threadShade = BLUE;
}
});

JRadioButton greenOption = new JRadioButton("Green");
group.add(greenOption);
greenOption.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
threadShade = GREEN;
}
});

redOption.setSelected(true);
this.threadShade = RED;

add(redOption);
add(greenOption);
add(blueOption);

add(new JButton(new RandomColorAction()));

this.keepRunning = true;
this.colorShadeThread = new Thread(new RandomColorShadeRunnable());
this.colorShadeThread.start();
}

private class RandomColorAction extends AbstractAction {
public RandomColorAction() {
super("Create Random Color");
}

public void actionPerformed(ActionEvent e) {
IsEDTExample.this.tableModel.generateRandomColor(VARIABLE);
}
}

private class ColorTableModel extends AbstractTableModel {
private Color[][] colors = new Color[3][3];

public ColorTableModel() {
for (int i = 0; i < SIZE; i++) {
for (int x = 0; x < SIZE; x++) {
colors[i][x] = Color.white;
}
}
}

public int getRowCount() {
return SIZE;
}

public int getColumnCount() {
return SIZE;
}

public Object getValueAt(int rowIndex, int columnIndex) {
return colors[rowIndex][columnIndex];
}

public void generateRandomColor(int type) {
Random random = new Random(System.currentTimeMillis());
final int row = random.nextInt(SIZE);
final int column = random.nextInt(SIZE);
final Color color;
if (type == RED) {
color = new Color(random.nextInt(256), 0, 0);
else if (type == BLUE) {
color = new Color(0, 0, random.nextInt(256));
else if (type == GREEN) {
color = new Color(0, random.nextInt(256), 0);
else {
color = new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256));
}

if (SwingUtilities.isEventDispatchThread()) {
colors[row][column] = color;
fireTableCellUpdated(row, column);
else {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
colors[row][column] = color;
fireTableCellUpdated(row, column);
}
});
}
}
}

private class ColorRenderer implements TableCellRenderer {
private JLabel label;

public ColorRenderer() {
label = new JLabel();
label.setOpaque(true);
label.setPreferredSize(new Dimension(100, 100));
}

public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
boolean hasFocus, int row, int column) {
label.setBackground((Color) value);
return label;
}
}

private class RandomColorShadeRunnable implements Runnable {
public void run() {
while (keepRunning) {
tableModel.generateRandomColor(threadShade);
try {
Thread.sleep(500);
catch (InterruptedException e) {
}
}
}
}

public static void main(String[] a) {
JFrame f = new JFrame("Is Event Dispatch Thread Example");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.add(new IsEDTExample());
f.pack();
f.setVisible(true);
}

}

Como seria um mundo sem a Microsoft?

Uma nova era de inovação – ou caos em TI. Será que aplicações web poderiam substituir o Windows?

Esse é o tipo do exercício mental que atiça a curiosidade. Como seria a vida sem o Microsoft Windows? Para o pessoal do software livre e de código aberto, o sumiço do Windows – e, por consequência, o fim da hegemonia da Microsoft no mundo dos PCs – significaria uma espécie de renascimento para a tecnologia da informação. O software poderia finalmente estar livre das amarras corporativas que têm suprimido a inovação e usurpado o que há de melhor e mais brilhante nas pessoas.

Tal pensamento é incrivelmente crédulo, para dizer o mínimo. Em vez de liberar a tecnologia da informação (TI), o ocaso da Microsoft poderia jogar a indústria em um redemoinho apocalíptico de proporções bíblicas – não há lugar para visões hippies utópicas aqui. A saída de mercado da gigante de Redmond poderia causar um rompimento no cenário computacional de hoje, e questões como compatibilidade e interoperabilidade voltariam a um tipo de caos no estilo do Velho Oeste, algo nunca visto desde os tempos das três grandes do DOS: Lotus, WordPerfect e Ashton-Tate.

Não vá acreditar que a web iria de alguma forma preencher o vazio causado pelo fim do Windows. Apesar de o Google ter um bom discurso sobre a suplantação de modelos tradicionais de computação por um paradigma centrado na web, a verdade é que o pessoal de Mountain View não é menos sinistro quando se trata de planos grandiosos para dominar o mundo. A ascensão do Google – ou de qualquer competidor com presença dominante no mundo da cloud computing – deveria ser percebida como uma ameaça potencial à independência da TI. Como diz o ditado, nunca ponha todos os seus ovos de TI na cesta de um único fornecedor.

Mas vale ponderar as implicações de um mundo sem aquele logotipo brilhante e colorido do Windows. Um mundo onde os padrões são efêmeros e onde a criatividade e a inovação circulam de forma selvagem e desenfreada. Aqui, apresentaremos a visão da vida sem o Windows.

Aplicações cliente: dê adeus à consistência

O cenário das aplicações cliente será quase irreconhecível em um mundo pós-Microsoft. A depreciação do código legado em Windows API, somada à mudança rumo a um modelo de entrega totalmente baseado na web, vai abrir as comportas da inovação – e criar dores de cabeça em massa para o pessoal de suporte, que deve agora enfrentar a rica variedade de projetos de interface e de implementações que definem a experiência do usuário nas aplicações web.

Basicamente, você pode dar adeus à consistência. Com os desenvolvedores livres para criar suas próprias primitivas de interface, muitas decisões arbitrárias vão cavar seu caminho rumo ao grande inconsciente das interfaces de usuário. Passos para completar tarefas básicas – por exemplo, a manipulação e a formatação de listas de dados – vão variar enormemente entre implementações. E, embora as metáforas comuns da web (hiperlinks, form fields) continuem a funcionar como esperado, construções mais exóticas – como a versão ‘webificada’ de uma paleta de ferramentas – vão oferecer modos incrivelmente diversos de interação. Você ainda terá de clicar em coisas (ou, mais provavelmente, tocá-las na tela com o dedo ou uma caneta), mas o resultado de suas ações será tudo menos previsível.

A integração de aplicações será outro ponto problemático. Com OLE, COM e VBA fora do páreo, o trabalho de troca de dados entre aplicações cairá numa mistura de JavaScript e vários recursos e APIs baseados em nuvem. Em alguns casos – mais notavelmente, suítes de aplicações de um único fornecedor -, esta integração irá ocorrer de modo transparente na retaguarda. No entanto, sem um padrão robusto e amplamente adotado para troca de dados, será difícil atingir tal integração entre os vários silos específicos dos fornecedores que formarão as futuras instalações de cloud computing.

Um aspecto positivo do futuro das aplicações cliente pós-Microsoft será a eliminação do modelo tradicional de distribuição de software. As equipes de TI não terão mais que rastrear e gerenciar uma gigantesca biblioteca de aplicações instaladas em redes de PCs. Com tudo vinda da nuvem, os dias de pacotes MSI corrompidos e do inferno de DLLs que falham também serão coisa do passado. Toda sua infraestrutura de aplicação será totalmente dependente da conexão permanente à nuvem, o que fará da internet em si seu novo calcanhar de Aquiles.

Resumindo: espere por um aumento nos custos de suporte e de treinamento para dominar as funções mais comuns entre aplicações diferentes. Você também poderá querer atualizar seu plano de contingência para incluir os cenários de pesadelo pré-apocalíptico onde um operador de escavadeira derruba toda sua infraestrutura de TI, agora dependente da nuvem, com um movimento errado de sua poderosa pá.

Ferramentas para desenvolvedores: expurgos sangrentos e guerras de API serão os novos padrões

Tal como no caso das aplicações cliente, o cenário das ferramentas para desenvolvedor será profundamente alterado pelo declínio inevitável da API Win32. Os programadores vão enfrentar uma diversidade de decisões novas e potencialmente críticas de projeto, incluindo como criar uma interface funcional em um mundo onde as regras do velho Windows não mais se aplicam. O potencial para liberdade de expressão e de inovação verdadeira vai precisar ser equilibrado com a realidade de ter que testar mais e de assegurar que sua última ideia para um novo paradigma de interface revolucionária funcionará nos sistemas mais obscuros.

Um de seus primeiros desafios será atingir o nível de riqueza de interface do usuário com que você aprendeu a se acostumar na era pré-declínio do Windows. AJAX, CSS e HTML terão percorrido um longo caminho desde os dias em que YouTube e Facebook eram nomes familiares. No entanto, essas e outras tecnologias similares da web ainda serão restritas pelas limitações do modelo de documentos sobrepostos (underlying documents). E com as agências regulatórias decidindo pelo banimento do Adobe Flash (e soluções similares da RIA) para o bem da internet – que já estava entrando em colapso, sob o estresse de um quatrilhão de anúncios animados de Viagra – você poderá descobrir que as opções para a criação de uma interface atraente serão limitadas a imagens GIF estrategicamente posicionadas, tags DIV, e algum uso inteligente de bordas e sombras em tabelas HTML.

Outro problema será como integrar as aplicações recém-projetadas à web. A troca de dados na retaguarda por meio de APIs será predominante, cada uma com seu próprio grupo de fãs fervorosos, portanto será preciso escolher de forma sábiaa A última coisa que você quer é que sua aplicação matadora feita para mudar o mundo seja relegada à obscuridade por causa da falta de interoperabilidade com o resto da nuvem.

Há um lado bom. A ausência do Windows significa que você nunca mais terá de se preocupar se há, no PC, a versão correta de uma DLL ou biblioteca crítica, e que é necessária para sua aplicação funcionar. Da mesma forma, o debate do tipo ovo-e-galinha sobre o framework.NET será finalmente resolvido (em favor da galinha). No entanto, os dias da interface padronizada já não existirão, e isso fará com que o trabalho de criação de aplicações consistentes, e que interajam com o usuário e com outras aplicações de maneira previsível, seja muito mais desafiador.

Ecossistema de hardware: o caos até que um novo senhor apareça

Talvez a consequência mais forte dessa onda de choque pós-Windows será sentida no mercado de hardware e de periféricos para PC. A ausência de um sistema operacional dominante causará uma fratura no cenário antes homogêneo de drivers para dispositivos, e os fabricantes irão à caça das plataformas populares do momento ao mesmo tempo que rejeitarão sua base legada. Plug and Play (conecte e use) será substituído por “plug and pray” (conecte e reze) à medida em que os consumidores frustrados lutam para combinar seus aparelhos com as respectivas escolhas em sistema operacional, ao mesmo tempo que imaginam se irão lamentar suas escolhas quando a próxima onda de desenvolvimento disruptivo vier.

Neste mundo caótico da hiperinovação, os fabricantes vão procurar se alinhar com os líderes de mercado do momento. Os produtos serão julgados não por seus recursos ou qualidade de design, mas por quantos logos de “funciona com x” e “pronto para y” serão possíveis de serem colados em suas caixas. A compra de um novo produto se tornará uma partida doentia de Sudoku, em que os clientes lutarão para alinhar os valores de vários componentes no padrão correto de sequência. O sucesso virá quando alguém encontrar um grupo de produtos complementares que ostentem pelo menos um logo comun de programa de certificação – uma espécie de novo Santo Graal da TI pós-Windows.

A boa notícia é que a natureza não admite vácuo. Em algum momento, novos concorrentes emergirão para redefinir o ecossistema de hardware de PC em torno de suas plataformas particulares. Isso, por sua vez, vai causar um terremoto nas comunidades de hardware e software, e aquelas que apostarem na plataforma errada vão cair pelo caminho. Mas a questão real será: que tipo de força este novo líder ascendente mobilizará? Ele seguirá os passos da Microsoft e usará sua forã de definição de padrões para elevar o nível do mercado? Ou adotará a estratégia da IBM dos anos 1980 e tentará consolidar suas garras da morte por meio de travas proprietárias e outras práticas anticompetitivas?

Resumo: só porque o Windows saiu de cena, não quer dizer que você deverá esperar um período de renascença na inovação em hardware. O mundo pós-Microsoft parecerá mais com um pesadelo caótico, cheio de feudos de fabricantes concorrentes e de tecnologias isoladas por muros – em outras palavras, um retorno à Idade Média do hardware para PC.

Abandonai as esperanças?

O quadro pintado aqui é, de fato, sombrio. Caos. Confusão. Um retrocesso às bizarrias que definiam a computação pessoal antes da ascensão da Microsoft.

No entanto, ainda pode haver esperança no horizonte. O Google pode provar ser um melhor líder da era pós-Microsoft do que predissemos aqui (apesar de seu recente confronto com a China ainda não inspirar muita confiança). Talvez o Google ajude a estabelecer padrões para a apresentação de dados e de conteúdo de aplicações por meio de interfaces centradas na web. Até a mudança para um ecossistema de hardware centrado em um sistema não-Windows poderá se mostrar menos disruptivo do que imaginamos – desde que se mantenha a tendência atual rumo aos aparelhos integrados e tudo-em-um (netbooks, tablet PCs).

Talvez as coisas funcionem bem. Ou talvez – e este é o cenário que consideramos mais provável – a Microsoft continue a cooptar cada tecnologia emergente e de mudança de paradigmas e aumentar sua força de base instalada de Windows para manter as comunidades de software e hardware focadas naquele logo brilhante e colorido. Quem prefere a estabilidade ao caos e a mudanças disruptivas sabe o futuro que quer ter.

Fonte: IDGNow

iPad estreia em todo o mundo em março

A venda dos modelos sem suporte a redes 3G do iPad começa nos Estados Unidos e em um grupo de países selecionados no final de março. Entre estes países, devem estar o Canadá e os membros da União Europeia.

É provável, no entanto, que a estreia dos modelos sem 3G no Brasil aconteça em pouco tempo, já que não há interesse da Apple em retardar a venda de seu novo gadget no mundo.

Mais complicado, no entanto, será a estreia do modelo mais sofisticado do iPad, que suporta redes 3G. Neste caso, as vendas nos Estados Unidos e em um grupo de países selecionados começam em abril. Consumidores no Brasil podem ser obrigados a esperar alguns meses até encontrarem o iPad 3G nas lojas.

De acordo com a Apple, as vendas do dispositivo 3G envolvem uma burocracia maior com homologação e, ainda, possíveis negociações com operadoras. Nos Estados Unidos, um acordo com a AT&T – mesma parceira da estreia do iPhone – foi anunciado.

O cenário mais provável é que negociações com as teles brasileiras atrasem um pouco a venda do produto no Brasil em relação aos Estados Unidos e outros mercados considerados ‘prioritários’.

Críticas

Após o encantamento causado pelo keynote de Steve Jobs ao apresentar o iPad como um produto ‘mágico’ e ‘revolucionário’, uma série de críticas apareceram na internet. A principal delas é a ausência de uma porta USB ou leitor de cartões SD.

Para transferir dados para o iPad, é preciso conectar um cabo como aqueles utilizados em iPhone e iPods – numa ponta, porta de 30 pinos e, em outra, USB 2.0. Um cabo adaptador permitirá conectar diretamente cartões de memória ou a própria câmera digital ao iPad para a transferência exclusiva de fotografias.

Outra crítica é que – ao contrário de um computador – o iPad não é multitarefa, ou seja, o usuário deve executar uma aplicação de cada vez.

Confira as principais características do produto:

– Tela sensível a toque de 9,7 polegadas;

– Versão de 16 gigabytes custará 499 dólares nos Estados Unidos, de 32 GB sairá por 599 dólares, e de 64 GB por 699 dólares;

– Capacidade sem fio 3G custará valor adicional de 130 dólares;

– A operadora AT&T terá um plano de transmissão de dados com preço mensal de 14,99 dólares por 250 MB, outro de 29 dólares para acesso ilimitado;

– Bateria tem duração de 10 horas e de 1 mês em “standby”;

– Espessura de 1,3 centímetro, peso de 680 gramas;

– Conexão WiFi e Bluetooth, permite visualizar informações na tela nos modos horizontal e vertical;

– Opera com um sistema operacional que é uma variação do software do iPhone. Segundo a Apple, todos os aplicativos do iPhone funcionam no iPad;

– Suporta o iWork, pacote de aplicativos da Apple que compete com o Office da Microsoft;

– Equipado com chip A4 de 1GHz da Apple;

– Modelos com WiFi começarão a ser vendidos no final de março e aparelhos com 3G em abril.

Fonte: Plantão Info

Começar a Programar

Antes de começar a programar, é necessário saber algumas noções de programação, e essas noções envolvem principalmente o raciocínio lógico. A programação destina-se a resolver problemas da forma mais simples possível, eliminando processos redundantes e melhorando a obtenção de resultados.

Estrutura da programação

  • Análise do problema (dados de entrada, dados de saída, relações de transformação)
  • Desenvolvimento do algoritmo
  • Codificação na linguagem de programação
  • Execução e testes.

Dados de entrada: dados que são necessários fornecer para que possam ser calculados os dados de saída.

Dados de saída: resultados a obter.

Relações de transformação: relações matemáticas ou de qualquer outra espécie que permitam transformar os dados de entrada nos dados de saída.

Algoritmo: escrita, numa linguagem normalizada, da sequência de operações que definem o problema.

Noções de Algoritmo

Para resolver os problemas em programação, recorreremos à utilização de algoritmos.

E o que é um algoritmo?

Um algoritmo é, nada mais nada menos, do que a sequência de passos a realizar para que possamos chegar à solução de um determinado tipo de problema.

A utilização de algoritmos apenas visa tornar mais fácil a programação, visto que, ao elaborarmos um algoritmo, subdividimos o problema sistematicamente em partes mais pequenas e menos complexas, chegando a um ponto em que compreendemos claramente cada uma das partes.

Assim,podemos indicar sem ambiguidade os passos (algoritmo) para a resolução de problemas:

  • Analisar o problema
  • Conhecer o problema: ouvir o problema, entendê-lo, perceber qual o objetivo
  • Descrever o problema: subdividir o problema (esquematizar), detalhar
  • Resolver o problema: escrever passo-a-passo o raciocínio da solução do problema; verificar se não existe ambiguidade
  • Implementar: esta fase acontece apenas após o problema estar resolvido e consiste em implementar o algoritmo numa linguagem de programação

Linguagens de Programação

Para que um computador produza resultados úteis é necessário indicar as ordens que ele deve obedecer. Essas ordens são uma série de instruções binárias – as únicas instruções que o computador entende, também designadas por código de máquina.

Apesar de ser possível escrever um programa diretamente em código de máquina, dar ordens em número binários é difícil, lento e sujeito a erros. Assim, se desenvolveram linguagens de programação de baixo e alto nível, que são próximas do código de máquina ou da linguagem humana, respectivamente.

É nessas linguagens que são escritos os programas com que os computadores funcionam e que se formam por programas fonte. Assim, uma linguagem de programação é constituída por um conjunto de palavras (ou símbolos) que, colocados segundo determinadas regras, significam operações que o computador deve realizar.

As linguagens de programação têm como função descrever todas as operações a serem efetuadas por um computador, necessárias para se resolver um determinado problema. Desta forma, uma linguagem de programação deve apresentar as seguintes facilidades:

  • Um vocabulário limitado
  • Regras gramaticais simples
  • Ser clara e concisa
  • De aprendizagem simples

Existe uma grande variedade de linguagens de programação:

Linguagens de baixo nível:

  • Linguagem de máquina e linguagens Assembly
  • Vocabulário elementar
  • Processamento de execução rápida
  • Formulação dos problemas extremamente complicada e sujeita a erros

Linguagens de alto nível:

  • BASIC, Fortran, Cobol, C, Pascal, Java, etc.
  • Vocabulário adequado à expressão de grande complexidade
  • Processamento de execução morosa
  • Facilitam a tarefa do programador