segunda-feira, 26 de maio de 2014

Hello World!

Esse post é mais para apresentar o novo recurso do blog, agora é possível testar os códigos online.
Infelizmente não foi possível fazer isso para todas as linguagens de programação que pretendemos abordar, mas vamos trabalhar melhor nisso.
Esse post vai apresentar o famoso "Hello World" em algumas linguagens diferentes que conseguimos compilar online.
Para realizar a compilação utilizamos o site codepad.

C

#include <stdio.h>

int main(int argc, char ** argv){
    printf("Programando no Aquário\n");
    return 1;
}

C++

#include <iostream>

int main(int argc, char ** argv){
    std::cout << "Programando no Aquário" << std::endl;
}

Python

# -*- coding: utf-8 -*- 
print "Programando no Aquário"

PHP

<?php

echo "Programando no Aquário\n";


Lua

print "Programando no Aquário"

D

import std.stdio;

void main(){
   writefln("Programando no Aquário");
}

Haskell


programando :: IO()
programando = putStrLn "Programando no Aquário"
main = programando


OCaml


print_endline "Programando no Aquário"


Perl


#!/usr/bin/perl 
print "Programando no Aquário"


Scheme


(display "Programando no Aquário")


Tcl


#!/usr/bin/tclsh
 
puts "Programando no Aquário"


Ruby


puts "Programando no Aquário"


Obrigado!
Obrigado codepad!

quinta-feira, 22 de maio de 2014

Classes Anônimas em Java

Em alguns momentos precisamos implementar alguma coisa pequena e simples, de forma “privada” e obedecendo alguma interface já definida, acho que esse é o melhor momento de se utilizar as classes anônimas.
O código abaixo vai utilizar uma classe anônima para implementar a interface Runnable, esta interface pode ser utilizada para definir a ação de uma Thread.
import java.lang.Thread;
import java.lang.Runnable;

public class Blog{

    public static void main(String... args) throws Exception{
        
        Runnable runnable = new Runnable(){
            @Override
            public void run(){
                System.out.println(this.getClass());
            }
        };

        for(int i=0;i<5;i++){
            new Thread(runnable).start();
        }
    }
}

Algo muito interessante das classes anônimas, é que sempre é guardado uma referencia da instância do objeto que a criou, assim é possível acessar essa instância de dentro da classe anônima. Para diferenciar de qual instância o this está se referenciando é utilizado o nome da classe, como no exemplo abaixo.

import java.lang.Runnable;

public class Blog{

    private int cont =0;

    public Blog(){

    }

    public Runnable constroiClasseAnonima(){
        return new Runnable(){
            private int cont = 0;
            @Override
            public void run(){
                System.out.println(
                    this.getClass()+":"+this.cont
                );
                System.out.println(
                    Blog.this.getClass()+":"+Blog.this.cont
                );
                this.cont++;
                Blog.this.cont++;
            }
        };
    }

    public static void main(String... args){
        Blog blog = new Blog();
        for(int i=0;i<5;i++){
            blog.constroiClasseAnonima().run();
        }
    }
   
}

Reparem que a classe anônima teve total acesso aos atributos privados da classe responsável por sua instanciação.
O NetBeans por padrão cria classes anônimas para responder aos eventos gerados por botões implementado a interface ActionListener, de forma semelhante ao exemplo abaixo.

import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JOptionPane;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.FlowLayout;

public class Blog extends JFrame{

    private JButton btOi = new JButton("Diga oi!");

    public Blog(){
        super("Programando no Aquário");
        this.setLayout(new FlowLayout());
        this.add(btOi);
        //ajusta tamanho da janela
        this.pack();
        //posiciona do centro da tela
        this.setLocationRelativeTo(null);
        //finaliza ao fechar janela
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        btOi.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent event){
                Blog.this.dizOiJanela();    
            }
        });

        btOi.addActionListener(new ActionListener(){
            @Override
            public void actionPerformed(ActionEvent event){
                Blog.this.dizOiTerminal();    
            }
        });
    }

    private void dizOiJanela(){
        JOptionPane.showMessageDialog(null,"Olá Mundo!!!");
    }

    private void dizOiTerminal(){
        System.out.println("Olá Mundo!!!");
    }

    public static void main(String... args){
        new Blog().setVisible(true);
    }
   
}

É possível também criar classes anônimas de classes abstratas ou até mesmo concretas, a sintaxe é a mesma só que invés de implementar métodos de uma interface, você terá que implementar métodos abstratos de uma classe abstrata ou sobrescrever métodos de uma classe qualquer.

Segue outro exemplo utilizando Thread, porém desta vez é sobrescrito o método run da própria classe Thread.
import java.lang.Thread;

public class Blog{

    public static void main(String... args) throws Exception{
        
        Thread thread = new Thread(){
            @Override
            public void run(){
                System.out.println(this.getClass());
            }
        };

        thread.start();
    }
}

Obrigado!

sábado, 17 de maio de 2014

Hot Tips: Acessando Atributos de Classes PHP

Deve-se ter atenção ao acessar atributos das classes PHP.

O acesso aos atributos de uma classe PHP por seus métodos deve ser feito utilizando a variável $this que irá indicar que será utilizado o atributo da classe.
Quando não for utilizado o $this, a variável é utilizada no escopo local do método.

//PHP
//Variáveis utilizadas nos métodos estão definidas no escopo local.
class Pessoa{
    public  $nome;
    public  $idade;

    public function getNome(){
        return $nome;
    }

    public function setNome($n){
        $nome = $n;
    }

    public function getIdade(){
        return $idade;
    }

    public function setIdade($i){
        $idade = $i;
    }
}

$pessoa = new Pessoa();

$pessoa->setNome("Arthur");
$pessoa->setIdade(30);

var_dump($pessoa->getNome());
var_dump($pessoa->getIdade());

A saída do var_dump do código acima será:
 NULL 
NULL
Então, para que seja setado e retornado os valores dos atributos da classe, foi utilizado o $this
//PHP
//Utilizando o $this para acessar os atributos da classe Pessoa
class Pessoa{
    public  $nome;
    private $idade;

    public function getNome(){
        return $this->nome;
    }

    public function setNome($n){
        $this->nome = $n;
    }

    public function getIdade(){
        return $this->idade;
    }

    public function setIdade($i){
        $this->idade = $i;
    }
}

$pessoa = new Pessoa();

$pessoa->setNome("Arthur");
$pessoa->setIdade(30);

var_dump($pessoa->getNome());
var_dump($pessoa->getIdade());

Deste modo a saída do var_dump será:
string(6) "Arthur"
int(30)

Obrigado!

quinta-feira, 15 de maio de 2014

Java Reflection

O conceito de reflexão é baseado na ideia de que um programa possa se observar, como se estivesse vendo sua imagem refletida em um espelho. A partir dessa auto observação o programa pode tomar decisões em tempo de execução. Praticamente os dados que representam uma instância conseguem acessar seus meta-dados.

No exemplo abaixo, foi programado em Java um exemplo do uso de reflexão. A classe Blog tem o método toString, que constrói uma String para representar aquela instância, porém o conhecimento sobre os campos daquela classe foi necessário na escrita do código. Já no método main, é construído uma String igual a gerada pelo método toString, porém utilizando reflexão.

import java.lang.reflect.*;

public class Blog{

    private String name = "Programando no Aquário";

    public String getName(){
        return this.name;
    }

    public void setName(String name){
        this.name = name;
    }

    public String toString(){
        return "Blog{name="+this.name+"}";
    }
    
    public static void main(String... args) throws Exception{
        Blog b = new Blog();
        System.out.println(b);
        Class clazz = b.getClass();
        String className = clazz.getSimpleName();
        String toString = className+'{';
        for(Field field : clazz.getDeclaredFields()){
            toString += field.getName()+'='+field.get(b);
        }
        toString += '}';
        System.out.println(toString);
    }
}

Além de acessar atributos dos objetos, também é possível invocar métodos ou até mesmo instanciar os objetos. No exemplo acima é utilizado reflection para acessar um atributo privado, isso deve ser feito com cautela, o código acima só funciona pois o método main pertence a classe Blog, logo ele tem acesso aos atributos privados, caso contrario seria disparado uma exceção.

Caso seja necessário acessar atributos ou métodos teoricamente inacessíveis, é necessário utilizar um método chamado setAccessible, cuidado com sua utilização a final os atributos é métodos não foram feitos privados atoa.

No exemplo abaixo foi criada uma classe que sobrescreve o método toString da classe Object. Utilizando reflection o método toString cria uma String com a representação da instância do objeto independente de seu tipo.

//ToString.java
import java.lang.reflect.*;

public class ToString {

    public String toString(){
        StringBuilder sb = new StringBuilder();
        Class myClass = this.getClass();
        sb.append(myClass.getSimpleName()).append('{');
        Field[] fields = myClass.getDeclaredFields();
        AccessibleObject.setAccessible(fields,true);
        if(fields.length != 0)
            fieldToString(fields[0],sb);
        for(int i=1;i<fields.length;i++){
            sb.append(',');
            fieldToString(fields[i],sb);
        }
        sb.append('}');
        return sb.toString();
    }

    private StringBuilder fieldToString(Field f,StringBuilder sb){
        try{
            Object value = f.get(this);
            String name = f.getName();
            return sb.append(name).append('=').append(value);    
        }
        catch(Exception ex){
            return null;
        }
    }
    
}

Agora qualquer classe que herdar ToString, terá por padrão um método toString que realmente apresenta seus valores.

//Blog.java
import java.lang.reflect.*;

public class Blog extends ToString{

    private String name = "Programando no Aquário";
    private String post = "Reflection Java";
    protected String protegida = "Variavel Protegida";
    public String publica = "Variavel Publica";

    public String getName(){
        return this.name;
    }

    public void setName(String name){
        this.name = name;
    }

    public static void main(String... args) throws Exception{
        System.out.println(new Blog().toString());
    }
}


Exitem muitos outros recursos oferecidos pelo uso de reflection, para ir até o fundo da toca do coelho, recomendo o estudo da própria documentação do Java.

Obrigado!

terça-feira, 13 de maio de 2014

Simulando Objetos em C

Como a maioria já sabe, a linguagem C não é uma linguagem orientada o objeto, por isso o máximo que vou conseguir demonstrar é um jeito de simular a instância de um objeto.

Para o melhor entendimento deste post, é necessário que o leitor já tenha algum conhecimento sobre ponteiro de funções, caso não tenha existe um post no blog sobre isso.

O exemplo abaixo, irá criar uma estrutura de dados (struct) que conterá ponteiros para funções. Essa estrutura será utilizada semelhantemente a uma interface em alguma linguagem orientada a objeto, ou seja, existe conhecimento de que métodos ela implementa, mas nenhum conhecimento de como é implementado.

//C
#include <stdio.h>
#include <stdlib.h>

int _soma_padrao(int a,int b){
    return a + b;
}

int _subtrai_padrao(int a,int b){
    return a - b;
}

int _soma_debug(int a,int b){
    int soma = a + b;
    printf("SOMA %d + %d = %d\n",a,b,soma);
    return soma;
}

int _subtrai_debug(int a,int b){
    int sub = a - b;
    printf("SUBTRAI %d + %d = %d\n",a,b,sub);
    return sub;
}

typedef struct{
    int (*soma)(int,int);
    int (*subtrai)(int,int);
} calculadora;

void constroiCalculadoraPadrao(calculadora * calc){
    calc->soma = _soma_padrao;
    calc->subtrai = _subtrai_padrao;
}

void constroiCalculadoraDebug(calculadora * calc){
    calc->soma = _soma_debug;
    calc->subtrai = _subtrai_debug;
}

int main(int argc,char ** argv){
    calculadora calc;

    constroiCalculadoraPadrao(&calc);
    printf("%d\n",calc.soma(2,4));
    printf("%d\n",calc.subtrai(8,7));

    constroiCalculadoraDebug(&calc);
    printf("%d\n",calc.soma(2,4));
    printf("%d\n",calc.subtrai(8,7));

}

Porém desta maneira os métodos da estrutura não tem conhecimento da estrutura, impossibilitando o uso de atributos. Umas das maneiras de se contornar esse problema, é a criação de métodos que recebem por parâmetro a estrutura, podendo assim utilizar os dados dela.
//C
#include <stdio.h>
#include <stdlib.h>

struct calculadora;

typedef struct{
    int ultimoResultado;
    int (*soma)(void*,int,int);
    int (*subtrai)(void*,int,int);
    void (*imprimeResultado)(void*);
} calculadora;

int _soma_padrao(calculadora * this,int a,int b){
    this->ultimoResultado = a + b;
    return this->ultimoResultado;
}

int _subtrai_padrao(calculadora * this,int a,int b){
    this->ultimoResultado = a - b;
    return this->ultimoResultado;
}

int _soma_debug(calculadora * this,int a,int b){
    this->ultimoResultado = a + b;
    printf("SOMA %d + %d = %d\n",a,b,this->ultimoResultado);
    return this->ultimoResultado;
}

int _subtrai_debug(calculadora * this,int a,int b){
    this->ultimoResultado = a - b;
    printf("SUBTRAI %d + %d = %d\n",a,b,this->ultimoResultado);
    return this->ultimoResultado;
}

void _imprime_resultado(calculadora * this){
    printf("Ultimo Resultado %d\n",this->ultimoResultado);
}

void constroiCalculadoraPadrao(calculadora * calc){
    calc->ultimoResultado = 0;
    calc->soma = _soma_padrao;
    calc->subtrai = _subtrai_padrao;
    calc->imprimeResultado = _imprime_resultado;
}

void constroiCalculadoraDebug(calculadora * calc){
    calc->ultimoResultado = 0;
    calc->soma = _soma_debug;
    calc->subtrai = _subtrai_debug;
    calc->imprimeResultado = _imprime_resultado;
}

int main(int argc,char ** argv){
    calculadora calc;

    constroiCalculadoraPadrao(&calc);
    printf("%d\n",calc.soma(&calc,2,4));
    calc.imprimeResultado(&calc);
    printf("%d\n",calc.subtrai(&calc,8,7));
    calc.imprimeResultado(&calc);

    constroiCalculadoraDebug(&calc);
    printf("%d\n",calc.soma(&calc,2,4));
    calc.imprimeResultado(&calc);
    printf("%d\n",calc.subtrai(&calc,8,7));
    calc.imprimeResultado(&calc);
}


O exemplo acima utiliza métodos que recebem por parâmetro a instância do "objeto", podendo assim acessar seus dados.

Obrigado!

domingo, 11 de maio de 2014

Ponteiro de void

Com programação orientada a objeto, conseguimos colocar qualquer tipo de instância em alguma variável do tipo objeto ou de alguma classe pai desta instância. Então se criarmos uma lista de objetos, seria possível adicionar qualquer tipo de objeto nesta lista. Com isso é possível reaproveitar melhor o código de uma lista, a final ela poderia ser usada em qualquer lugar.

No caso da linguagem C que não é um linguagem orientada a objeto, se torna um pouco mais complicado reaproveitar o código de uma lista. Mas sim é possível!

O tipo void que é utilizado para definir o retorno vazio de uma função, pode ter uma utilidade a mais. Void sozinho realmente significa vazio, porém um ponteiro para void não aponta para vazio, mas sim para qualquer coisa.
No exemplo abaixo a variável p que é um ponteiro para void, é utilizada para apontar para um tipo float e um tipo int.
//C
#include <stdio.h>
#include <stdlib.h>

int main(int argc,char ** argv){
    void * p;
    int valorInteiro;
    float valorReal;
    
    valorInteiro = 10;
    valorReal = 10.10f;
    
    p = &valorInteiro;
    printf("Valor Inteiro %d\n",*((int*)p));
    valorInteiro = *((int*)p);

    p = &valorReal;
    printf("Valor Real %f\n",*((float*)p));
    valorReal = *((float*)p);
}
Observe bem o uso de casting!
Como p pode apontar para qualquer coisa, o compilador não sabe como tratar os dados que estão nele, sendo necessário sempre fazer a conversão para o tipo correto.

Para exemplificar melhor o reúso de código, o exemplo abaixo contem a implementação de uma pilha com ponteiro de void, assim essa pilha pode armazenar qualquer tipo de dados.
//C
#include <stdio.h>
#include <stdlib.h>

typedef struct{
    void * data;
    void * next;
} stack_node;

typedef struct{
    unsigned int size;
    stack_node * node;
} stack;

stack * makeStack(){
    stack * s = NULL;
    s = (stack*)malloc(sizeof(stack));
    s->size = 0;
    s->node = NULL;
    return s;
}

void push(stack * s,void * data){
    stack_node * node;
    node = (stack_node*)malloc(sizeof(stack_node));
    node->data = data;
    node->next = s->node;
    s->node = node;
    s->size += 1;
}

void * pop(stack * s){
    void * val;
    stack_node * node;
    val = s->node->data;
    node = s->node;
    s->node = s->node->next;
    s->size -= 1;
    free(node);
    return val;
}

void * top(stack * s){
    if(s->node == NULL)
        return NULL;
    return s->node->data;
}

void clear(stack * s){
    stack_node * node;
    s->size = 0;
    while(s->node != NULL){
        node = s->node;
        s->node = s->node->next;
        free(node);
    }
}

int main(int argc,char ** argv){
    int i;
    int val[5] = {12,1,-5,7,13};
    stack * s = makeStack();
    printf("stack size %d\n",s->size);
    for(i=0;i<5;i++){
        printf("size %d\n",s->size);
        printf("push %d\n",*(val+i));
        push(s,(void*)(val+i));
        printf("top %d\n",*((int*)top(s)));
    }
    for(i=0;i<5;i++){
        printf("size %d\n",s->size);
        printf("top %d\n",*((int*)top(s)));   
        printf("pop %d\n",*((int*)pop(s)));
    }
    printf("stack size %d\n",s->size);
    clear(s);
    free(s);
}
A mesma pilha pode armazenar valores heterogêneos, ponteiros para inteiros, ponteiros para reais, strings e muito mais.
Obrigado!

sábado, 10 de maio de 2014

Quantidade Argumentos Variável Reticências (...)

Quando comecei a programar, sempre ficava curioso para saber como a funções é métodos nativos funcionavam. Como que o printf do C recebe infinitos parâmetros? como posso fazer isso nas minhas funções?
Procurando um pouco descobri o uso de reticencias (...)

No caso da linguagem C é necessário o uso de algumas funções(va_start,va_end)  de uma biblioteca especifica(stdarg.h).
Como em C um vetor (int * v; int v[100]) não armazena o seu próprio tamanho, é necessário que a função que utilizar ... tenha um modo de saber a quantidade dos argumentos.
Por exemplo o printf(const char * format,...) utiliza a string de formatação para saber quantos argumentos são recebidos.

//C
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

//necessario sempre ter um parametro antes dos ...
void reticencias(int tamanho,...){
    int i;
    char * str;
    va_list tresPontos;
    //va_start precisa do primero parametro da função
    va_start(tresPontos,tamanho);
    for(i=0;i < tamanho;i++){
        //va_arg (argumentos,tipo do argumento)
        str=va_arg(tresPontos,char*);
        printf("%s\n",str);
    }
    va_end(tresPontos);
}

int main(int argc, char ** argv){
    const char * const str1 = "teste";
    const char * const str2 = "outro teste";
    const char * const str3 = "programando do aquário";
    reticencias(3,str1,str2,str3);
}

Em Java a utilização do ... é bem mais simples.
public class Blog{

    //o ... pode ser usado no main
    //o método main recebe sempre um vetor de String
    public static void main(String... args){
        // não a diferença de tipo entre String... e String[]
        String[] vetorDeString = args;
        //chamada do metodo com varios argumetos
        print("teste","outro teste","programando no aquário");
        //camada do metodo passando um vetor
        print(new String[]{
            "teste",
            "outro teste",
            "programando no aquário"
            });
    }

    public static void print(String... palavras){
        for(String palavra: palavras){
            System.out.println(palavra);
        }
    }

}
Porém um método que em sua assinatura usa String[] não recebe vários argumentos, mas sim, um vetor de String.
Obrigado!

sexta-feira, 9 de maio de 2014

Ponteiro de Função (Função Callback)

Muita gente não gosta muito de trabalhar com ponteiros, confunde, é complicado e fácil de fazer alguma besteira. Porém uma linguagem que consegue trabalhar com ponteiros normalmente se torna bem poderosa.

"Com grandes poderes vem Grandes Responsabilidades" Ben Parker

Espero que quem esteja lendo já conheça  um pouco sobre ponteiros.

As variáveis e as funções na maioria dos casos estão armazenados na mesma memória.
Se conseguimos criar apontamentos para endereços de variáveis, por que não criar para funções também?


//c
#include <stdio.h>
#include <stdlib.h>

int sub(int a,int b){
    int r = a - b;
    printf("%d - %d = %d\n",a,b,r);
    return r;
}

int soma(int a,int b){
    int r = a + b;
    printf("%d + %d = %d\n",a,b,r);
    return r;
}


int main(int argc, char ** argv){
    int a,b;
    //variavel op é um ponteiro de função
    //a função necessariamente tem que retornar um inteiro
    // e receber como parâmetro dois inteiros
    int (*op)(int,int);
    a = 7;
    b = 4;
    soma(a,b);
    sub(a,b);
    // op  recebe o endereço da função soma
    // repare que não utiliza & e nem ()
    // se fosse utilizado o () a função
    // seria chamada retornando um inteiro
    op = soma;
    //chama soma utilizando op
    op(a,b);
    op = sub;
    //chama sub utilizando op
    op(a,b);
}

No exemplo acima é criado duas funções (sub;soma) para serem apontadas. A variável op (operação) é do tipo ponteiro, no caso ponteiro para função, podendo receber os endereços das funções!

Algumas bibliotecas utilizam ponteiros de funções para pedir ao usuário da biblioteca (provavelmente um programador) uma função que deve ser chamada quando algo ocorrer, como se fosse o aviso de um determinado evento.

Obrigado!

quinta-feira, 8 de maio de 2014

Sobrecarga de Métodos no PHP



Sobrecarga de métodos é um recurso muito interessante. É possível mudar o comportamento do método a partir da quantidade e tipos de parâmetro. Em varias linguagens a assinatura de um método (sua identificação unica) é composta pelo seu nome e argumentos, assim é possível diferenciar qual método chamar somente pelo seus argumentos. 
//Java
public class Blog{
    public diz(){
        System.out.println("Olá Mundo");  
    }

    public diz(String frase){
        System.out.println(frase);
    }

    public static void main(String... args){
        Blog b = new Blog();
        b.diz();
        b.diz("Uma Frase Qualquer");
    }
}
Neste simples exemplo a diferenciação do método foi feita praticamente pelo número de argumentos, que não é  muito diferente do que definir valores padrões no PHP.
<?php
class Blog{
    public function diz($frase = 'Olá Mundo'){
        echo $frase;
    }
}

$b = new Blog();
$b->diz();
$b->diz("Uma Frase Qualquer");
O problema começa quando precisamos nos preocupar com o tipo do argumento,em uma linguagem tipada é possível que o compilador detecte os tipos dos parâmetros e realize a distinção dos métodos, mas isso se torna complexo no PHP.

//Java
public class Blog{
    public String dobrar(String frase){
        return frase + frase;
    }

    public int dobrar(int val){
        return val * 2;
    }

    public static void main(String... args){
        Blog b = new Blog();
        b.dobrar("2");
        b.dobrar(2);
    }
}

No exemplo acima os métodos tem o mesmo nome, sendo necessário utilizar os tipos para a diferenciação dos métodos. Infelizmente a unica solução que eu encontrei para fazer a sobrecarga de métodos em PHP é fazendo os testes dos argumentos eu mesmo. Esses testes podem ser auxiliados por duas funções do PHP, func_get_arg, func_get_args e func_num_args.


<?php
class Blog{
    public function dobrar(){
        if(func_num_args() != 1)
            throw new Exception("dobrar com argumentos invalidos");
        $args = func_get_args();
        if(is_int($args[0])){
            return $args[0] * 2;
        }
        else if(is_string($args[0])){
            return $args[0].$args[0];
        }
        else{
            throw new Exception("dobrar com argumentos invalidos");
        }
    }
}

$b = new Blog();
$b->dobrar('2');
$b->dobrar(2);
E assim é possível simular sobrecarga de métodos em PHP.
Obrigado!

quarta-feira, 7 de maio de 2014

PHP Dinâmico



Praticamente tudo no PHP é texto, até valores que as vezes não queremos que seja texto.
Mas pensando bem o código é texto, então poderíamos criar código(texto) no PHP em tempo de execução!

Um exemplo simples disso pode ser mostrado com a função eval.
<?php
    $a = 10;
    $b = 5;
    eval(' $c = $a + $b;');
    var_dump($c);

Mas a dinamicidade do PHP não para por ai!
É possível também invocar métodos de forma dinâmica.

<?php
    class MyClass{
        public function myMethod(){
            echo 'Olá';
        }
    }

    //forma bem comum de utilização
    $instance = new MyClass();
    $instance->myMethod();

    //utilizando texto
    $className = 'MyClass';
    $methodName = 'myMethod';
    $textInstance = new $className();
    $textInstance->$methodName();

    // pode ser colocado {} para "melhorar" a vizualização
    $textInstance->{$methodName}();

Acredito que seja muito útil conseguir chamar métodos dessa forma.
É possível fazer uma tradução da URL requisitada para alguma classe ou método especifico.

Pensando que essa dinamicidade só é possível porque o PHP é uma linguagem interpretada?
Algumas linguagens compiladas também fornecem meios para isso, normalmente utilizando Reflection que funciona um pouco diferente, inclusive o próprio PHP possui classes para utilizar Reflection.
Mas vamos deixar Reflection para um outro dia!
Obrigado!