Claudiu Persoiu

Blog-ul lui Claudiu Persoiu


Archive for the ‘PHP’ tag

Magento native stack trace

with 5 comments

Exista momente cand ai nevoie sa vezi stack trace-ul, sa stii cum ai ajuns pana la un anumit punct. PHP are doua functii native pentru a realiza acest lucru: debug_backtrace() si debug_print_backtrace. Prima intoarce un array iar a doua afisaza stacktrace-ul pe ecran.

Problema in sine este ca acestea trebuie customizate pentru Magento, pentru ca este foarte posibil cand rulezi debug_backtrace() sa ramai fara memorie inainte sa poti trimite rezultatul catre un fisier de log.

Magento are o functie nativa pentru acest lucru: Varien_Debug::backtrace([bool $return = false], [bool $html = true], [bool $withArgs = true]). Pentru a trimite catre log stacktrace-ul se apeleaza pur si siplu:

Mage::log(Varien_Debug::backtrace(true, false));

Aceasta tehnica este foarte utila in momentul in care vrei sa vezi de unde se initializeaza anumite obiecte si ce metode se ruleaza pana in acel moment.

Written by Claudiu Persoiu

25 February 2012 at 11:48 AM

Posted in Magento,PHP

Tagged with , , ,

PHP 5.4 – Closures asa cum ar trebui!

with 5 comments

Notiunea de Closure, a fost introdusa in PHP 5.3, o data cu o noua sintaxa, “mai traditionala” pentru functiile anonime.

PHP 5.3

In 5.3, un closure se baza pe termenul “use”, care transmite anumite variabile functiei anonime, transformand-o intr-un closure.

Problema este ca functia anonima nu va avea acces decat la variabilele trimise folosind “use”. In cazul obiectelor ele sunt trimise prin referinta, dar in cazul variabilelor scalare (int, string, etc.) acestea se transmit prin valoare, asa cum face implicit in PHP 5+:

$scalar = 5;

$closure = function () use ($scalar) {
     return 'Scalar: ' . $scalar . PHP_EOL;
};

echo $closure(); // Scalar: 5

$scalar = 7;

echo $closure(); // Scalar: 5

O alta problema este ca nu se pot trimite $this in cadrul obiectelor, deci doar proprietatile sau metodele care sunt publice nu pot fi accesate de closure.

PHP 5.4

In PHP 5.4 folosirea cuvantului “use” este optionala, iar tot mediul in care functia anonima a fost creata este disponibil in interiorul functiei.

Avantajul este ca atunci cand functia anonima este generata in interiorul unei alte functii, sau a unei metode, functia anonima va putea accesa mediul in care aceasta a fost creata chiar si dupa terminarea executiei acestuia. Obiectele din mediul creat se vor dezaloca de abea dupa ce se ultima referinta catre closure se va sterge:

class testClass {

        private $changeableVar = 1;
        private $bigVar;

        public function __construct() {
                // Allocate a big variable so we can see the changes in memory
                $this->bigVar = str_repeat("BigWord", 5000);
        }

        /**
         * O metoda care intoarce un closure
         */
        public function closure() {

                return function () {
                        // Display the value of a private property of the object
                        echo 'Private property: ' . $this->changeableVar.PHP_EOL;

                        // Change the value of a private property of the object
                        $this->changeableVar = 2;
                };
        }

        /**
         * O metoda care afisaza o variabila privata
         */
        public function showChangeableVar() {
                echo 'Private property in method: ' . $this->changeableVar.PHP_EOL;
        }

}

// Memoria inainte sa fie alocat obiectul
echo "Memory: " . memory_get_usage() . PHP_EOL; // Memory: 229896

// Creare obiect
$testObj = new testClass();

// Creare closure
$closure = $testObj->closure();

// Executie closure
$closure(); // Private property: 1

// Afisare valoare curenta a proprietatii private
$testObj->showChangeableVar(); // Private property in method: 2

// Memoria inainte sa fie desalocat obiectul
echo "Memory: ". memory_get_usage() . PHP_EOL; // Memory: 266240

// Dezalocare obiect
unset($testObj);

// Memoria dupa ce a fost dezalocat obiectul, nu este o diferenta mare in memorie
echo "Memory: ". memory_get_usage() . PHP_EOL; // Memory: 266152

// Executie closure dupa ce obiectul in care a fost creata a fost dezalocat
echo $closure(); // Private property: 2

// Dezalocat closure si o data cu el mediul in care a fost generat
unset($closure);

// Memoria dupa ce a fost stearsa ultima referinta catre obiect
echo "Memory: " . memory_get_usage() . PHP_EOL; // Memory: 230416

Callable type hinting

Inca un nou lucru introdus legat de closures introdus in PHP 5.4 este un nou “type hint”: “callable”. De fapt “callable” se refera la orice functie anonima, chiar si la un nou mod de a apela o metoda a unui obiect:

<?php
// O functie care foloseste type hinting
function typeHinting(callable $a) {
     echo $a() . PHP_EOL;
}

// Un closure
$closure = function () {
     return __FUNCTION__;
};

// Apelare functie cu type hinting cu un closure ca argument
typeHinting($closure); // {closure}

class testClass {
     public function testMethod() {
          return __METHOD__;
     }
}

// Un obiect de test
$testObj = new testClass();

// Noua forma de apelare a unei metode dintr-un obiect
$objCallable = array($testObj, 'testMethod');

// Apelare functie type hinting cu noua forma de apelare ca argument
typeHinting($objCallable); // testClass::testMethod

Cred ca de abea acum este momentul sa spunem ca PHP suporta closures cu adevarat!

Written by Claudiu Persoiu

11 February 2012 at 5:10 PM

Posted in PHP

Tagged with , , , ,

Magento dead end – Breadcrumbs

without comments

Intr-una din aventurile mele prin codul Magento, m-am lovit de urmatoarea problema: trebuia sa adaug un link la breadcrumb.

Cum documentatia nu e foarte bogata, dupa putin debug-ing (nu foarte mult), am ajuns in core la Mage_Page_Block_Html_Breadcrumbs.

Metoda este foarte auto-explicativa: addCrumb($crumbName, $crumbInfo, $after = false). Daca tot eram acolo am zis sa arunc un ochi in ea:

function addCrumb($crumbName, $crumbInfo, $after = false)
{
  $this->_prepareArray($crumbInfo, array('label', 'title', 'link', 'first', 'last', 'readonly'));
  if ((!isset($this->_crumbs[$crumbName])) || (!$this->_crumbs[$crumbName]['readonly'])) {
    $this->_crumbs[$crumbName] = $crumbInfo;
  }
  return $this;
}

Ce este interesant este parametul $after, dupa cum se poate observa, desi are chiar si o valoare default, nu se foloseste nicaieri. In rest functia functioneaza asa cum este de asteptat, probabil de asta nu se plange lumea atat de des.

Written by Claudiu Persoiu

3 February 2012 at 10:03 PM

Posted in Magento,PHP

Tagged with ,

Closures si functii lambda in PHP vs. JavaScript

with 2 comments

JavaScript si PHP suporta atat functii lambda cat si closures. Dar termenii sunt putin intelesi in ambele libaje de programare si de multe ori sunt confundati.

Functii Lambda

Mai sunt numite si functii anonime. Acestea se refera la functii care pot fi apelate fara sa fie neaparat legate de un identificator. Unul din scopurile lor este de a fi pasate ca argumente. Numele de Lambda li se trage de la Alonzo Church, inventatorul lambda calculus in 1936. In lambda calculus toate functiile sunt anonime.

JavaScript

In JavaScript functiile lambda fac parte din setul de baza si reprezinta metoda preferata de creare a unei functii.

De exemplu:

var add = function (a, b) {
     return a + b;
}
alert(add(1, 2)); // 3

Functiile lambda sunt folosite aproape in orice context cand vine vorba de JavaScript, un exemplu este:

window.onload = function (e) {
     alert('Pagina s-a incarcat!');
}

PHP

In PHP, functiile lambda au fost introduse de la versiune 4.0.1 folosind create_function. In versiunea 5.3+ a fost adaugata si sintaxa similara cu JavaScript, un mod mult mai lizibil si elegant de a definii o functie.

Asta inseamna ca in PHP exista doua moduri de a genera o functie lambda:

// PHP 4.0.1+
$add = create_function('$a, $b', 'return $a + $b;');

// vs.

// PHP 5.3+
$add = function ($a, $b) {
     return $a + $b;
};

echo $add(1,2); // 3

Functiile lambda pot fi folosite ca parametru pentru alte functii, cum ar fi usort:

$array = array(4, 3, 5, 1, 2);
usort($array, function ($a, $b) {
     if ($a == $b) {
          return 0;
     }
     return ($a < $b) ? -1 : 1;
});

Chiar mai mult, PHP 5.3+ permite apelarea unui obiect ca o functie anonima:

class test {
     function __invoke($a) {
          echo $a;
     }
}
$a = new test();
$a('test'); // 'test'

Closures

Notiunea de closure este notiunea cu adevarat neinteleasa dintre cele doua. In general confuzia apare pentru ca implementarea de cloasure poate presupune si functii lambda. Un closure se refera la capacitatea unei functii/obiect de a accesa mediul in care aceasta a fost creat(a) chiar daca executia functiei parinte s-a terminat. Cu alte cuvinte functia/obiectul intors de un cloasure pastreaza mediul in care a fost definita.

In JavaScript notiunea de closure face parte din arsenalul de baza, pentru ca limbajul nu are la baza un model obiectual traditional ci unul bazat pe prototype si functii. Dar JavaScript mai are si cateva reminescente, cum ar fi faptul ca poti folosi “new” pentru a construi un obiect pe baza unei functii care joaca roul de clasa. In PHP este mai degraba o noua posibilitate de abordare a problemelor, PHP facand parte din familia de limbaje cu model obiectual traditional.

JavaScript
In JavaScript notiunea de closure este foarte folosita, iar popularitatea se datoreaza faptului ca JavaScript nu este un limbaj obiectual traditional, ci unul functional, bazat pe mostenire prototype.

In JavaScript nu exista notiunea de Public, Private si Protected, exista doar Public si Private iar obiectele pot mostenii unele de la altele, fara sa foloseasca clase.

O alta problema este mediul (scope), care in mod implicit este cel global. Prin closure aceste probleme pot fi rezolvate intr-un mod elegant:

var closure = function () {
     var sum = 0;
     return {
          add: function (nr) {
               sum += nr;
          },
          getSum: function () {
               return sum;
          }
     }
}();

closure.add(1);
closure.add(2);
console.log(closure.getSum());

In exemplul de mai sus, sum este o proprietate privata iar aceasta teoretic, putea fi accesata si modificata doar din functia closure. Partea interesanta este ca parantezele de la finalul definitiei de functiei semnifica faptul ca aceasta functie se va si executa si deci va intoarce rezultatul care este un obiect. In acest moment functia initiala nu mai exista decat pentru a servi obiectul intors, incapsuland astfel variabila privata.

Desi functia si-a terminat executia, prin intermediu acestul closure obiectul returnat poate accesa variabilele definite in interiorul functiei, pentru ca este mediul in care a fost creeat.

Problema devine mai interesanta atunci cand o functie intoarce o alta functie:

var counter = function () {
    var counter = 0;
    console.log('in closure');
    return function () {
        console.log('in functia anonima');
        return ++counter;
    };
};
var counter1 = counter();

console.log(counter1()); // 1

var counter2 = counter();
console.log(counter2()); // 1
console.log(counter1()); // 2

Output-ul va fi:

in closure
in functia anonima
1
in closure
in functia anonima
1
in functia anonima
2

Ce se intampla de fapt este ca prima functie se executa si intoarce o functie anonima care inca mai poate accesa mediul in care a fost creata. Dupa parerea mea de aici vine confuzia dintre closures si lambda functions, pentru ca o functie intoarce o alta functie.

Diferenta dintre exemple este ca in primul exemplu functia initiala de closure se executa imediat, iar in al doilea exemplu se poate vedea ca atunci cand counter se executa intoarce un rezultat, care este de fapt o definitie de functie, care la randul lui poate fi executata. Evident si acest exemplu poate fi adaptat sa se comporte precum cel precedent folosind paranteze la final.

PHP

Cum spuneam si mai sus, in PHP notiunea de closure nu este la fel de importanta ca in JavaScript.

Daca functiile lambda sunt disponibile in limbaj incepand cu versiunea 4, closure au aparut de abea dupa PHP 5.3+

Datorita mediului (scope) de executie care este de tip block in PHP se realizeaza o incapsulare mai buna dar si mai putin flexibila fata de JavaScript. Practic in PHP trebuie specificat cu ajutorul instructiunii use ce anume va putea accesa functia anonima din closure-ul care si-a terminat executia.

function closure () {
     $c = 0;
     return function ($a) use (&$c) {
          $c += $a;
          echo $a . ', ' . $c . PHP_EOL;
     };
}

$closure = closure();

$closure(1);
$closure(2);

Spre deosebire de JavaScript in PHP nu se pot realiza closure care sa intoarca un obiect, sau mai bine zis obiectul nu poate fi legat de mediul in care a fost creat, decat sa zicem, daca nu se trimit parametrii la constructor prin referinta, metoda nu foarte eleganta care nu vad in ce scenariu ar avea neaparata nevoie de closure.

Ca o paralela la exemplele  de la JavaScript, in loc de parantezele “()” de la finalul functiei, in PHP pentru a executa functia imediat dupa definire se pot folosii call_user_func() sau call_user_func_array():

$closure = call_user_func(function () {
    $c = 0;
    return function ($a) use (&$c) {
        $c += $a;
        echo $a . ', ' . $c . PHP_EOL;

    };
});

$closure(1);
$closure(2);

Written by Claudiu Persoiu

16 April 2011 at 6:02 PM

Parsare fisiere ini in PHP

without comments

De ce fisiere “ini”? Pentru ca sunt mult mai comode! Majoritatea serverelor din lumea *nix au fisiere de configurare de tip “ini” sau “conf”. In lumea PHP preferate sunt fisierele de configurare PHP, care in general sunt array-uri. Nu ar fi mult mai elegant sa fie un fisier ini care sa nu fie imbricat in cod PHP?

Din fericire PHP dispune de doua functii native care pot realiza acest lucru: parse_ini_file si parse_ini_string.

Principiul este foarte simplu, se da un fisier de configurare ini si functia va intoarce un array.

Un mic exemplu:

;config.ini

[simple]
number = 1
another = 2
fraction = 0.2

[escape]
path = /usr/bin/php
url = http://blog.claudiupersoiu.ro
error = '<a href="%path%">%error%</a>'

[array]
1 = a
2 = b
3 = c

Pentru a parsa fisierul anterior:

$config = parse_ini_file('config.ini', true);
var_dump($config);

Parametrul al doilea specifica daca sectiunile vor deveni chei in array. Sincer nu vad in ce moment nu ar fi asta util.

Pare costisitor? De fapt pentru fisierul de mai sus este mai ieftin ca timp sa il parsezi din ini decat sa incluzi un array gata parsat. Diferenta pe calculatorul meu este de ~0.00002.

Dar fisierul de sus nu este tocmai mare, asa ca sa trecem la un fisier ini serios, cum ar fi php.ini. Aici diferenta a fost mai mare in favoarea array-ului care a castigat cu un avantaj de ~0.0003, adica aproximativ jumatate din parsare care a fost ~0.0006.

Avand in vedere ca masina mea este destul de puternica si multe cereri concurente pot adauga un overhead pentru un fisier mare, uneori este util un cache intr-un fisier de configurare.

Din fericire acest lucru este simplu de realizat in PHP.

$cache = var_export($config, true);

file_put_contents('cache/config.php', "<?php\n\$config = " . $cache . ';');

Acum nu mai trebuie inclus decat fisierul cache/config.php si evident regenerat atunci cand fisierul ini este modificat.

PHP trebuie sa aiba drept de scriere in directorul cache.

Written by Claudiu Persoiu

12 March 2011 at 11:38 AM

Posted in PHP

Tagged with , ,

PHP CLI Input/Output de la tastatura, pipe sau argumente

without comments

Undeva in ghidul de certificare exista un capitol dedicat pentru “streams”.

O mica parte din asta reprezinta stream-ul de input, output si cel de eroare din PHP. In C/C++ este faimoasa biblioteca stdio.h, insa putina lume stie ca se poate realiza input de la tastatura si in PHP.

Pe scurt, acest lucru se realizeaza cu PHP://STDIN, PHP://STDOUT si PHP://STDERR.

Ca sa nu fie confuz termenul de stream, subiect care ii panicheaza pe multi care studiaza pentru ZCE, el reprezinta un flux de informatie, la fel cum citesti un fisier inter sau extern folosind fopen.

Dar cum un programator intelege cel mai bine din cod, sa trecem la lucruri mai concrete.

Input

Pentru input se foloseste PHP://STDIN.

Un script care citeste de la tastatura este urmatorul:

#!/usr/bin/php
<?php
// initializare stream de input
$input = fopen('php://stdin', 'r');

// mesaj de intampinare
echo 'Scrie "exit" si apoi enter pentru a termina' . PHP_EOL;

// citire de la stream
while($line = fgets($input, 1024)) {
 // conditie de iesire cu tot cu terminator de rand
 if($line == 'exit' . PHP_EOL) {
    echo 'bye bye' . PHP_EOL;
    break;
 }
 // afisare input citit de la tastatura
 echo 'Ai scris: ' . $line . PHP_EOL;
}

// inchidere stream
fclose($input);

Prima linie din cod este speciala pentru Linux/Unix iar utilizatorii de Windows o pot scoate.
Codul de mai sus trebuie pus intr-un fisier, de exemplu testStream.php

Fisierul trebuie sa aiba drept de executie care se poate da cu:

chmod +x testStream.php

Apoi fisierul poate fi rulat in Linux direct cu:

$./testStream.php

In Windows trebuie sa fie data calea catre PHP daca nu este inclusa in include path:

>c:\php\php.exe testStream.php

Este de remarcat ca inputul este cu tot cu “\n” sau “\r\n” de asta la “exit” se testreaza cu tot cu terminator de linie (PHP_EOL). Folosesc PHP_EOL ca sa poata functiona atat pe Linux/Unix cat si pe Windows.

Output

Pentru output se foloseste PHP://STDOUT.

Dar fata de Input, output-ul este mult mai putin relevant. Practic output-ul este cel standard, care se poate realiza si cu echo sau print.

Dar in scop educational sa modificam fisierul de mai sus sa foloseasca si PHP://STDOUT.

#!/usr/bin/php
<?php
// initializare stream de input
$input = fopen('php://stdin', 'r');

// initializare stream de output
$output = fopen('php://stdout', 'w');

// mesaj de intampinare
fwrite($output, 'Scrie "exit" si apoi enter pentru a termina' . PHP_EOL);

// citire de la stream
while($line = fgets($input, 1024)) {
 // conditie de iesire cu tot cu terminator de rand
 if($line == 'exit' . PHP_EOL) {
    fwrite($output, 'bye bye' . PHP_EOL);
    break;
 }
 // afisare input citit de la tastatura
 fwrite($output, 'Ai scris: ' . $line . PHP_EOL);
}

// inchidere stream input
fclose($input);

// inchidere stream output
fclose($output);

Practic nu este nici o schimbare in script, doar ca output-ul a fost afisat folosind PHP://STDOUT intr-un mod mai explicit.

Eroare

Un subiect mai interesant decat output-ul este stream-ul de eroare.

Practic el este relevant mai mult in mediul linux, probabil este si in windows dar eu nu stiu cum se poate capta. Daca citesti acest blog si sti cum se poate face asta lasa te rog un comentariu.

Si din nou scriptul va fi modificat ca mesajele de eroare sa foloseasca stream-ul corespunzator. Voi face ca de fiecare data cand sunt introduse mai mult de 5 caractere sa fie afisat un mesaj de eroare (imi pare rau dar nu am mai multa inspiratie acum):

#!/usr/bin/php
<?php
// initializare stream de input
$input = fopen('php://stdin', 'r');

// initializare stream de output
$output = fopen('php://stdout', 'w');

// initializare stream de eroare
$err = fopen('php://stderr', 'w');

// mesaj de intampinare
fwrite($output, 'Scrie "exit" si apoi enter pentru a termina' . PHP_EOL);

// citire de la stream
while($line = fgets($input, 1024)) {
 // conditie de iesire cu tot cu terminator de rand
 if($line == 'exit' . PHP_EOL) {
    fwrite($output, 'bye bye' . PHP_EOL);
    break;
 }

 if(strlen($line) > 5) {
    fwrite($err, 'ATENTIE! Inputul mai mare de 5 caractere: ' . $line);
    continue;
 }

 // afisare input citit de la tastatura
 fwrite($output, 'Ai scris: ' . $line . PHP_EOL);
}

// inchidere stream input
fclose($input);

// inchidere stream output
fclose($output);

// inchidere stream eroare
fclose($err);

Implicit in Linux mesajele de eroare sunt afisate pe ecran, dar sunt scenarii cand este mai relevanta trecerea erorilor intr-un log de exemplu.

Pentru ca mesajele de eroare sa fie redirectionate catre fisier log se foloseste 2>> dupa cum urmeaza:

$./testStream 2>>testStream.log

Input din PIPE (|)

Sa luam urmatorul scenariu: Exista rezultatul unei procesari anterioare, care contine o serie de adrese email valide dar si unele invalide. Ar trebuie facute doua fisiere: valid.txt cu adrese valide si unul invalid.txt cu adrese invalide. Adresele valide si invalide vor fi trimise catre script cu pipe.

Lista de adrese va fi simulata prin fisierul email.txt:

valid_addres@yahoo.com
another_valid@yahoo.co.uk
invalid@y.c
good@gmail.com
invalid addres@hotmail.com
foo

Scriptul de procesare va fi emailTest.php:

#!/usr/bin/php
<?php

// initializare stream de input
$input = fopen('php://stdin', 'r');

// initializare stream de eroare
$err = fopen('php://stderr', 'w');

// faza de cazurile anterioare, aici se verifica sfarsitul fisierului
// pentru ca inputul nu se citeste de la tastatura
while(!feof($input)) {
 // fac trim la linie pentru a scapa de eventuali terminatoari de linie
 $line = trim(fgets($input, 1024));

 // testez adresa de email
 if(filter_var($line, FILTER_VALIDATE_EMAIL)) {
    // output-ul se face direct pentru ca acesta este echivalent cu
    // stream de php://stdout
    echo $line . PHP_EOL;
 } else {
    // adresele invalide sunt scrise directionate catre stream-ul de
    // php://stderr pentru a fi interceptate ulterior
    fputs($err, $line . PHP_EOL);
 }
}

// inchidere stream input
fclose($input);

// inchidere stream eroare
fclose($err);

Pentru a testa voi simula output-ul de adrese de email print comanda cat:

cat email.txt |./emailTest.php >valid.txt 2>invalid.txt

Acum fisierele valid.txt si invalid.txt din directorul curent sunt populate cu adresele corespunzatoare.

Procesarea de acest fel este foarte utila cand exista procesari mai complexe. Practic este o alternativa la Shell Scripting (linux) sau Batch Scripting (windows), limbaje care nu sunt la fel de flexibile.

Argumente catre script

De multe ori este util sa trimitem direct argumente catre script pentru a avea functionalitate diferita de exemplu.

Diferenta fata de scenariul anterior ar fi ca numele fisierului cu adrese de mail trebuie sa vina ca argument la script.

Argumentele sunt preluate automat in variabila $argv. Este de remarcat ca de fapt primul element din array, adica $argv[0] este chiar numele scriptului!

Exemplul anterior modificat este:

#!/usr/bin/php
<?php

// numaratoarea incepe de la 1 pentru a elimina numele scriptului
for ($i = 1; $i < count($argv); $i++) {
  // initializare stream de input
  $input = fopen($argv[$i], 'r');

  // initializare stream de eroare
  $err = fopen('php://stderr', 'w');

  if(!$input) {
   continue;
  }

  // faza de cazurile anterioare, aici se verifica sfarsitul fisierului
  // pentru ca inputul nu se citeste de la tastatura
  while(!feof($input)) {
   // fac trim la linie pentru a scapa de eventuali terminatoari de linie
   $line = trim(fgets($input, 1024));

   // testez adresa de email
   if(filter_var($line, FILTER_VALIDATE_EMAIL)) {
     // output-ul se face direct pentru ca acesta este echivalent cu
     // stream de php://stdout
     echo $line . PHP_EOL;
   } else {
     // adresele invalide sunt scrise directionate catre stream-ul de
     // php://stderr pentru a fi interceptate ulterior
     fputs($err, $line . PHP_EOL);
   }
  }

  // inchidere stream input
  fclose($input);

  // inchidere stream eroare
  fclose($err);
}

Pentru a rula fisierul cu argumente:

$./argTest.php email.txt >valid.txt 2>invalid.txt

Written by Claudiu Persoiu

26 February 2011 at 2:35 PM

Posted in PHP

Tagged with , , , ,

100+ certificati PHP ZCE in Romania

with 4 comments

In 2008 cand am dat primul examen de certificare erau 22 de ingineri certificati Zend in Romania, eu am devenit numarul 23.

Cu timpul se pare ca mai multa lume a inceput sa se certifice, iar saptamana aceasta numarul100 a fost depasit!

La o filtrare dupa data certificati ZCE PHP am constatat, plin de bucurie, ca web developer-ul cu numarul 100 certificat din Romania este chiar colegul si prietenul meu Emanuel Croitoru, pe care l-am chinuit saptamani intregi cu indemnul: “nu-ti face griji, e simplu”.

Atunci cand a trebuit sa aprofundeze manualul se pare ca nu era chiar atat de simplu. 🙂

Dar pana la urma, determinarea pentru a face pasul acesta este un argument in plus ca un ZCE se straduieste sa fie un web developer bun!

Written by Claudiu Persoiu

25 February 2011 at 10:38 PM

Posted in PHP

Tagged with , , ,

PHP for Android o prima parere

without comments

Cand vine vorba de Android si PHP s-a scris mult pe tema PHP for Android.

Conceputul este simplu, Google a lansat Android Scripting Environment (ASE).

ASE este asa cum spune si numele, este un mediu de scripting, iar aplicatiile nu sunt compilate si pot fi modificate de catre utilizator in orice moment.

Peste ASE se instaleaza extensii pentru diferite limbaje cum ar fi: Python, LUA, Perl, JavaScript sau JRuby.

Din pacate nu exista suport oficial pentru PHP din partea Google, dar exista PHP for Android, proiect care permite integrarea PHP CLI cu acest mediu.

Instalarea este foarte simpla si se face direct pe mobil. Pentru a dezolta se poate folosi simulatorul din Android SDK.

Una din probleme este ca o aplicatie nu poate fi impachetata ca APK, deci nu poate fi postata pe Android Market.

Practic asta a fost singura problema ridicata pana acum peste tot, problema care nu mi-se pare tocmai mare avand in vedere facilitatile care sunt disponibile in acest mediu.

Am caut aplicatii facute cu PFA, am gasit foarte putine, am gasit de fapt foarte putine si in alte limbaje folosind ASE. De ce nu sunt atat de dornici utilizatorii sa dezolte? Simplu, din mediu de scripting poti accesa foarte multe facilitati de care dispune telefonul, cum ar fi functia de vibratie de exemplu si cam toate felurile de dialoguri. Este totusi un lucru estential care lipseste in totalitate (cel putin la data cand scriu acest blog), nu exista o interfata grafica, cum ar fi orice fel de fereastra care nu este un dialog.

Deci care este scopul sa pui o aplicatie pe Android Market daca nu exista interfata grafica? Nu cred ca este aproape un motiv cu adevarat consistent in acest punct.

Totusi, ce fac utilizatorii in acest mediu atunci? Pai… Cellbots de exemplu. Practic poti face niste jucarii interesante, dar nu te astepta sa poti face aplicatii adevarate (inca). Un alt proiect a fost trimiterea unui NexusOne in spatiu.

Deci proiectul este interesant, dar nu cred ca are scopul de a dezvolta aplicatii traditionale inca.

Written by Claudiu Persoiu

21 August 2010 at 12:26 PM

Posted in Diverse,PHP

Tagged with , ,

CodeIgniter 1.7 Professional Development Packt Publishing – Book review partea 1

without comments

0905.jpg

Packt Publishing a scos o noua carte despre framework-ul PHP de tip RAD, CodeIgniter versiunea 1.7.  Cartea CodeIgniter 1.7 Professional Development scrisa de Adam Griffiths , are sloganul “become CodeIgniter experts with professional tools, techniques and extended libraries”.

Doar din slogan se vede un ton putin diferit fata de cartea CodeIgniter 1.7 de la Packt Publishing care dupa parerea mea avea mai mult scopul de a arata ce poate face framework-ul CodeIgniter.

Aceasta noua cartea are mai mult scopul de a arata cum poti dezvolta aplicatii profesionale, sau cel putin pana la proba contrarie, stay tuned to find out!

Un argument pentru slogan este si target-ul asa cum este definit in “Who this book is written for”, care contine fraza:

Basic knowledge of CodeIgniter will be helpful.

O fraza periculoasa dupa parerea mea, pentru ca poate speria un incepator, chiar daca in carte se pare ca sunt descrisi toti pasii de la instalarea serverului.

Daca de la prima carte ma asteptam la o prezentare generala, acum sunt curios sa vad daca exemplele sunt mai ample si mai concrete.

Din capitoul mostra se poate vedea ca in care este foarte mult cod. Cat timp este logic cred ca este bine, este de multe ori mai usor sa intelegi din cod, pe care oricum il vei scrie si tu si il poti lua drept exemplu, decat teorie.

Dar mai multe despre aceasta carte dupa ce voi avea ocazia sa o lecturez.

Va urma…

Written by Claudiu Persoiu

11 May 2010 at 10:31 PM

Posted in PHP

Tagged with ,

PHP ca limbaj general-purpose

without comments

PHP pentru desktop, merita?

PHP este descris pe Wikipedia ca fiind:

PHP: Hypertext Preprocessor is a widely used, general-purpose scripting language that was originally designed for web development to produce dynamic web pages.

Luand in considerare aceste lucruri, aplicatiile se impart in 3 categorii: web, command line si desktop.

Pentru mediul Web, PHP este cel mai popular limbaj open-source (si nu numai).

PHP CLI

PHP CLI (Command Line Interface) mi se pare foarte interesant, chiar daca este cam putin folosit. Multi prefera shell scripting, sau Perl fara nici un motiv real. Eu pot spune ca m-am jucat cu aceasta facilitate si mi-a placut rezultatul.

Framework-uri importante, cum ar fi Zend, Symfony sau Cake PHP se folosesc de PHP CLI pentru a genera proiecte, CRUD sau pentru alte facilitati care se pot folosi cu usurinta in linie de comanda.

In windows linia de comanda nu este tocmai populara, dar in linux este aproape imperativ. Pana la urma ce rost are sa faci un script in shell scripting daca poti sa folosesti un limbaj puternic si cu foarte multe facilitati cum ar fi PHP?

Dar CLI nu se limiteaza doar la linia de comanda, este de mai multe ori folosit pentru cronjob-uri, pipe-uri, socket-servere etc.

PHP-GTK

Cand vine vorba de php si desktop majoritatea se gandeste la PHP-GTK. Ce cred despre proiect? Nu e mort dupa cum scrie si pe site-ul oficial, dar nu este tocmai viu. Motivul? Gtk nu e tocmai simplu. Daca provi din mediul linux probabil nu e asa de dificil, daca insa ai lucrat mai mult pe web, nu e tocmai html… Cu toate acesta exista o comunitate in spate care inca sustine acest proiect.

Cu toate astea iti permite sa construiesti aplicatii desktop in PHP, compatibile cu o gama larga de sisteme de operare.

Dar este totusi o problema, aplicatiile rezultate nu sunt tocmai cod compilat, acestea trebuie sa ruleze folosind o masina virtuala de PHP.  De aici apare problema, cum distribui aplicatia? Daca ai o aplicatie mica, de cateva randuri, sa o distribui impreuna cu masina virtuala este cam complicat… De asemenea codul este vizibil, evident exista metode de a rezolva aceasta problema, dar asta nu este tocmai simplu.

Aceasta este probabil cea mai populara platforma PHP pentru desktop, daca se poate spune asta despre acesst mediu.

Documentatia, destul de stufoasa a fost preluata de la versiunea pt. C++. Nu este la fel de bine finisata cum e manualul oficial PHP de exemplu, dar cred ca este suficienta.

Winbinder

Fata de PHP-GTK are un dezavantaj, nu merge decat pe sisteme de operare MS Windows. Avantajul este ca are un API mult mai simplu. Daca ar fi sa aleg o platforma PHP pentru desktop, probabil Winbinder ar castga. Din pacate este in aceeasi stare, nu e mort dar nici viu. Si acesta se bucura de sprijinul unei comunitati, dar fara rezultate iesite din comun.

Problema cu codul compilat se regaseste si aici, ba mai mult problema legata de distributia platformei este si ea prezenta. Cred cu fermitate ca daca vrei sa dezvolti o aplicatie folosind aceasta platforma, sa o faci sa mearga pe calculatorul tau este cea mai mica problema, sa o faci sa mearga pe calculatorul altcuiva este adevarata problema…

Documentatia este destul de mica, datorita simplitatii API-ului. Dar simplitatea este buna in programare, iar asta inseamna ca poti cu usurinta sa construiesti aplicatii destul de interesante.

Compilatoare

Nu sunt multe, iar majoritatea au probleme pentru ca folosesc versiuni vechi de PHP sau chiar de GTK. Am petrecut multe ore pe Google incercand sa gasesc niste solutii reale dar in zadar.

Principalele compilatoare sunt:

  • Bambalam – functioneaza pentru CLI si Winbinder fara probleme. Dar are un dezavantaj important: nu este compatibil decat cu PHP 4.4.4, iar asta cred ca spune tot. Oricum mi se pare cea mai interesanta solutie, din pacate prea veche (ultima versiune a aparut in 2006).
  • PriadoBlender – functioneaza bine cu PHP-GTK si CLI, dar este cam instabil. Ultima versiune (beta) a aparut in anul 2007, de atunci nu s-a mai auzit nimic nou. Daca probabil ar mai fi actualizat aceasta versiune ar ajuta mult proiectul PHP-GTK.

Concluzie

Cand vine vorba de Web, totul merge excelent!

PHP in linie de comanda devine tot mai popular si apar tot mai multe unelte!

In mediul desktop este o senzatie de “living dead”… Aceste proiecte nu au murit dar nici nu sunt tocmai in viata. Evident mai sunt si alte solutii PHP pentru desktop pe care nu le-am amintit, dar si ele sunt tot cam in aceeasi situatie. Probabil ar trebui o abordare diferita, mai atractiva pentru dezvoltatorii din mediul web pasionati de acest limbaj.

Written by Claudiu Persoiu

8 May 2010 at 5:00 PM

Posted in PHP

Tagged with , , ,