Foros Club Delphi - Opiniones sobre Python, Ruby y Perl

Foros Club Delphi (https://www.clubdelphi.com/foros/index.php)

- Python (https://www.clubdelphi.com/foros/forumdisplay.php?f=46)

- - Opiniones sobre Python, Ruby y Perl (https://www.clubdelphi.com/foros/showthread.php?t=73123)

Opiniones sobre Python, Ruby y Perl

Observando la lista de TIOBE, que si bien es cuestionable también no puede ser ignorada del todo, Delphi se encuentra en el lugar número 13 (marzo de 2011).

Para mí es tiempo de empezar a estudiar otros lenguajes (al tiempo de continuar apoyando el rescate de Delphi), sobre todo aquellos que facilitan la creación de aplicaciones Web. Observando esa lista, debo confesar que me simpatizan poco los Cées y sus parientes más cercanos.

De los lenguajes que se encuentran (según TIOBE) en posiciones superiores a Delphi, me llaman la atención para estudiarlos Python, Ruby y Perl, que según entiendo son como primos. Me inclino por el primero a raíz de los comentarios que he leído últimamente, pero quiero estar seguro de que habré hecho una buena elección una vez que conozca, grosso modo, las ventajas y desventajas que tienen entre sí esos tres lenguajes, y, por qué no, respecto a otros lenguajes también.

Mi intención con este mensaje es abrir una invitación a todos aquellos programadores que han tenido experiencia con alguno de esos tres lenguajes, para que opinen sobre lo que les ha parecido, cuáles son sus puntos fuertes, sus puntos débiles, en qué casos son más recomendables, sus ventajas sintácticas, sus bibliotecas nativas, alcances, empuje de su comunidad, etc.

Todo lo que permita contrastar a Python, Ruby y Perl, y tomar la mejor decisión a todos los que estamos interesados en aprender un nuevo lenguaje de programación.

Muchas gracias.

Al González. :)

esta bien esa lista?

situar a Visual Basic por encima de Delphi ?
sacrilegio !!!

y me ha hecho recordar viejos tiempos

Cobol
RPG y su clasico HFELICO

Desde luego, no es de mi de quién esperas escuchar una opinión :) No por otra cosa sino porque mi experiencia en los tres lenguajes que mencionas en prácticamente nula.

Sin embargo, y ya me corregirán, yo descartaría Perl. Tengo entendido que es muy poderoso pero lo siento más para administradores de servidores. Es, según creo, algo rudimentario y no sé siquiera si sea orientado a objetos. Vamos, que no sé si sea lo más práctico para desarrollo a alto nivel.

De Python y Ruby, para desarrollo web, no he escuchado sino buenas opiniones.

// Saludos

Más que Python, para desarrollo web optaría por cosas como PHP. Como que Python es más "todoterreno", mientras que PHP es más especializado en eso.

Concuerdo con roman con lo de descartar perl, empezando porque indicas que no te gustan mucho los parientes de C. La verdad que perl no lo he usado, tan solo en una o dos ocasiones que he visto el código de algún script que he necesitado, pero de allí, nada mas.

De python y ruby si te puedo hablar un poco, los he usado ambos. El primero fué ruby, me gustó mucho, el lenguaje en sí es bastante simple (que no le quita funcionalidad) y muy potente, sin embargo, al utilizarlo con rails me costó mucho ya la parte de personalización del sitio web, donde necesitaba funciones "especiales" se me cerró todo.

Con python me ha ido diferente, igual de ágil que ruby, consume casi nada de recursos y es muy potente. Lo utilizo con django y va de maravilla.

Un problema que tube con ruby fué que no pude hacerlo funcionar bien sobre windows, entonces para mi le quita puntos en lo de "multiplataforma". El interprete si me funcionó, lo que no funcionó fueron las bibliotecas de acceso a bases de datos, sqlite, mysql y postgres.

Se agradecen los comentarios, Román, D-MO, rretamar.

Eso de que «Python es más "todoterreno"» se escucha interesante. :)

Cita:

Empezado por Al González (Mensaje 395478)

Para mí es tiempo de empezar a estudiar otros lenguajes (al tiempo de continuar apoyando el rescate de Delphi), sobre todo aquellos que facilitan la creación de aplicaciones Web. Observando esa lista, debo confesar que me simpatizan poco los Cées y sus parientes más cercanos.

Creo que deberías echar un vistazo a node.js, que es bastante nuevo y viejo a la vez: se trata de javascript ejecutado en el servidor, pero con unas caracteristicas impresionantes. Con node.js, cada petición al servidor se trata como un evento en lugar de crear un nuevo thread, lo cual significa que una aplicacion web basada en node.js necesita muchisima menos de ram y CPU en el server para poder atender muchisimas mas conexiones.

Entre otros puntos fuertes permite hacer aplicaciones comet sin necesidad de estar haciendo polling al servidor.

Y se integra muy bien con el servidor NGINX, el web server que esta llamado a sustituir al apache. De hecho, ya lo está haciendo.

Un saludo!

Hola a todos.
yo me inclinaría por phyton.

Con Django como framework para desarrollos.

Tengo entendido que integra bien con delphi.

OpenERP está desarrollado con phyton. Al, a ti que esres un estudioso de los frameworks de desarrollo, meterte a conocer OpenERP creo que te puede abrir un mundo de posibilidades, ya que dispones de todo el código. Tienes código para su estudio a cascoporro , que por lo que te conozco, lo valoras.

Si tuviera tiempo, empezaría con él...

Saludos

Tengo mucha experiencia ya con python, y te cuento que se integra muy bien con delphi (es lo que he usado para BestSeller).

Concuerdo con ignorar a Perl. No porque no sea un lenguaje potente, lo es, sino porque es particularmente complejo... a un nivel que incluso es famoso por su concurso de codigo incomprensible:

http://en.wikipedia.org/wiki/Obfuscated_Perl_Contest

Cita:

Entrants to the competition aimed to write "devious, inhuman, disgusting, amusing, amazing, and bizarre Perl code"

PHP (Para Hacer Paginitas) es ... para hacer paginitas. Una ventaja que tienes con ruby o python es que puedes extenderte facilmente a otras cosas sin recurrir a otros lenguajes. A menos que te dediques a ser un webmaster, realmente es algo que apreciaras... y teniendo en cuenta que conoces Delphi y son el resto de apps diferentes a aplicaciones web lo que tienes de experiencia, me inclinaria mas por estos dos:

Entre ruby & python mas o menos la cosa es asi. Ruby es mas magico. Python es mas simple. No me refiero a simple o magico en los terminos usuales, sino a su diseño estructural.

Ruby es mas inclinado a lisp/smaltalk. Python es mas inclinado a lo simple (tanto asi que esta dentro de su filosofia ).

Actualmente, ruby es mas lento (en sitios web) que python. Es algo que están corrigiendo...

Cita:

Empezado por mamcx (Mensaje 395595)

PHP (Para Hacer Paginitas) es ... para hacer paginitas.

Hum, no me atreveré a decir que no llevas razón, pues ciertamente PHP sirve para para hacer paginitas. Yo lo uso en el trabajo, en donde hacemos aplicaciones web que se usan en nuestra intranet. Una intranet que está desplegada sobre una red que proporciona conectividad a cientos de centros de trabajo, algunos de ellos MUY grandes. Una intranet que en la rama Users de su arbol LDAP cuenta con mas de 20.000 usuarios. En esta gran intranet, a la que se unen otras muchas bastante heterogéneas, lo mismo hay bases de datos Oracle, Informix, DB, SQL Server, y mas, supongo. inlcuso a menudo hay varias o de varias versiones en un mismo centro de datos.
Y nuestras aplicaciones PHP lo mismo atacan a una u otra de esas bases de datos, normalmente despues de que el usuario se haya autentificado contrra el servidor LDAP a fín de obtener un conjunto de derechos de acceso.

Por "motivos políticos" deberiamos estar usando Java con Hibernate y no se qué mas. De hecho, en otros departamentos lo usan. Pero en el mio usamos PHP porque con PHP tardamos MENOS en hacer las aplicaciones, y porque hacemos más rápido las interfaces de usuario, y mas eficientes gracias tambien a las facilidades de cosas como jquery, ajax, y al buen uso del CSS. Y sobre todo porque hemos comprobado que con php conseguimos las respuestas mas rápidas y cargas mas bajas de los servidores.

Ahora vamos a evaluar, para ciertas cosas, node.js y sobre todo nginx, y tambien Python, claro.

No somos fans de ningún lenguaje, ni framework ni ide. Y si evaluamos alguna cosa y nos parece mas productiva que PHP le daremos la patada sin dudarlo. No sería la primera vez.

Por eso me parece un poco, bueno, no sólo un poco, asombrosa, tal vez desde mi ignorancia, una afirmación como esa: "para hacer paginitas". De ahí que te formule una pregunta: ¿En que te basas para efectuar tal juicio?

A lo mejor esto da para un buen debate :D

Un saludo!

Cita:

Empezado por Julián (Mensaje 395607)

Por eso me parece un poco, bueno, no sólo un poco, asombrosa, tal vez desde mi ignorancia, una afirmación como esa: "para hacer paginitas". De ahí que te formule una pregunta: ¿En que te basas para efectuar tal juicio?

Ah pues un intento de decir algo ofensivo (ser tan políticamente correcto y decir que cada lenguaje tiene lo suyo y que cada uno escoja... bla.. es aburridor!). Es un lenguaje que me ofende desde mis adentros. Como el C++ (aunque en un golpe irónico trabajo ahora con Objective-C para la parte del iPhone de BestSeller, y como va la cosa, es algo para ratooooo).

Pero ya siendo mas serio lo que mencionas en cierta forma refuerza el punto. Una aplicacion de intranet no es que sea muy distinta a una web. Obvio, hay "paginitas" de paginitas, no es lo mismo hacer un facebook que la tipica web de quienes somos, los productos y venga aqui el contacto.

PHP es el lenguaje mas popular para hacer paginitas (abajo las palabras politicamente correctas!) y con todo, muchos de esos sitios son excepcionales.

Sin embargo, python (ruby) nacieron mucho antes de que la parte web fuera tan popular, así que se prestan de forma natural para otro tipo de software.

Como motores 3D de videojuegos (http://www.panda3d.org/), soporte en animacion de 3d (http://www.blender.org/), aplicaciones cientificas (http://www.scipy.org/), y todo un largo conjunto de aplicaciones, servicios y demas (Una lista aqui: http://en.wikipedia.org/wiki/List_of_Python_software).

No es que PHP como tal no pueda usarse en ámbitos fuera de la web, es que no es su propósito. Es mas natural usarlo para cosas web y por todos lados se nota, como su integracion en apache (modpython creo, es la razon #1 por la cual le gano la puja a perl y todo lo demas).

Python (y ruby) recorrieron el camino inverso. Solo fue cuando salio ruby on rails (http://rubyonrails.org/) y basado en su exito, django (http://www.djangoproject.com/) que tomaron "vuelo" en el mundo mas hip-hop y de cultura pop de la web.

PHP nació en la web, y no ha migrado, de forma significativa a otras tierras. Los demas lenguajes nacieron en otras tierras, y han migrado progresivamente a la web, con mayor o menor exito...

Para mi, tener la ventaja de hacer cosas <> paginas me empujo directamente a python . La magia de ruby y su lentitud me ahuyentaron, a pesar de que su sintaxis tiene puntos muy atrayentes, como se aprende en Why's (poignant) guide to ruby, quizas el tutorial de programacion mas entretenido que hay..

Un ultimo punto, y que fue determinante en mi caso en cuanto a aelegir a python (django) para la parte web, fue el hecho de que no se mezcla python con el html. Eso me causaba nauseas de las malas al ver codigo en PHP (hubo una epoca en la cual examine varios paquetes open source con el proposito de comercializarlos y reempaquetarlos) y al imaginar los dolores de cabeza que seria soportar codigo asi... bueno eso fue la estocada final.

Con django, por el contrario, el html esta muy alejado: http://docs.djangoproject.com/en/dev/ref/templates/api/. Es tan simple de modificar el codigo de python (y el html) sin corromper lo demas! Eso fue lo que me vendio al 100% la idea de nunca jamas de los jamases meterme en PHP. Porque aunque en PHP se *puede* hacer asi, al ir integrando codigo de terceros en los proyectos, unos serian un sancocho, otros mediocres y uno que otro bueno.

Con python, todos son mas o menos iguales. Es muy extraño, porque pareciera que python lo escribiera un solo programador. Casi como con pascal, pero con pascal si se notan muchos los diversos estilos de organizar el codigo...

Bueno, le echado un ojo muy muy por encima a la web de django, y he visto un ejemplo bastante básico, ese del reporter y el article, y antes de seguir mirando he decidido desempolvar un debian (64etch) que tenia en vmware, y ahora ando actualizandolo a squeeze despues de importarlo a parallels, con la intención de instalarle python (viene sin él, pues es una instalación de esas minimas) y despues proceder a probar pythin, y sobre todo django, que ya me has convencido de que al menos, debo hacerlo :D

Sobre dejar de lado lo politicamente correcto no podiamos estar mas de acuerdo.

Un saludo!

Muy interesantes todos los comentarios que han vaciado aquí.

Para desarrollar aplicaciones Web me parece muy importante comenzar con un lenguaje maduro cuya formación haya ocurrido en entornos de escritorio y que luego fuese pacientemente adaptado al entorno Web, como al parecer es el caso de Python.

Con PHP apenas si he realizado un par de ejercicios y cuando me ha tocado ver ejemplos de código fuente siento ganas de dejar de ser informático. Tantos simbolitos poco legibles (típico de C) mezclados con HTML y JavaScript me hacen cuestionarme «¿Cómo llegamos a esto?».

Ya les haré partícipes de mis primeras impresiones usando Python.

Al González. :)

Despues de actualizar el debian de etch a squeeze ya está pythion en el sistema. Y acabo de ver que el django estña en los respositoios de Debian, con un montón de paquetes:

Código:

#sudo aptitude search django

p   mumble-django                                         - A Mumble-Server web interface                                   

p   python-django                                         - High-level Python web development framework                     

p   python-django-app-plugins                             - plugin system for django                                        

p   python-django-auth-ldap                               - Django LDAP authentication backend                              

p   python-django-auth-openid                             - provides optional OpenID integration for Django                 

p   python-django-contact-form                            - extensible contact-form application for Django                  

p   python-django-countries                               - provides a country field for Django models                      

p   python-django-dajax                                   - easy to use ajax library for django                             

p   python-django-dajaxice                                - agnostic and easy to use AJAX library for django                

p   python-django-debug-toolbar                           - Embedded debugging toolbar for Django projects                  

p   python-django-djapian                                 - Search API for Django using Xapian                              

p   python-django-djblets                                 - Re-usable components for Django projects                        

p   python-django-dmigrations                             - Database migration tool for Django projects                     

p   python-django-doc                                     - High-level Python web development framework (documentation)     

p   python-django-extensions                              - Useful extensions for Django projects                           

p   python-django-filebrowser                             - file management in the Django admin interface                   

p   python-django-formfieldset                            - fieldset rendering mixin for Django-based forms                 

p   python-django-genshi                                  - Django integration for Genshi                                   

p   python-django-lint                                    - Static analysis tool for Django projects and applications       

p   python-django-markupfield                             - custom Django field for easy use of markup in text fields       

p   python-django-mumble                                  - A Mumble-Server config application for Django                   

p   python-django-nose                                    - Django test runner that uses python-nose                        

p   python-django-picklefield                             - Pickled object field for Django                                 

p   python-django-piston                                  - Django mini-framework creating RESTful APIs                     

p   python-django-registration                            - A user-registration application for Django                      

p   python-django-reversion                               - Provides comprehensive version control facilities for Django    

p   python-django-rosetta                                 - Eases the translation process of your Django projects           

p   python-django-shorturls                               - A short URL handler for Django applications                     

p   python-django-south                                   - Intelligent schema migrations for django apps                   

p   python-django-swordfish                               - Persistent key-value database with HTTP interface (Django integr

p   python-django-tagging                                 - A generic tagging application for Django projects               

p   python-django-threaded-multihost                      - allows to serve multiple sites from one django installation     

p   python-django-tinymce                                 - replacement text widget for Django web framework                

p   python-django-treebeard                               - Efficient implementations of tree data structures for Django    

p   python-django-treebeard-doc                           - Efficient implementations of tree data structures for Django (do

v   python2.4-django-genshi                               -                                                                 

v   python2.5-django-genshi

A ver si conseguimos hacer un "holamundo" con eso :D
Creo que mejor abrimos un hilo aparte para esto, que parece bastante potente.

Cita:

Empezado por Julián (Mensaje 395629)

A ver si conseguimos hacer un "holamundo" con eso :D

O un "pabernosmatao". :D ;)

Ahoritica me encuentro trabajando en un proyecto para la web y dada mi poca experiencia en otros lenguajes opté por PHP ya que necesitaba actuar raoidamente en este proyecto.

No creo que sea para hacer "paginitas"... algunos ignorantes dirian que delphi solo es para hacer "programitas"... pero que le vamos a hacer... ahi quienes comen moco y se esconden debajo de la cama pa'que no les pidan.

esta clase la hice en estos dias... me sirve para abstraer a php una tabla y ejecutar las funciones mas básicas (insertar, actualizar, eliminar) <<depende de otras clases>>

Código PHP:


		
			
class tge_dbtable {

    const CAN_GET_ALL = TRUE;

    const CANT_GET_ALL = FALSE;

    const SEPARATOR_DEFAULT = ",";

    const SEPARATOR_AND = "and";

    const ASSIGN = TRUE;

    const NOT_ASSIGN = FALSE;

    

    protected $db;

    protected $table_name;

    protected $table_alias;

    protected $sql;        

    protected $fields;

    protected $registros;

    

    public $listado;

    public $join;

    

    public function __construct($table_name, $table_alias = "t0"){

        $this->db = mysql_layer::getInstance(DB_LINK);

        $this->registros = new mysql_recordset(false);

        $this->listado = new mysql_recordset(false);

        

        $this->table_name = $table_name;

        $this->table_alias = $table_alias;

        

        $result = $this->exec_query("SHOW COLUMNS FROM {$this->table_name}");

        while ($field = mysql_fetch_object($result)){

            $fieldname = $field->Field;

            $this->fields[] = $this->table_alias.".".$fieldname;

            $this->$fieldname = $field->Default;            

        }

    }

    

    protected function get_fields($fields, $cangetall = self::CAN_GET_ALL, $assign = self::NOT_ASSIGN, $separator = self::SEPARATOR_DEFAULT){

        $sql = "";

        if (is_string($fields)){

            if (strlen($fields) > 0){

                if (!$assign) $fields = explode(",", $fields);

                else $sql .= $fields; 

            } else {

                if ($cangetall) $sql .= "* ";

            }

        }        

        if (is_array($fields)){

            $fieldcount = count($fields);

            $i = 1;

            if (!$assign){

                foreach ($fields as $field) {

                    $sql .= trim($field);

                    if ($i < $fieldcount) $sql .= "{$separator} ";

                    $i++;

                }

            } else {

                foreach ($fields as $field => $value) {                    

                    $field = trim($field);

                    $value = trim($value);

                    $sql .= "{$field} = '{$value}'";

                    if ($i < $fieldcount) $sql .= "{$separator} ";

                    $i++;

                }                

            }

        }



        return $sql;

    }

    

    private function get_values($values, $separator = self::SEPARATOR_DEFAULT){

        $sql = "";

        if (is_string($values)){

            if (strlen($values) > 0){

                $values = explode(",", $values); 

            } else {

                if ($cangetall) $sql .= "";

            }

        }        

        if (is_array($values)){

            $pattern = "/'(.*?)'/";            

            $count = count($values);

            $i = 1;

            

            foreach ($values as $value) {                    

                $value = trim($value);

                $match = array(); $pm = preg_match($pattern, $value, $match);

                if ($pm) $value = $match[1];

                

                if(is_string($value)) $value = "'{$value}'";

                

                $sql .= "{$value}";

                if ($i < $count) $sql .= "{$separator} ";

                $i++;

            }                

        }



        return $sql;

    }

    

    private function get_where($where, $operator = self::SEPARATOR_AND){

        $sql = "";

        if (is_string($where)){

            if (strlen($where) > 0){

                $sql .= " where ". $where . " "; 

            } else {

                $sql .= " ";

            }

        }

        if (is_array($where)){

            $i = 0;

            foreach ($where as $key => $value) {

                $pattern = "/#(.*?)#/"; $condition = "";    



                if ($i == 0) $condition = " where ";

                else  {

                    $operator = $operator;

                    $matches = array(); $pm = preg_match($pattern, $key, $matches);

                    if ($pm) {

                        $key = str_replace($matches[0], "", $key);

                        $operator = $matches[1];

                    }                

                    $condition = $operator . " ";    

                }

                

                $matches = array(); $pm = preg_match($pattern, $value, $matches);                

                $operator = "=";

                if ($pm) {

                    $value = str_replace($matches[0], "", $value);

                    $operator = $matches[1];

                }

                

                $condition .= "{$key} {$operator} '{$value}' ";

                $sql .= $condition;

                

                $this->$key = $value;

                $i++;

            }

        }

        

        return $sql;

    }

    

    private function get_join($joins = array()){

        $sql = "";

        

        foreach ($joins as $join) {

            //$sql .= " {$type} join {$condition} ";

            if (is_object($join) && get_class($join) == "tge_join_data"){

                $join = new tge_join_data($join->type, $join->table, $join->alias, $join->conditions);

                

                //get join fields

                $result = $this->exec_query("SHOW COLUMNS FROM {$join->table}");

                while ($field = mysql_fetch_object($result)){

                    $fieldname = $field->Field;

                    $this->fields[] = $join->alias .".". $fieldname;            

                }

                

                $conditions = "";

                if (is_string($join->conditions)) $conditions = $join->conditions;

                else {

                    $i = 0;

                    foreach ($join->conditions as $condition) {

                        if ($i > 0) {

                            $pattern = "/#(.*?)#/"; $operator = "and";

                            $matches = array(); $pm = preg_match($pattern, $condition, $matches);                            

                            if ($pm) {

                                $condition = str_replace($matches[0], "", $condition);

                                $operator = $matches[1];

                            }

                            $conditions .= " {$operator} ";

                        }

                        $conditions .= $condition;

                        $i++;

                    }

                }

                                

                $sql .= " {$join->type} join {$join->table} {$join->alias} on $conditions";

            }

        }

        

        return $sql;

    }

    

    /**

     * Obtener registros de una tabla.

     * @param string / array $fields

     * @param string / array $where

     * @param string / array $limit 

     * <br/>

     * <br/>

     * <b>$fields [string]</b> ej. "field1, field2".<br/> 

     * <b>$fields [array()]</b> ej. array("field1", "field2")<br/>

     * <b>$where [string]</b> ej. "field1 = value and field2 = value".<br/> 

     * <b>$where [array()]</b> ej. array("field1"=>"value", "field2"=>"value")<br/>

     * <b>Filtro en $where:</b> array("<font color="red"><b>#or#</b></font>field1"=>"<font color="red"><b>#like#</b></font>value")<br/>

     * <b>$limit [string]</b> ej. "0, 30".<br/>

     */

    protected function get_registros($fields = "", $where = "", $extra = ""){

        $sql = "select ";

        

        //Get JOIN

        $join = ""; if (is_array($this->join)) $join .= $this->get_join($this->join);

        

        //Fields

        $fields = $this->fields;

        $sql .= $this->get_fields($fields);        

        

        //FROM

        $sql .= " from {$this->table_name} {$this->table_alias} ";

        

        //WHERE

        $sql .= $this->get_where($where);

        

        //ADD - JOIN

        if ($join != "") $sql .= $join;

        

        //EXTA (ORDER BY, LIMITS)

        if (is_string($extra)) if (strlen($extra) > 0) $sql .= " {$extra} ";    

        

        $result = $this->exec_query($sql);

        

        $this->registros = new mysql_recordset($result);

        $this->listado = $this->registros;

        

        return $this->registros;

    }    

    public function get_listado(){ return $this->listado; }

    

    

    protected function exec_query($query){

        //CLEAN - TRIM

        for ($j = 0; $j < 10; $j++) {

            $query = str_replace("  ", " ", $query);    

            $query = str_replace("\n", " ", $query);

            $query = str_replace("\t", " ", $query);

        }    

        

        $this->sql = $query;

        $result = $this->db->query($query);

        return $result;

    }

    

    public function clean_alias($fieldname){

        $fieldname = str_ireplace($this->table_alias.".", "", $fieldname);

        return $fieldname;

    }

    

    protected function get_update($values, $where){

        $query = "update {$this->table_name} set ";

        $query .= $this->get_fields($values, self::CANT_GET_ALL, self::ASSIGN);

        $query .= $this->get_where($where);

        

        return $query;

    }    

    public function update($values, $where){

        $query = $this->get_update($values, $where);

        $exec = $this->exec_query($query);

        return $exec;

    }

    

    protected function get_insert($fields, $values){

        $query = "insert into {$this->table_name} ";

        $query .= "(". $this->get_fields($fields, self::CANT_GET_ALL) .") ";

        $query .= "values (". $this->get_values($values) .") ";

        

        return $query;

    }

    public function insert($fields, $values){

        $query = $this->get_insert($fields, $values);

        $exec = $this->exec_query($query);

        return $exec;

    }

    

    protected function get_delete($where = ""){

        $query = "delete from {$this->table_name} ";

        $query .=  $this->get_where($where);

        

        return $query;

    }

    public function delete($where = ""){

        $query = $this->get_delete($where);

        $exec = $this->exec_query($query);

        return $exec;

    }

}

y su implementación a la hora de trabajar es bastante sencilla...

Código PHP:


		
			
class tge_clientes extends tge_dbtable {

    public function __construct(){

        parent::__construct("tgv_cli_clientes");

    }

    

    public function get_listado(){

        parent::get_registros($this->fields);

        return $this->listado;

    }

}

no se no se... talvéz no aporte mucho pero PHP me ha dado buenos y excelentes resultados... nno conozco ni ruby ni pithon ni perl y no puedo opinar nada de ellos.. se que tienen buena pinta pero mientras logre conseguir lo que quiero con PHP para que aventurarme hasta aquellos lados.

El proyecto actual es para el control de distribución, manejo de clientes, mantenimientos etc de una marca de filtros de motor en todo el pais... no se no le veo nada de "paginita" (ya que estamos poco diplomaticos)

Gracias por tu testimonio, movorack. No se ve que sea una aplicación simple. Sólo te recomendaría tener más cuidado con la ortografía (hay muchas faltas en esta interfaz de usuario).

Cabe aclarar que no soy de los que cuestiona la capacidad de PHP, puesto que no lo he usado lo suficiente, pero sí he hecho ver la poca gracia que me causa su sintaxis heredada de C: esa vieja filosofía de ayudarle a la máquina antes que facilitarle las cosas al programador, cuya "cachiruleada" evolución ha derivado en un excesivo uso de símbolos que deterioran la legibilidad del código.

Cita:

Empezado por movorack (Mensaje 395644)

Ahoritica me encuentro trabajando en un proyecto para la web

movorack, eso es precisamente lo que digo. PHP es una herramienta hecha para hacer sitios web. Que pueden ser tremendos sitios web, no lo discuto porque un buen programador hará cosas buenas con lo que sea ue tenga a la mano.

En contraste, otros lenguajes permiten hacer cosas como motores en 3D de juegos de MMO.

Es entonces malo porque es un lenguaje enfocado y otros mas multi-proposito? No. Eso le ayuda, si el punto es hacer sitios web, esta bien.

Por años trabaje con FoxPro, un lenguaje para hacer programitas de bases de datos. A la fecha, no ha salido algo que lo supere...

Cita:

Empezado por movorack (Mensaje 395644)

esta clase la hice en estos dias... me sirve para abstraer a php una tabla y ejecutar las funciones mas básicas (insertar, actualizar, eliminar)

En donde yo trabajo usamos un sistema parecido: la bd principal, que no la única, es Oracle y tenemos hechos unos objetos con sus metodos inserta(), actualiza() y borra() con los cuales tratamos, de manera que en el código php no hay ni una sentencia sql. Cada uno de esos objetos no se corresponde con una tabla, sino con una entidad, que tambien es un objeto, o un conjunto de objetos, por ejemplo empleados() o contratos() o pacientes() de talk manera que podemos hacer algo como
Pepito = new Empleado();
Pepito->Apellidos="Perez Perez";
Contratos->Inserta(Pepito->Contrato());
Empleados->actuliza(Pepito);
No me acuerdo de como es la sintaxis, pero mas o menos se entiende el sistema, y lo potente y cómodo que es. Ademas, permite que uno se dedique a esas clases y otro a usarlas, aprovechando el encapsulamiento.
En resumen, se trata de, como dice el amigo movorack, de convertir las bases de datos en objetos.

En cuanto a lo de las paginitas, pues yo tampoco tenía ni idea de python, y ayer le eché unas cuantas horas, y sigo sin verle ninguna ventaja sobre PHP, aunque ya le he visto alguna desventaja. No digo que para otras cosas no sea muy bueno, que seguro que lo és, pero para aplicaciones WEB, al menos de momento, no lo veo yo muy claro.

Un saludo!

Por cierto, en el código PHP no hay SQL, y tampoco HTML. Y no usamos basuras tipo Smarty. Las plantillas que usamos para el diseño son PHP, pues, ¿para que usar plantillas si el mismo php ya es un lenguaje de script?

Creo que no le dariamos dolor de cabeza a Al Gonzalez :D

Un saludo!