Archive

Archive for agosto \30\UTC 2010

Teoria de Maslow

Maslow fora um psicólogo e consultor , ele criou a teoria da motivação de modo que é preciso entender das necessidades humanas, para isso hierarquizou estas necessidades em uma pirâmide para que ficasse clara a hierarquia, as necessidades mais básicas estão na base sendo que as mais elevadas aparecem no topo:

Necessidades fisiológicas: Constituem-se em necessidades básicas como alimentação, sono, descanso, comida e até mesmo sexo.Uma vez satisfeitas estas necessidades básicas nós abandonamos estas preocupações e passamos a nos preocupar com outras coisas.

Necessidades de segurança: É do instinto do ser humano a busca pela segurança, por procurar abrigo, correr do perigo, querer estabilidade. Até mesmo a busca pelo sentido espiritual, como a procura por uma religião se enquadra nesta hierarquia de necessidades.

Necessidades sociais: É a necessidade de boas relações, ter amizade, afeto, amor e se sentir aceito no grupo.

Necessidades de estima: São necessidades na qual é a maneira como o indivíduo se vê e como se sente perante as pessoas, é uma maneira de se auto-avaliar de forma que é preciso conquistar a auto confiança, respeito, ter aprovação social, status e prestígio.

Necessidades de auto-realização: São necessidades que precisam ser satisfeitas de acordo com seu potencial, essa tendência se expressa através do impulso da pessoa tornar-se melhor, tornar-se o melhor que pode ser ou fazer bem feito o que gosta para se sentir realizado.

Fonte:

http://www.site.lidernato.com.br/index.php?option=com_content&view=article&id=13:teoria-de-maslow&catid=7:administracao-privada.

Produtividade

Aumentar a produtividade é produzir cada vez mais e/ou melhor com cada vez menos.

Maneiras de se medir a produtividade:

Produtividade = O que a empresa produz / O que ela consome
Produtividade = Valor produzido / Valor consumido = Valor agregado
Produtividade = Qualidade / Custos
Produtividade = Faturamento / Custos

Como melhorar a produtividade:

Existem duas maneiras de aumentar a produtividade, sendo eles pelo aporte de conhecimento e pelo aporte de capital.

Aporte de capital:
O aporte de capital tem retorno baixo, inseguro e variável, pode ser feito em um curto espaço de tempo e só depende da disponibilidade financeira.

Aporte de conhecimento:
O aporte de conhecimento tem um alto retorno mas de difícil avaliação. O aporte humano é limitado na sua velocidade de aprendizado (ver conceito de potencial mental em Maslow), e da vontade das pessoas de aprender.

Qualidade em uma empresa, os resultados são lentos e graduais, mas definitivo.

Fonte: (Controle da qualidade total) Vicente Falconi campos (baita livro).

Categorias:Qualidade Tags:

Componentes básicos do Flex

Mas tchêêê…

Pessoal, quando tiverem duvidas de como usar alguns dos componentes Flex ai vai um link que contém exemplos básicos.

http://examples.adobe.com/flex3/componentexplorer/explorer.html

Caso não acharem nada que estão procurando ai é só pedir para o pai Google ou me mandar email.
Abraço galeraa.

Categorias:Flex Tags:

Benchmark de Desempenho Flex / ActionScript 3

Arrays e ArrayCollections

Utilizar [ ] ao invés de new na criação de Arrays


// versão lenta: 126ms
var a:Array = new Array();

// versao otimizada: 56ms (125% mais rápido)
var a:Array = [];

Maneira mais rápida para copiar um Array


var copy:Array = array.concat();

Evitar operações em de inserção e remoção em ArrayCollections quando for possível utilizar Array


// versão lenta: 28117ms
var a:ArrayCollection = new ArrayCollection();
for (var i:int = 0; i < 10; i++)
{
    a.addItem(1);
}
                
var l:int = a.length;
for (i = 0; i < l; i++)
{
    a.removeItemAt(l - 1 - i);
}

// versão otimizada: 374ms (7418% mais rápido)
var a:Array = [];
for (var i:int = 0; i < 10; i++)
{
    a.push(1);
}
                
var l:int = a.length;
for (i = 0; i < l; i++)
{
    a.pop();
}

Utilizar a propriedade //source// do ArrayCollection no lugar do método //toArray()// quando não for necessária uma cópia do conteúdo


// versão lenta: 234ms
var a:Array = arrayCollection.toArray();

// versão rápida: 116ms (102% mais rápido)
 var a:Array = arrayCollection.source;

Loops

Salvar o tamanho do array/collection antes de iterar


// Com Array

// versão lenta: 435ms
for (var i:int = 0; i < array.length; i++)
{
    var a:int = array[i];
    var b:int = a;
}

// versão mediana: 304ms (44% mais rápido)
var l:int = array.length;
for (var i:int = 0; i < l; i++)
{
    var a:int = array[i];
    var b:int = a;
}

// versão otimizada: 254ms (72% mais rápido)
for each (var a:int in array)
{
    var b:int = a;
}

// com ArrayCollection

// versão lenta: 10094ms
for each (var a:int in arrayCollection)
{
    var b:int = a;
}

// versão mediana: 9000ms (13% mais rápido)
for (var i:int = 0; i < arrayCollection.length; i++)
{
    var a:int = int(arrayCollection.getItemAt(i));
    var b:int = a;
}

// versão otimizada: 6530ms (56% mais rápido)
var l:int = arrayCollection.length;
for (var i:int = 0; i < l; i++)
{
    var a:int = int(arrayCollection.getItemAt(i));
    var b:int = a;
}

Não fazer calculos repetidos em loops


// versão lenta: 536ms
for (var i:int = 0; i < 50; i++)
{
    var a:Number = 100 * 180 / Math.PI;
}
                
// versão otimizada: 339ms (58% mais rápido)
var toRad:Number = 180 / Math.PI;
for (var i:int = 0; i < 50; i++)
{
    var a:Number = 100 * toRad;
}


Não fazer acesso a propriedados ou constantes em loops


// versão lenta: 654ms
for (var i:int = 0; i < 100; i++)
{
    var a:int = i + myInt;
}

// versão otimizada: 613ms (7% mais rápido)
var localInt:int = myInt;
for (var i:int = 0; i < 100; i++)
{
    var a:int = i + localInt;
}

Condicionais

Utilizar //if/else// no lugar de //try/catch//


// versão lenta: 1207ms
var s:String = null;
                
try
{
    s = nullBean.myName2;
}
catch (e:Error)
{
    s = "default";
}

// versão rápida: 35ms (3349% mais rápido)
var s:String = null;
                
if (nullBean != null)
{
    s = nullBean.myName2;
}
else
{
    s = "default";
}

Para comparação de inteiros utilizar switch/case no lugar de if/else


// versão lenta: 54ms
var s:int = 0;
                
if (s == 1)
{
}
else if (s == 2)
{
}
else if (s == 3)
{
}
else
{
    var i:int = 0;
}

// versão rápida: 49ms (10% mais rápido)
var s:int = 0;
switch (s)
{
    case 1:
    break;
                    
    case 2:
    break;
                    
    case 3:
    break;
                    
    default:
        var i:int = 0;
    break;
}

UI

Evitar Repeaters

Evitar chamadas ao setStyle()

Usar o mínimo de containers possível

Utilizar posicionamento e dimensionamento absoluto sempre que possível

Utilizar //visible=false// no lugar de //alpha = 0//

Outros

Não usar new para criar Object


// versão lenta: 63ms
var o:Object = new Object();

// versão otimizada: 55ms (15% mais rápido)
var o:Object = {};

Criar método de reflexao próprio


// versão lenta: 164ms
var c:Class = Class(getDefinitionByName(getQualifiedClassName(myBean)));

// versão otimizada: 45ms (264% mais rápido)
public class MyBean {
  public function getClass():Class {
    return MyBean;
  }
}
...
var c:Class = myBean.getClass();

Utilizar atributos públicos no lugar de get/set nos VOs


// versão lenta: 64ms
public class MyBean {
  private var _myName:String;

  public function get myName():String {
    return _myName;
  }

  public function set myName(value:String):void
  {
    _myName = value;
  }
}
...
myBean.myName = "Alison";
var a:String =  myBean.myName;

// versão otimizada: 32ms (100% mais rápido)
public class MyBean {
  public var myName:String;
}
...
myBean.myName = "Alison";
var a:String =  myBean.myName;

Utilizar objetos tipados ao invés de Object (ou classes dynamic) quando for necessário acessar métodos ou atributos, visto que o Object tem que procurar se a propriedade/método existe.


// versão lenta: 63ms
var o:Object = array;
var l:int = o.lenght;

//versão rápida: 61ms (4% mais rápido)
var o:Array = array;
var l:int = o.lenght;


Referências

http://www.insideria.com/2009/04/51-actionscript-30-and-flex-op.html

http://www.rozengain.com/blog/2007/05/01/some-actionscript-30-optimizations/

http://www.lostinactionscript.com/blog/index.php/2008/09/28/tips-on-how-to-write-efficient-as3/

http://www.danielhai.com/blog/?p=55

http://www.adobe.com/livedocs/flashlite/2/main/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Parts&file=00000089.html

Categorias:Desempenho, Flex Tags:,

Não tenho tempo para conquistar meus sonhos

É amigo…

Você já sonhou com a abertura de sua própria empresa, a criação de um produto para a internet ou simplesmente ensaiou criar um blog sobre programação ou qualquer outro assunto de seu interesse? Se a resposta para essas perguntas, ou para uma similar a essas, for afirmativa, espero que você já tenha iniciado algum plano para atingir a sua meta. Caso contrário, por que ainda não começou a trabalhar para conquistar o seu sonho?

Leia mais…

Categorias:Artigo Tags:

Participem do SCA 2010!

II SIMPÓSIO DE COMPUTAÇÃO APLICADA – SCA – 2010

OBJETIVO

Divulgar a produção científica nacional nas áreas de computação aplicada à educação, ciências exatas, agricultura e saúde, por meio de um ambiente da troca de experiências e ideias entre profissionais, estudantes e pesquisadores nacionais e estrangeiros.

Período do Evento:
28 de setembro a 01 de outubro de 2010

Período de inscrição:
de 01 de julho a 21 de setembro de 2010

Link do evento.

Não percam o minicurso que ministrarei.

Abraço.

O método equals()

Pois bem, estava eu lá estudando para certificação scjp e achei interessante criar um post sobre o método equals.

A assinatura deste método é:

public boolean equals(Object o)


Integer i = new Integer("10");
Long j = new Long("10");
if( i.equals(j) )
    System.out.println("igual");
else
    System.out.println("diferente");

Resultado: diferente

Comparando instâncias de classes distintas porém iguais:


Integer i = new Integer("10");
Integer j = new Integer("10");
if ( i.equals(j))
    System.out.println("igual");
else
    System.out.println("diferente");

Resultado: igual

São objetos diferente porém tem o mesmo valor.
Vamos testar agora usando o operador ==


Integer i = new Integer("10");
Integer j = new Integer("10");
if (i == j)
    System.out.println("igual");
else
    System.out.println("diferente");

Resultado: diferente

Isso acontece por que (==) testa se os objetos fazem referência para o mesmo objeto na memória.

Agora basta saber o que realmente voçê precisa comparar e optar por um dos operadores de comparação.
Qualquer duvida estou a disposição.
Abraço!

Categorias:Java Tags: