Programmazione Web » Design pattern

Template engine, smarty, ma sono utili su framework MVC?

neryo — Sun, 01 Mar 2009 13:00:24 +0000

Lo sviluppo web in questi ultimi anni ha introdotto notevoli migliorie sotto l’aspetto di progettazione e programmazione.. si e’ passati da uno sviluppo funzionale ad una programmazione completamente object oriented, si utilizzano ora sempre piu’ pattern di sviluppo basati sul concetto MVC, appoggiandosi a diversi framework php (codeigniter, cakephp, symphony, zend ecc ecc..), ottenendo codice piu’ organizzato e ben strutturato, quindi maggiore controllo e velocita’ di sviluppo, separazione logica ed estensibilita’, uno standard di sviluppo.. insomma molti vantaggi rispetto a quando si creavano files confusi di codice html innestati a query php, cicli e migliaia di controlli sparsi in tutte le pagine con includes di centinaia di funzioni di libreria poco organizzate.. che una volta fatti e poi lasciati nel dimenticatoio, quando bisognava modificarli poi diventava necessario fare un brainstorming per capire la logica con cui erano stati concepiti.. figuriamoci se il codice era sviluppato da qualcun altro che non usava i nostri schemi.

Ora come sappiamo, grazie al pattern MVC e ai framework opensource php si ha modo di organizzare il codice al meglio, separando completamente la logica applicativa dalla parte di modello di accesso ai dati del database e dalla parte di presentazione dei dati sulle viste.

Fino qua tutto bene e vedo solo dei vantaggi che non voglio ripetere, ma parliamo ora del ruolo dei template language.. smarty tpl per citarne uno.. che sono ormai spesso presenti nei CMS di ultima generazione e vengono spesso propinati per rendere la vita piu’ facile a chi progetta interfaccie web… Sinceramente fatico a capire che grossi vantaggi possono offrire questi pseudo linguaggi, che sono nati appunto per rendere la vita piu’ semplice a chi deve mettere le mani sulle viste, tentando di ridurre il gap tra gli sviluppatori, i web designer e i grafici.. questo nell’ottica di team di sviluppo medio grandi dove sono solitamente sono i web designer a mettere le mani sulla parte frontend dei layout.

Questi motori di template, in ambiente PHP così come in altri ambienti, sono delle classi che consentono ai grafici di interagire con il codice sviluppato dai programmatori senza per questo dover acquisire competenze specifiche sul linguaggio di programmazione utilizzato… questo e’ vero se si dimentica che il grafico invece di capire come estrapolare il codice da un array in php tramite un foreach, dovra’ imparare ad usare un linguaggio diverso con costrutti simili (foreach, loop) e non molto piu’ semplici, per poi fare la stessa cosa con un array di dati in smarty.

Quindi nell’ottica di utilizzo di un framework MVC che ha gia’ dentro il concetto di vista e gia’ separa adeguatamente la parte di presentazione dalle query al database e dalla logica applicativa, risulta inutile secondo me appoggiarsi a queste classi, che appesantiscono a livello prestazionale il codice per introdurre un nuovo linguaggio, che ha le medesime difficolta’ dal punto programmativo quando si maneggiano strutture dati semplici come array (ovvero quello che ci dovremmo trovare nelle viste).

Quindi quali sono i vantaggi nello scrivere codice delle viste in tpl? Cambia la sintassi, non sono piu’ semplici e bisogna imparare un nuovo linguaggio, si introducono nuove classi quindi piu’ righe di codice da eseguire rallentando le prestazioni del software e come ripeto se si lavora su framework MVC si ha gia’ una separazione logica delle viste, percui non ha senso neanche per la sepazione della business logic…

Li buttiamo a mare questi tpl?

Progettiamo il software o programmiamo e basta?

neryo — Tue, 05 Aug 2008 20:52:42 +0000

Spesso noi programmatori siamo costretti a lavorare in condizioni esasperate da tempistiche troppo stringenti, richieste e specifiche date all’ultimo minuto e margini di brainstorming ridicoli.

Questo e’ quello che succede in molte aziende dove spesso i project manager (cosi’ amano definirsi), che in alcuni casi non hanno neanche mai seriamente progettato e sviluppato applicazioni, pretendono di vedere i risultati in tempi molto brevi.. magari preferiscono vedere la bozza del software semi funzionante, anche se concepita male, piuttosto che dare agli analisti/sviluppatori tempi adeguati di progettazione e analisi che migliorerebbero inevitabilmente la qualita’ e la stabilita’ finale dei software prodotti.

E’ chiaro a tutti noi che se vengono fornite specifiche complete e precise, e c’e’ il tempo di progettare l’intero ciclo di vita del software, utilizzando pattern validi e magari linguaggi di modellazione, lo sviluppo e la manutenzione del codice sarebbe molto piu’ semplice. Anche uno sviluppatore meno esperto, con queste premesse, riuscirebbe a cimentarsi senza particolari problemi; ma purtroppo non e’ sempre cosi’ e si preferisce programmare e basta, progettare mentre si programma ed inevitabilmente nascono software che non stanno in piedi.

Sara’ la senzazione di risparmio? Sara’ che meglio un uovo oggi che una gallina domani? mah..

Progettare software e’ un investimento, se si vuole fare le cose di fretta e senza riflettere si finisce per buttare via soldi e tempo, oltre a creare un prodotto di scarsa qualita’; poi noi ci troveremo a mettere continuamente mano a progetti pieni di toppe e ripieghi che per sistemare un bug impieghiamo giornate di lavoro!

Un software ben progettato e’ piu’ stabile e architetturalmente espandibile, mantenibile e il costo finale sara’ inferiore.. quindi perche’ non vogliamo attenerci a queste semplice regole?

Framework CodeIgniter guida alla creazione di un blog

neryo — Sat, 15 Mar 2008 17:55:22 +0000

Guida alla creazione di un blog con il framework codeigniter

Ecco a voi un’altro tutorial di sviluppo web, piú complesso rispetto al precedente, utilizzando il framework CodeIgniter. Questa guida é una bozza per la creazione di un semplice blog sfruttando le potenzialitá di questo versatile e potente framework, che come sappiamo stá maturando sempre piú interesse nel mondo dagli sviluppatori del web che credono fermamente nel pattern di sviluppo MVC.

Questo tutorial ha preso spunto quasi interamente dal tutorial di Michael Wales “Live tutorial codeigniter blog”, il quale presenta secondo me alcuni errori e imprecisioni, come ad esempio il non utilizzo delle classi che estendono il Model per fare interfacciarsi al database (pattern MVC), implementate in modo “sporco” direttamente all’interno del controller.
Inoltre ho esteso qualche funzionalitá non implementata come: la visione dei singoli post del blog, i commenti sui post, il logout.. ecc

Come al solito per iniziare a programmare scaricate il pacchetto di codeigniter sul sito ufficiale, al momento giunto alla versione 1.6.1 e scompattate tutto il contenuto dentro la cartella principale del vostro web server (solitamente htdocs), e rinominate la cartella in myblog.

Configurazioni del framework

Dentro la cartella system/application/config apportate le seguenti modifiche di configurazione ai files del framework, facendo particolare attenzione nei paramentri di configurazione del database che potrebbero differire da quelli che vi ho postato. Per capire cosa sono queste variabili consultate i commenti all’interno dei file di configurazione o fate riferimento diretto al manuale ufficiale di codeigniter.

autoload.php

$autoload[‘libraries’] = array(‘database’, ‘session’);
$autoload[‘helper’] = array(‘url’, ‘form’);

config.php:

$config[‘base_url’] = "http://localhost/myblog";
$config[‘log_threshold’] = 1;
$config[‘encryption_key’] = "myblog";
$config[‘sess_cookie_name’] = ‘myblog_sess’;
$config[‘sess_expiration’] = 0;
$config[‘sess_encrypt_cookie’] = TRUE;
$config[‘global_xss_filtering’] = TRUE;
$config[‘compress_output’] = TRUE;

database.php

$db[‘default’][‘hostname’] = "localhost";
$db[‘default’][‘username’] = "root";
$db[‘default’][‘password’] = "";
$db[‘default’][‘database’] = "myblog";

routes.php

$route[‘default_controller’] = "blog";

Creazione del database del nostro blog (myblog)

Questo é il dump del mio database mysql, contenente le query di creazione delle tabelle necessarie e alcuni dati.

SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";
CREATE TABLE `comments` (
`id` smallint(5) UNSIGNED NOT NULL AUTO_INCREMENT,
`post_id` smallint(5) UNSIGNED NOT NULL,
`name` varchar(60) collate latin1_general_ci NOT NULL,
`email` varchar(100) collate latin1_general_ci NOT NULL,
`body` text collate latin1_general_ci NOT NULL,
`created_on` varchar(10) collate latin1_general_ci NOT NULL,
PRIMARY KEY (`id`),
KEY `post_id` (`post_id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci COMMENT=‘Comments on Posts’ AUTO_INCREMENT=1 ;
CREATE TABLE `posts` (
`id` smallint(5) UNSIGNED NOT NULL AUTO_INCREMENT,
`title` varchar(255) collate latin1_general_ci NOT NULL,
`slug` varchar(255) collate latin1_general_ci NOT NULL,
`author_id` smallint(5) UNSIGNED NOT NULL,
`body` text collate latin1_general_ci NOT NULL,
`created_on` varchar(10) collate latin1_general_ci NOT NULL,
PRIMARY KEY (`id`),
KEY `author_id` (`author_id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci COMMENT=‘Blog Posts’ AUTO_INCREMENT=5 ;
INSERT INTO `posts` (`id`, `title`, `slug`, `author_id`, `body`, `created_on`) VALUES
(1, ‘test1′, ‘test1′, 1, ‘test’, ’1205594625′),
(2, ‘test2′, ‘test2′, 1, ‘test2′, ’1205594637′),
(3, ‘test3′, ‘test3′, 1, ‘test3′, ’1205594651′),
(4, ‘test4′, ‘test4′, 1, ‘test4′, ’1205596145′);
CREATE TABLE `users` (
`id` smallint(2) UNSIGNED NOT NULL AUTO_INCREMENT,
`username` varchar(20) collate latin1_general_ci NOT NULL,
`password` varchar(100) collate latin1_general_ci NOT NULL,
`email` varchar(100) collate latin1_general_ci NOT NULL,
`display_name` varchar(40) collate latin1_general_ci NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci COMMENT=‘Registered Users Information’ AUTO_INCREMENT=3 ;
INSERT INTO `users` (`id`, `username`, `password`, `email`, `display_name`) VALUES
(1, ‘admin’, ‘admin’, ”, ”),
(2, ‘test’, ‘test’, ‘test@test.it’, ‘test’);

Importate questo database come preferite, tramite phpmyadmin o tramite la shell di mysql utilizzando il comando source. Vi ho inserito alcuni dati cosí potete subito visualizzare alcuni post e loggarvi e rendervi conto subito del funzionamento dell’applicazione.

Partiamo innanzitutto con il controller principale ovvero la classe blog che come abbiamo settato parte di default al momento dell’avvio di questa applicazione. Questa classe di nome blog.php andrá salvata all’interno di system/application/controllers.

< ?php
if (!defined(‘BASEPATH’)) exit(‘No direct script access allowed’);
class Blog extends Controller {
// costruttore
function Blog() {
parent::Controller(); //richiama il costruttore padre
}
// funzione principale che richiama la vista principale front con la lista dei post
function index() {
// parametri per il titolo del blog
$data[‘title’] = "Questo e’ il mio blog";
$data[‘heading’] = "Header del mio blog";
if ($this->session->userdata(‘logged_in’)) {
$data[‘user’][‘logged_in’] = TRUE;
} else {
$data[‘user’][‘logged_in’] = FALSE;
}
$this->load->database();
$this->load->model(‘blog_model’); // richiamo il modello
$data[‘posts’] = $this->blog_model->get_posts();
$this->load->view(‘blog/front’, $data);
}
// Metodo per visualizzare un post del blog
function article($id = false) {
$this->load->helper(‘url’);
if (!$id) redirect(‘blog’);
$this->load->database();
$this->load->model(‘blog_model’);
$data[‘blog’] = $this->blog_model->get_post($id);
$this->load->view(‘blog/article’, $data);
}
// metodo per l’inserimento di un post nel blog
function write() {
if ($this->session->userdata(‘logged_in’) === FALSE) {
redirect(‘blog’);
}
$this->load->library(‘validation’); // libreria per i controlli sui campi
$rules[‘title’] = ‘trim|required|min_length[3]|max_length[255]‘;
$rules[‘body’] = ‘trim|required’;
$this->validation->set_rules($rules);
$fields[‘title’] = ‘title’;
$fields[‘body’] = ‘body’;
$this->validation->set_fields($fields);
if ($this->validation->run()) { // se tutto e’ valido
$this->load->helper(‘date’);
// array di dati in post
$insert = array(
‘title’ => $this->input->post(‘title’),
‘slug’ => url_title($this->input->post(‘title’)),
‘author_id’ => $this->session->userdata(‘logged_in’),
‘body’ => $this->input->post(‘body’),
‘created_on’ => now()
);
$this->db->insert(‘posts’, $insert);
redirect(‘blog’);
} else {
$this->load->view(‘blog/write’);
}
}
function comments(){
$this->db->where(‘post_id’, $this->uri->segment(3));
$data[‘query’] = $this->db->get(‘comments’);
$this->load->view(‘blog/comments’, $data);
}
function comment_insert(){
$this->db->insert(‘comments’, $_POST);
redirect(‘blog/comments/’.$_POST[‘post_id’]);
}
}
?>

Come potete vedere rispetto al tutorial di Michael, la parte relativa all’interfacciamento al database, é stata delegata ad un’altra classe chiamata “Blog_model” che estende naturalmente la classe di default “Model”, rispettando quindi quello che il pattern MVC consiglia di fare; inoltre ho inserito due metodi per la gestione dei commenti sui post del blog: uno per la visualizzazione e uno per l’inserimento di nuovi commenti.
Il nome del file che si interfaccia al database per la lettura dei post del blog é blog_model.php e sará contenuto, come potete immaginare, nella cartella system/application/models/.

< ?php
if (!defined(‘BASEPATH’)) exit(‘No direct script access allowed’);
class Blog_model extends Model {
// preleva tutti i post dal db
function get_posts() {
$query = $this->db->get(‘posts’);
foreach ($query->result_array() as $row){
$result[] = $row;
}
return $result;
}
// preleva un singolo post
function get_post($post_id) {
$query = $this->db->where(‘id’, $post_id)->get(‘posts’);
$result = $query->row_array();
return $result;
}
}
?>

Ora passiamo alle parte di viste che vengono richiamate dal Blog controller, utilizzando i dati forniti dal modello attraverso l’interrogazioni del database. Questi files devono essere salvati nella cartella system/application/views/ dentro la sottocartella creata di nome blog/ .

front.php
E’ la vista principale, che ci permette di effettuare il login e visualizzare i post del blog.

< ?=$title;?>
< ?=$heading;?>
< ?php
if ($user[‘logged_in’] === TRUE) {
echo anchor(‘user/logout’, ‘Logout’);
echo ‘
< ?
if(isset($posts)){
foreach ($posts as $id => $post) {
echo ‘Post #’ . $id . ‘: ‘;
echo anchor(‘blog/article/’ . $id, $post[‘title’]);
echo ”;
}
}
?>

write.php
La form per l’inserimento dei post del blog, accessibile come possiamo vedere dal controller solo agli utenti autenticati.

< ?= form_open(‘blog/write’); ?>
for="title">Title:
"title" name="title" size="50" type="text" />
for="body">Body:
"body" cols="60" rows="10" name="body">

Programmare il Web seguendo MVC

neryo — Sun, 09 Mar 2008 13:05:54 +0000

Programmare il Web seguendo MVC

Qualcuno di voi appena ha letto l’acronimo MVC si sará subito posto qualche domanda… alcuni non l’avranno nemmeno sentito nominare… MVC stá per Model View Controller in italiano Modello-Vista-Controllore é un design pattern architetturale three tier, originariamente impiegato nel linguaggio smalltalk, (ora portato in tutti i linguaggi ad oggetti), ovvero un metodo su come strutturare le applicazioni in tre parti utilizzando la programmazione ad oggetti.

Il compito di questa strutturazione é quello di rendere indipendenti, disaccoppiando le parti software tra loro, adibite al controllo, all’accesso ai dati e alle viste di presentazione degli stessi.
Il pattern é basato quindi sulla separazione dei compiti fra le classi che interpretano tre ruoli principali:

Il modello gestisce i dati e fornisce i metodi per accedervi in modo astratto e consistente, solitamente la progettazione del modello è guidata sostanzialmente dalla struttura del database e quindi sostanzialmente dalle modalità di accesso ad esso;
La vista si incarica di visualizzare i dati o un porzione di essi, forniti dal controllore attraverso un opportuno modello, in base ad una specifica formattazione rappresentante un certo contesto applicativo, che potrá essere un lista di record, una form per l’inserimento e la modifica, un grafico, o qualsiasi rappresentazione si vuole dare a questi dati;
Il controllore é il “motore” dell’applicazione, riceve i comandi dall’utente, generalmente attraverso la vista utilizzando i propri metodi e li utilizza per richiamare in modo adeguato gli altri due componenti, permettendo quindi al modello di estrarre i dati, che vengono passati per la visualizzazione alle opportune viste. In pratica il controllere si occupa di rimappare le azioni effettuate dall’utente alle risposte dell’applicazione, che lavoreranno sui modelli e le viste in modo adeguato.

Questo approccio ha numerevoli vantaggi:

Indipendenza giá citata delle varie componenti, che permette di lavorare separatamente in team (con competenze diverse) alle parti software astraendone al meglio il funzionamento.
Possibilitá di scrivere viste e controllori diversi utilizzando lo stesso modello di acceso ai dati e quindi riutilizzare parte del lavoro giá fatto.
Avere il controllore separato dal resto dell’applicazione rende la sua progettazione piú semplice permettendo di concentrare gli sforzi sulla logica del funzionamento.
Obbliga gli sviluppatori a rispettare uno standard nella stesura del progetto, che ne facilita poi la comprensione e le successive implementazioni, soprattutto utilizzabile in progetti di medie/grandi dimensioni.
Software più flessibile, mantenibile ed aggiornabile nel tempo.

Ha anche alcuni svantaggi:

Adatto soprattutto a progetti medio/grandi.
Architettura sostanzialmente complessa.
Flessibilitá dipendente dal framework utilizzato.

Per iniziare ad addentrarsi in questo metodo, esistono tantissimi framework open-source per utilizzare il pattern di sviluppo MVC, come potete vedere da questa lista. Alcuni di essi sono piuttosto famosi come Zend Framework, CodeIgniter, Kohana Php, CakePhp, Symfony, PHPMVC ecc.. e sicuramente alcuni di voi li hanno utilizzati o almeno sentiti nominare.

Il piú é riuscire a capire quale framework MVC sia il piu’ adatto per ridurre e migliorare il nostro lavoro e rendere le nostre applicazoni piú snelle e ben organizzate, facilitandone in futuro il mantenimento e le aggiunte di funzionalitá.

Sicuramente nessuno puó sapere a priori quale sia il migliore per il vostro utilizzo, é una scelta abbastanza soggettiva, a parte che deve ricadere sui framework che supportano PHP5.. Ognuno di noi deve capire le sue necessitá e provarli sulla propria pelle o meglio sui propri progetti e magari poi portare le proprie esperienze su questo blog!

Riferimenti e spunti:
http://it.wikipedia.org/
http://www.phpday.it

Programmazione Web » Design pattern

Template engine, smarty, ma sono utili su framework MVC?

Progettiamo il software o programmiamo e basta?

Framework CodeIgniter guida alla creazione di un blog

< ?=$title;?>

< ?=$heading;?>

Programmare il Web seguendo MVC