WordPress Cache, Hyper Cache, Super Cache, W3 Total Cache

One of these days a customer asked me to improve the performance of his wordpress website. The first thing I’ve done was to measure the actual performance of the site. For that I started to search for firefox and chrome addons. I’ve already knew a few, bur after some googling I found that the usual suspects were enough: Firebug with YSlow and Google Speed Tracer. There were anothers but I couldnt find any reason to use them.

So my first metrics of the web site from the YSlow:

1) Homepage on first call without cache retrieves to client about 1800Kb
2) After first call, the most part of webpage elements stay on browser local cache, like 700Kb of images, 500 of Javascript and CSS and the rest was Html. So, to the client just comes 120Kb. Not bad at all! But not the 100Kb recomended pratice.

So, I want to reduce below the 100kb, and who knows the 1800Kb too, How?
I started to search for a wordpress cache plugin to compress (using http compression, which was one of the recomendations from the performance analysis tools) html, javascript, css. I want the website to respond faster instead of always using the access to the wordpress database to retrieve the same content (the posts arent always changing!). Besides these reasons, its helps for google SEO/rank faster webpage retievals. I found 3 plugins:

  • W3 Total Cache
  • Super Cache
  • Hyper Cache

Apparently the best one was suppose to be W3 Total Cache. Great reviews, very popular, but wih one biggest problem, doesnt work well in WordPress 3.4.x, just works until 3.2.x. Unfortunelly I had to put it aside.
So I had to find which one of the others I will choose.
Both are very similar, but after some search, reading, analysis of performance with cpu and memory charts the Hyper Cache was found the best, more lighty, works great in WordPress 3.4.x and its realy very easy to use, I just had to define Cache on wp-config.php.

So I’ve installed the Hyper Cache Plugin and tested the website performance and the quantity of kbytes transfered to the browser. Well, at first, the length was the same, but after reading the Hyper Cache Help I discovered that when I am logged as wordpress admin, the Hyper Cache its disabled, so any test will be with no use or conclusion. So I started a session with another browser without any website cookies for the site I was using the Cache and at the first test, even the 120Kbytes was reduced to 80Kbytes, and the 1800kb reduced at first attempt to 1600Kbytes (images are images, the wordpress cache cant do anything about it).

I hope this experience can help anyone struggling with ways to improve the wordpress performance in wordpress version 3.4.x.

Gamificação: Mecânica, Estética, História e Tecnologia – Parte II

Num dos meus últimos posts falei da relevância da História na criação de um jogo, seja ele para gamificar um site, criar realmente um jogo ou uma aplicação para um smartphone, tablet ou pc. Hoje irei abordar a Mecânica do Jogo.

chess O que é a Mecânica do Jogo? A mecânica do Jogo são as regras, surpresas, caminhos possiveis, acções, objectivos de vitória, ganhar vidas, conquistar, etc que vemos num jogo. São as restricções e ao mesmo tempo o nosso playground, ou seja, o espaço onde decorre o jogo segundo um conjunto de “regras”. Um exemplo simples: Xadrez! As regras são claras: pode ser jogado por 2 jogadores, um com peças brancas outro com as pretas. Cada jogador tem um conjunto de peças que se movem sob determinadas regras (num tabuleiro de 64 casas brancas e petras), e os seus próprios movimentos por vezes estão constrangidos à posição de outras peças (um peça não se pode mover se isso matar o seu próprio rei), do adversário ou da própria Estética(casas brancas e pretas. Num posto futuro falarei sobre a Estética do Jogo) do tabuleiro. O objectivo é ou dar mate ao rei adversário ou empatar quando não é possivel a vitória.bookstore

Um outro exemplo fora do âmbito dos jogos puros poderá ser um web site.  Uma estratégia para atrair utilizadores a um site gamificado (ou não) é recompensa-los quando estes recomendam alguém e essa pessoa volta ao site. Esta estratégia é por exemplo usada pela Dropbox, que oferece mais X GBytes de espaço quando alguém vem por convite e mais ainda se essa pessoa comprar mais espaço. Vamos supor que o site é sobre compras de livros digitais, também serve para outros produtos, e estou quase a chegar ao nível 2 do site, onde me é dado 5% de desconto permanente, mas para isso preciso de mais 100 pontos que consigo com 10 novos registos de utilizadores no web site que comentem livros pelo menos 1 vez. Além disto, sou reconhecido no site quando atinjo X recomendações sociais! Toda esta descrição faz parte da mecânica do jogo no site, “obriga-me” a trazer clientes, fazendo-me progredir no “Jogo” que por sua vez me traz recompensa pessoal. (Espantoso como a Gamificação faz as coisas andarem para a frente e ajuda o marketing de uma forma sensacional!).

Trazendo de volta o post anterior, qual seria a história para um web site de venda de livros gamificado? Poderia ser contada juntando a missão da empresa na venda dos livros, algo como servir o livro certo para as expectativas dos clientes, e ao mesmo tempo criar “aventuras” sobre determinados temas dos livros para os quais os utilizadores/clientes gostassem de comentar e dar as suas opiniões sobre os mesmos. Possivelmente, o número de comentários, o número de recomendações e o número de comentários bem avaliados seriam possivel fontes de pontos para promoções, descontos, badges, recompensas, etc. Os níveis seriam os descontos, que seriam também rewards ou recompensas, e um leaderboard de especialistas sobre temas no site! (Acho que já entrei demais na estratégia do marketing para um web site, mas foi para o bem da mecânica!).

Se a história é a descrição do mundo do jogo, a mecânica é sem dúvida a criação “física” desse mundo e como podemos “jogar” nele.

 

photo credit: szeke via photopin cc photo credit: EricGjerde via photopin cc

Gamificação: Mecânica, Estética, História e Tecnologia – Parte I

Como é sabido, a Gamificação acenta sobre os mesmos conceitos de um Jogo. Num post anterior falei sobre a experiência que o utilizador final deverá ou irá viver durante e no final do Jogo. A experiência é realmente o factor mais importante para o sucesso de um Jogo, mas não se cria experiência do nada, ou porque sim, ou sem um planeamento devido.Para se chegar à experiência é necessário acentar o desenvolvimento do Jogo sobre um conjunto de blocos que servirão de base para a criação da experiência. Pretendo falar sobre 4 factores que constituiem o desenvolvimento do Jogo: Mecânica, Estética, História e Tecnologia. Hoje falaremos da História.

Todo o jogo deverá ter uma história. Mesmo que o jogo seja algo simples como o Tetris ou puzzles, ou corridas de carros, ou gamificar um site de vendas, há uma histórica. Está histórica não tem que ser contada ao utilizador, pois por vezes é ele que a vai criar, outras vezes continuar, outras vezes descobrir, mas é necessário criar uma linha condutora, um âmbito ao Jogo, tal qual como se faz com um projecto qualquer. O utilizador tem de perceber o que está a fazer e o porquê e acima de tudo ter um contexto. Esse contexto é a história.

Eu lembro-me quando era novo e jogava nas “máquinas” (como se dizia na altura) que existiam em cafés ou salas de jogos (hoje em dia o PC ou Playstation ou Wii, etc, serve perfeitamente!) antes de cada jogo, mesmo o tetris, surgia um pequeno texto a explicar o porquê da existência do jogo, por vezes era salvar uma princesa e por isso tinha que aplicar golpes de karaté sobre os inimigos, outras vezes era libertar um prisioneiro que estava cativo e por isso tinha que resolver puzzles, salta plataformas, entregar encantamentos, etc. Até o jogo Space Invaders, um dos primeiros para os computadores tinha por detrás uma história de aliens que queriam invadir a Terra!

small_1721982928 O utilizador, quando está a jogar, deverá sentir que está a cumprir algo, a viver algo acerca de um acontecimento, ou a provocá-lo. Num post anterior referi a experiência na gamificação e dei como exemplo uma aplicação sobre recuperação de lesões na saúde, aqui está a ser desenvolvida ou a criar uma histórica de uma recuperação na vida de alguém, a histórica da vida do utilizador que está a “Jogar” o jogo (quantos filmes há sobre isto?)!

Quando o Jogo não é assim tão sério, tão pessoal, uma história trás algo misterioso, gera um conjunto de pensamentos na nossa imaginação para “tapar” os buracos que faltam no texto da história, algo como quando estamos a ler um livro.

Assim, o primeiro passo para a inclusão da gamificação num sistema, seja ele um site, uma aplicação para o PC, no local de trabalho, ou outro modelo onde possam ser aplicados conceitos de jogos, deve-se primeiro criar a história, ou descobri-la. Depois contá-la ou introduzi-la ao utilizador (diga-se jogador) e com a ajuda de outros factores (nas seguintes partes deste artigo) desenvolver o jogo!

A História irá ser também um componente muito importante para a criação do Tema do Jogo, mas isso deixo para futuro post.

photo credit: Dunechaser via photopin cc

A Experiência na Gamificação

Um dos factores mais importantes para o sucesso da Gamificação num determinado ambiente, é a experiência.

small_3803517719 Há 2 tipos de experiência, a do Jogo que se está a implementar e a experiência pessoal que se adquire ao jogar o Jogo! A experiência que é o Jogo, é apenas o Jogo e as suas mecânicas, regras, elementos, design, facilidade de utilização e compreensão. Agora a experiência de jogar o Jogo é o que sentimos, antes, durante e depois de uma sessão(ões) no jogo! Para mim, esta última é a mais importante. (Embora não exista sem a primeira, a base!) Vamos ver um exemplo prático. Se for implementado um sistema gamificado que ajuda a ultrapassar problemas de saude, como lesões, doenças prolongadas, etc, (felizmente já há sistemas destes), qual é a experiência mais importante? O jogo e as suas regras, elementos, design, mecânica, ou o que a pessoa sente durante o decurso do Jogo? Eu acredito que será a alegria quando atinge um objectivo como conseguir dar 10 passos, se estava numa fisioterapia para andar após uma lesão grave! Creio que quando a pessoa consegue esse objectivo, motivado, acompanhado e orientado pelo Jogo (provavelmente com uma componente social de pessoas em situações idênticas ou que já estiveram nessas situações), a sua experiência vai ser fenomenal e vai com certeza recomendar o “Jogo” a outras pessoas em situações semelhantes! Não porque o Jogo era desafiante, bem desenhado, equilibrado, fácil de usar, com componente social,  mas sim porque a sua experiência com o Jogo a fez sentir-se muito bem em diversos níveis  e de encontro às suas expectativas, e acima de tudo, o Jogo ajudou-a numa situação real, da vida real, e isto não é mais que o objectivo da Gamificação!

photo credit: thephotographymuse via photopin cc

LinkedIn Recommendations–Do you know the risks?

There are a lot of people asking for recommendation in LinkedIn and other social networks.
My focus will be on LinkedIn, because it’s the most popular business professional network, where many people are trying to gain and increase their “personal brand”.
Although it seems a great way to gain some free “personal brand”, I think the person who will write a recommendation for a friend or colleague must think twice before do it:

Among other questions I will start with:

1) In your professional analysis is it really true what are you writing about your friend?
2) Are you ready to answer about the words you used to recommend your “friend”, to your boss, ex boss, future boss, colleague, friend, etc.?
3) Do you want to be accountable for a future failure of your recommendation just because someone who trusts your judgment accepted it has true?

On LinkedIn it’s not about what people are saying about you, I can value more your value, reading the recommendations written by you, because it reflects your judgments, person analysis, technical and personal soft skills, etc. If you can do a good analysis, probably you know something about the subject you are talking about, and that values you, not the person that you are recommending.
Even being a friend of yours, it’s your reputation in the game, and above all in the the social network, visible to thousands of people, including head hunters and job opportunities.
Sometimes people ask me if I know/recommend someone to a specific job. Sometimes I know someone, sometimes not, but I always try to recommend a person that I know it will do the job, and be careful enough to say what I know about the person and don’t risk to blindly recommend her/him, and in the future be the guy who cant analyze people, who has recommended a failure, that will be my failure. How can I, in the future, present my self as a Team Leader, Project Manager or a Senior if I cant analyze the skills of someone? And, these skills must be not just technical ones, but soft skills too.

So, my “recommendation”: be very honest when you recommend someone on LinkedIn or other social network, because its not about the person who are recommending, but its, above all, the content of your recommendation about that person, which will reflect you as a professional. And it will be your name and your reputation, and your capacity as a business professional.

Don’t jeopardize your future just because he’s a friend.
Sometimes, it’s hard to say no to a friend, he could not understand a friend saying no to a “little help” for is professional life. In that case, I recommend you to be honest, try to focus on things that are really true, and if that friend had to work with you, what role do you think will fit in him? That, I think, it will be the content of your recommendation.

Hope it helps you in the future!

José Cruz

Java Blocks–Advanced–Part 1

Following a previous post I will deep into the discussion about anonymous blocks mixed with static variables.

Lets see a simple example, and then we will complicate a little bit.

public class TestStaticInitializer {

{
System.out.println(“block 1”);
}

public TestStaticInitializer() {
System.out.println(“static x = ” + x);
}

private static int staticInitialization() {

System.out.println(“static initialization of x”);

return 5;
}

{
System.out.println(“block 2”);
}

static int x = staticInitialization();

public static void main(String[] args) {

System.out.println(“static main block before calling the constructor”);

TestStaticInitializer test = new TestStaticInitializer();

System.out.println(“static main block after constructor”);
}

{
System.out.println(“block 3”);
}

}

You can observe that:
– There is a static variable ‘x’ that its initialized calling a static method.
– There are 3 anonymous blocks.
– The constructor calls the static variable.

The main method references the class.

At first sight we can think the anonymous blocks are called in sequence, which it’s true. Although if there is a static variable initialized in anyway, this initialization runs before any anonymous block.(Why? Because a class is loaded in 2 phases: load class, run class. At load the JVM after some verification, initialized every static variable and runs any static anonymous initializer, and only after runs the class, or our instance.)

You can observe this by looking to the execution output:

static initialization of x
static main block before calling the constructor
block 1
block 2
block 3
static x = 5
static main block after constructor

The anonynous blocks are executed by sequence, but the initialization variable “static initialization of x” runs first, although its declaration is after “block 2”.

The sequence is:

1 – Initialize the static variable x

2 – run main method

3 – initialize the class (because I’m calling the constructor)

4 – run anonymous blocks

5 – runs the constructor (only after the static blocks)

6 – runs the other “main” statements.

 

You must be wondering why I underlined “The main method references the class” above.

Lets see if I remove (I will just comment it) the call to the class constructor.

public class TestStaticInitializer {

{
System.out.println(“static block 1”);
}

public TestStaticInitializer() {
System.out.println(“static x = ” + x);
}

private static int staticInitialization() {

System.out.println(“static initialization of x”);

return 5;
}

{
System.out.println(“static block 2”);
}

static int x = staticInitialization();

public static void main(String[] args) {

System.out.println(“static main block before calling the constructor”);

//TestStaticInitializer test = new TestStaticInitializer();

System.out.println(“static main block after constructor”);
}

{
System.out.println(“static block 3”);
}

}

 

and the output is:

static initialization of x
static main block before calling the constructor
static main block after constructor

 

Well, where are the anonymous blocks initializers? Thet are not needed! We haven’t crated any instance of the class, so the JVM just considered the static stuff!

And if a static block references the static variable x?

public class TestStaticInitializer {

{
System.out.println(“block 1”);
x = 7;
System.out.println(“block 1 after x = 7”);
    }

public TestStaticInitializer() {
System.out.println(“static x = ” + x);
}

private static int staticInitialization() {

System.out.println(“static initialization of x”);

return 5;
}

{
System.out.println(“block 2”);
}

static int x = staticInitialization();

public static void main(String[] args) {

System.out.println(“static main block before calling the constructor”);

//TestStaticInitializer test = new TestStaticInitializer();

System.out.println(“static main block after constructor”);
System.out.println(“x = ” + x);
    }

{
System.out.println(“block 3”);
}

}

The output:

static initialization of x
static main block before calling the constructor
static main block after constructor
x = 5

The initialization of “x = 7” in the first anonymous block is simple ignored, because the code was never ran!

static int x;// = staticInitialization();

The output will show you “x = 0”.

 

I hope this post will help you understand the mix between anonymous and static initialization blocks. In a future post I will bring some class hierarchy to this discussion.

 

Anonymous Java Classes and Interfaces

In java you can use Anonymous Classes and Anonymous Interfaces.

Anonymous classes

class MyMessage {
    public void printMessage() {
        System.out.println("Original message");
    }
}

public class TestAnonymousClass {

    public static void main(String[] args) {
        TestAnonymousClass tac = new TestAnonymousClass();

        MyMessage m = new MyMessage();
        m.printMessage();
       
        tac.showGeneralMessage(new MyMessage() {
            public void printMessage() {
                System.out.println("Override message");
            }
        }
);
    }

    void showGeneralMessage(MyMessage msg) {
        msg.printMessage();
    }
}

The Bold source shows how to create the anonymous class. As you can see it’s not so anonymous as we expected, it’s just the name that is anonymous.

In anonymous classes the only think we can do it’s to instantiate an existing class, and override or add some methods.  What are we really doing is extending another class(in our example we are extending “MyMessage”) with the possibility to override or add new methods.

If you run the code above the output will be:

Original message

Override message

 

Anonymous Classes with interfaces

interface MyMessage {
    void printMessage();
}

public class TestAnonymousClass {

    public static void main(String[] args) {
        TestAnonymousClass tac = new TestAnonymousClass();

        tac.showGeneralMessage(new MyMessage() {
            public void printMessage() {
                System.out.println("Override message");
            }
        }
);
    }

    void showGeneralMessage(MyMessage msg) {
        msg.printMessage();
    }
}

Now with interfaces, you can observe that the syntax it’s the same, but we are creating a class by “implementing” the interface MyMessage.

Look that I only changed the MyMessage class to be and interface,  but the remaining code is still the same and works with the same behavior (ok, now the output doesn’t have the “Original Message”, because we don’t have one! We lost it when we changed the class to be an interface.)

Hope it helps you in your projects, to implement callbacks, using swing components to register listeners, etc..

Technorati Tags: ,,,

Windows Live Tags: Anonymous,Java,Classes,Interfaces

WordPress Tags: Anonymous,Java,Classes,Interfaces

Java Initialization Blocks

Java has some features that are not well know from a lot of Java Developers, even developers with 5 and 10 years of Java Experience.As a Oracle/Java trainer I must study all of them to teach my students and prepare them well for the Java Certification.

One of these bot well know features are java Initialization blocks. One of these are blocks runs before the JVM runs any code (at class loader level) and the other one runs at constructor time.

Lets see an example and an explanation:

Instance Block
class MyClass {
    private int x;
    {
         x = 7;
         System.out.println(“This is called inside constructor, just after super(…)”);
     }

     public MyClass() {
         System.out.println(“the constructor”);
     }
}
Static Block
class MyClass {
    private int x;
    public static int y;
    static { 
        y = 7; // y must be static!
        System.out.println(“This is called by class loader before your program runs!”);
        // x = 5; it’s illegal because this is class context and not instance context
    }

    public MyClass() {
        System.out.println(“the constructor”);
    }
}

 

So, there are 2 types of code initialization blocks:

Instance

When we talk about instances we talk about objects, something that was already created and has memory allocated.

The instance code block is executed right after the call to super in any constructor called.

It’s a way to initialize variables in all constructors without write code in any of them, which it’s a great way to organize initialization code, too.

 

Static

Static context it’s called class context too. Everything that is static it’s only visible when we use de class name before the field, method or inner class. (ok, unless we use import static…)

When we talk about classes we are talking about the blueprint or definition of the object. This definition “runs” before the instance is created, so the static initialization block runs before the java interpreter and before any constructor called. So, who runs the static initialization blocks? The class loader of the Java Virtual Machine.

This is the place to initialize ONLY static variables, because they are the only ones that are visible at this time and in this context.

In the future I will post more about not so know java features.

 

Technorati Tags: ,,,,,,,,,
Windows Live Tags: Java,Initialization,Blocks,Instance,Static,constructor,initialize,variables,context,class
WordPress Tags: Java,Initialization,Blocks,Instance,Static,constructor,initialize,variables,context,class

Error starting jBoss inside eclipse

You install jBoss 7. Unzip it to a folder like d:\jboss.

Now install jboss tools 3.3 for eclipse indigo.

When you start the jboss from eclipse (servers tab) you get an error. The console in eclipse doesn’t show any log activity and jboss doesn’t start.

After some research you discover that eclipse cant “talk” with jboss. You can confirm this by reading jboss logs.

You start jboss with standalone.bat and it works.

I got this problem in our dev team, and after some research around I found this solution. It was so simple and at the same time one of that problems that make us thinking about changing to other version or product that I thought it was a good idea to share it.

Possible solution:

1) Go to runtime environment in eclipse options and add jdk runtime environment. Not jre.

2) Make sure that you remove the JRE probably already installed and configured  from eclipse. (really! Remove it from eclipse and just let the jdk as an environment).

3) Now, start jboss from the tab servers. It must work by now.

 

Technorati Tags: ,,,,,
Windows Live Tags: troubleshooting,java,eclipse,j2ee,Error,jboss
WordPress Tags: troubleshooting,java,eclipse,j2ee,Error,jboss

Learning PHP – Step 4 – Statements

In my last post I’ve talked about variables and operators. Now, lets see what can we do with them.

Statement: if

The “if” statement has 3 main forms:



   
       
        Learning PHP – Step 2
   
   
                 $name = "José Cruz";
         $even = 10 % 2;
         $odd = 10 % 3;
         $someValue = $even * 4;
         $ifvar = 1;
        
         // it’s even – simple "if"
         if($even == 0) {
             echo "10 its even!";
         }

         // it’s even – simple "if" with an else
         if($even == 0) {
             echo "10 its even!";
         } else {
             echo "10 its odd! Really?";
         }
        
         // it’s even – complex "if"
         if($even == 0) {
             echo "10 its even!";
         } elseif($ifvar == 1) {
             echo "Althougth true, the first branch has already taken the flow! :(";
         } elseif($ifvar == 2) {
             echo "Just to ensure you understand this construction!";
         } else {
             echo "10 its odd! Really?";
         }
        ?>
   

 

Statement: switch

“switch” it’s a variation of “if”, but for cases where we have some kind of a list of values belonging to a common domain, like: weekdays, months, (1,3,4,5), etc.

The expression inside “switch()” its evaluated and the result will be compared with each of the “case ”. Each “case” can have the “break” statement, which terminates the statement. If its missing, the execution flow goes to the very next “case” (if its valid) until a “break” it’s found.

If a “case ” was not found, then the “default” its used (it it exists).



   
       
        Learning PHP – Step 2
   
   
                $weekday = 1; // assuming a week starts on sunday with value 1
       
        switch($weekday) {
            case 1:
                echo "Sunday";
                break;
            case 2:
                echo "Monday";
                break;
            case 3:
                echo "Tuesday";
                break;
            case 4:
                echo "Wednesday";
                break;
            case 5:
                echo "Thursday";
                break;
            case 6:
                echo "Friday";
                break;
            case 7:
                echo "Saturday";
                break;
            default:
                echo "big mistake1";
        }
        
        
        ?>
   

 

And that’s it!

Next post about loops!

 

Technorati Tags: ,,,,,,,
Windows Live Tags: programming,else,switch,if,php,Statements,expression,break
WordPress Tags: programming,else,switch,if,php,Statements,expression,break

Bad Behavior has blocked 154 access attempts in the last 7 days.

Hyper Smash