Programando con estilo...

Archivado
Gelou!

Últimamente estoy de un activo y un coñazo con la preguntas, que asusto.

Sigo con mi programachión y mi duda es... ¿cómo es la buena sintaxis de un buen programador? Es decir... programar con estilo. Que el código sea lo más claro posible, que siga unas normas...

Si no recuerdo mal, en otro post, hace tiempo me comentásteis incluso que ciertas organizaciones tienen cierto estilo propio. Que si los programas GNU tenían la sintaxis organizada de una forma, etc. Pero, supongo que lo que programéis de aquí y los que hayáis compartido código con gente de todo el mundo ó hayáis visto código de aplicaciones libres, estaréis acostumbrados a saber de qué hablo.
Son cosas como poner el nombre de las variables en minúsculas, las constantes en mayúsculas, poner el nombre de la función y en el siguiente renglón a la definición de ésta poner la llave para empezar a codificar dicha función...

No sé, todo ese tipo de cosas, ¿dónde podría aprenderlas a hacer correctamente?

Gracias.

Un saludín!
Pues lo último que ví parecido a lo que buscas lo encontré en el proyecto bombergum y como siempre , suerte pa ellos :D

Salu2
dykstra escribió:Pues lo último que ví parecido a lo que buscas lo encontré en el proyecto bombergum y como siempre , suerte pa ellos :D

Salu2
Pues como me he sentido aludido al leer esto :P te remito a esta url, y ahi esta la guia de estilo que hizo eraser para los programadores del grupo (mencionada por dykstra) ;)

Saludos!
Pues como me he sentido aludido al leer esto te remito a esta url, y ahi esta la guia de estilo que hizo eraser para los programadores del grupo (mencionada por dykstra)

Saludos!


Por eso no dije quien a había hecho... pensaba que tú, ashitaka, pero luego me vino a la cabeza eraser... supongo que por una vez, mi cabeza ha funcionado bien [qmparto] [qmparto] [qmparto]
La sintaxis GNU no está del todo mal... personalmente:

http://nbsmtp.ferdyx.org/wiki/CodeStyle

Y por supuesto, usa doxygen [ doxygen.org ] para tus programas.

Salu2.Ferdy
FuckingFreaky escribió:No sé, todo ese tipo de cosas, ¿dónde podría aprenderlas a hacer correctamente?

Lo mejor para aprender eso es:

1) Piensa que lo que haces lo tiene que entender hasta el más tonto de tu clase (yo de hecho pienso en una persona en concreto :P)

2) Sé muy detallista.

3) Mira códigos escritos por otras personas. Hay un huevo de software libre así que hay un huevo de código que puedes bajar para ver ;). No es necesario entenderlo si al fin y al cabo lo único que quieres ver es el estilo.
FuckingFreaky escribió:Si no recuerdo mal, en otro post, hace tiempo me comentásteis incluso que ciertas organizaciones tienen cierto estilo propio. Que si los programas GNU tenían la sintaxis organizada de una forma, etc. Pero, supongo que lo que programéis de aquí y los que hayáis compartido código con gente de todo el mundo ó hayáis visto código de aplicaciones libres, estaréis acostumbrados a saber de qué hablo.

Es como lo típico de:
for (int i = 0; i < 10; i++) {
     System.out.println(i);
}

for (int i = 0; i < 10; i++)
{
     System.out.println(i);
}

GNU tiene su forma, y muchos tienen su forma. Yo acostumbro a programar de la 1º forma que pongo y se me hace lento ver lo 2º. La gente que escribe de la 2ª forma ve "rara" la 1ª. Es cuestion de acostumbrarse.

Con respecto a las organizaciones, en ellas por lo general se tiene (o se deberia tener) un documento llamado Plan de Gestión de la Configuración donde debes indicar todo eso: Qué va en mayusculas, si los identificadores pueden empezar por _, cómo son los nombres de las funciones, etc.


EDITO: y muy importante. Para programar bien hay que escribir, por cada poco código, un párrafo de comentarios, pero no del tipo "mostramos el nombre del usuario" y luego hacer un printf, sino comentar qué se está haciendo y, sobre todo, por qué se está haciendo. Haberme tomado 5-10 minutos en hacer una explicación a veces me habría ahorrado muchos dolores de cabeza. Comentar no es perder el tiempo, creeme ;)


Un saludo
EDITO: y muy importante. Para programar bien hay que escribir, por cada poco código, un párrafo de comentarios, pero no del tipo "mostramos el nombre del usuario" y luego hacer un printf, sino comentar qué se está haciendo y, sobre todo, por qué se está haciendo. Haberme tomado 5-10 minutos en hacer una explicación a veces me habría ahorrado muchos dolores de cabeza. Comentar no es perder el tiempo, creeme


Según he podido leer y no recuerdo bien donde... pero en algún 'libro de estilo' de programación ... sobrecomentar es incluso peor que no comentar.

No termino de creermelo... pero los comentarios han de ser precisos y escuetos. A la curva de Hatton me remito.

Salu2.Ferdy
Puf! Pues ya tengo un par de cositas para mirar!

La verdad que yo, por lo que veo, soy un puto desastre. Soy de los que programa en plan:
if (int i=0;i cout << i;
}


En fin... Voy a ver si me bajo el código de algún programita interesante y bien hecho (¿recomendáis algún programa que creáis que pueda estar muy bien estructurado por buenos programadores?). La verdad es que de momento, casi lo que más me convence es lo del proyecto psEOL (ueeeeh!). Eso va más con mi forma, pero ahora que estoy aprendiendo lo que quiero es adoptar un buen estilo, y quitarme de manías personales que luego uno siempre arrastra.

Por cierto, las clases en C++...¿mayúsculas?¿minúsculas? ¿alguna combinación?

Muchas gracias a todos.

Un saludín!

P.D: Ferdy, no lo he mirado mucho, pero el nbSMTP, es un programita que te estás currando tú?
P.D: Ferdy, no lo he mirado mucho, pero el nbSMTP, es un programita que te estás currando tú?


Si.

Por eso en un principio te ponía el enlace para que le echaras un vistazo. Pero por otro lado, después de los requisitos que has puesto (sobre todo lo de buenos programadores :P) entonces ya no te lo recomiendo jejeje

Ahora sinceramente... en algunos aspectos modestamente creo que está bien, en otros seguro que no tan bien :)

Pero vamos que hay muchos programas a los que echarles un vistazo, por ejemplo mutt es uno de ellos

Salu2.Ferdy
yo para programar con estilo uso Channel

al principio del programa haces lo siguiente

#include "channel_n5.h"


Luego, después del main, inicializas el motor de Channel así

CH_Init(CH_NUMBER_FIVE); // inicializo el número cinco, que es el que me mola


Y una vez inicializado, en vez de sacar el texto con un triste printf, escribes con estilo
CH_Fashion_Text("Hola Ramona, tengo %d años\n",anios);

Ahora el texto quedará mucho más fashion

Y por cierto, que no se te olvide cerrar el motor Channel, o se quedará en memoria. Al terminar tu programa pon

CH_CloseAll();


En fin, que hoy es fiesta [fies] [fies] Regocijaos y ponzoñad por el barro warretes...
FuckingFreaky escribió: if (int i=0;i cout << i;
}


Si programas asi, preocupate mas por las sintaxis que por el estilo xD

Salu2

PD: No te mosquees, pero es que me ha pegado al ojo, incluso leyendo el post de pasada
xDDDDDDDDDDDDDDDDDDDDDDDDDD
Navegando, navegando, me he encontrado estos dos links relacionados con el tema:
http://www.lysator.liu.se/c/pikestyle.html
http://www.psgd.org/paul/docs/cstyle/cstyle.htm#contents

PD:Que malo eres Sylvan [qmparto]
La Guia de Estilo de Eraser con "comentarios y futuras actualizaciones" la puedes encontrar aquins:

http://bombergum.sourceforge.net/foros/viewtopic.php?t=67

Por cierto...

if (int i=0;icout << i;
}
este...... guau... vaya if más complejo [agggtt]

de todas formas, yo prefiero los siguientes estilos:

for ( int i = 0; i < n; i++ )
cout << i;


Y si en lugar de un "cout << i;", supongamos que lo que queremos hacer son operaciones que no hacen llamadas a funciones que no usen I/O de ningún tipo puedes hacer esto:

supongamos que queremos que el bucle sume a la variable 'j' el valor de 'i', y lo incremente en 10, es decir:
int i = 0;
while ( i < n ) {
j = j + i;
j = j + 10;
i = i + 1;
}

A mi me gusta optimizar al el espácio para que de un solo vistazo sea "entendible":
for ( int i = 0; i < n; j += i, j += 10, i++ );
Claro, que esto es muy simple, se puede complicar más, pero bueno. Realmente no hace falta acostumbrarse a UNA manera de indentar y de escribir el código, solo hacerlo de forma lógica para uno mismo, siempre y cuando se documente para que otro lo pueda "interpretar". Eso si, siempre va bien saber adaptarse, ya cuando haces proyectos en conjunto... mejor que todo el mundo siga una indentación y un estilo, porque sino es un caos.

Lo importante de verdad es aprender a programar bien. El estilo es lo de menos... si vieras el código de Linux (el kernel) 0.0.1 te cagabas la pata abajo... ¡si casi cada linea la indenta de manera distinta! La cuestión era que estaba bien programado, y eso no importó a la comunidad inicial... solo que después se tubo que adaptar porque era incontinuable :D

Ánimo!!!!

Por cierto,
Ferdy escribió:No termino de creermelo... pero los comentarios han de ser precisos y escuetos. A la curva de Hatton me remito.
Pues yo digo que cuanto más, mejor. A las curvas de Harumi Nemoto me remito. A ver quien es el guapo que lo discute [fumeta]
Rurouni escribió:[...]
Y si en lugar de un "cout << i;", supongamos que lo que queremos hacer son operaciones que no hacen llamadas a funciones que no usen I/O de ningún tipo puedes hacer esto:

supongamos que queremos que el bucle sume a la variable 'j' el valor de 'i', y lo incremente en 10, es decir:

for ( int i = 0; i < n; j += i, j += 10, i++ );

A mi me gusta optimizar al el espácio para que de un solo vistazo sea "entendible":

[...]


Yo en esos casos, veo mucho más claro, más limpio, y más comprensible a primera vista algo del tipo:

for (int = 0; i < n; i++)
{
j += i;
j += 10;
}

En este caso la cosa al tener j e i como nombre de variables, pues tampoco quedaba muy enrevesado, pero prueba con algo como:

for ( prev_index = 0; prev_index < MAX_INDEX_SET; dummy_var += prev_index, dummy_var += 10, prev_index++ );

VS

for ( prev_index = 0; prev_index < MAX_INDEX_SET; prev_index++)
{
dummy_var += prev_index;
dummy_var += 10;
}
Hola de nuevo ^__^x

Yo realmente no lo haría así
for ( prev_index = 0; prev_index < MAX_INDEX_SET; dummy_var += prev_index, dummy_var += 10, prev_index++ );

Lo pondría asin
for ( prev_index = 0;
prev_index < MAX_INDEX_SET;
dummy_var += prev_index,
dummy_var += 10,
prev_index++ );

Pa gustos colores... e indentaciones. Como digo, depende de donde trabajes y a lo que estés acostumbrado. A ver, que esto último simplemente es una chulería, pero lo utilizamos para hacer estadísticas y optimización de líneas (queremos evitarnos los '{ }', los ';''). Como digo, pura chulería :D

Saludos!!!

Actualizo: no se ve la indentación, pero bueno... simplemente estructurar un poquito el for.
Gelou!

Gracias a todos por los comentarios! Weno... menos al mamoncete de Sylvan :P. Que pasa joé, que voy estresado y ya no sé ni lo que escribo...

Ferdy, me gusta bastante la sintaxis que estás utilizando para tu proyecto. Tampoco sabía que se debiera especificar todo esto a la hora de crear un proyecto en un documento como el que comentó RaUleX, aunque claro, es muy lógico. Y la verdad que he sacado varias cosas interesantísimas de todos los enlaces. Gracias a todos!!!

En fin... yo intentaré aprender a programar bien, y además con estilo propio y bonito. Voy a ver si encuentro esa librería channel...[risita]

Por cierto, me bajé el código del mozilla, toma ya!XD. La verdad que mooola.

Ruro, en cuanto aprenda más de C++ y os pueda ser de ayuda, cuenta conmigo para BomberGUM!, si es que puedo hacer algo. De momento es que no sé nada más que lo básico (relaciones, polimorfismo, excepciones y genericidad...). Así que en cuanto vaya aprendiendo a ver si os puedo echar un manita aunque sea en cosas pequeñas, que me gustaría bastante poder colaborar.

En fin, voy a ver esos nuevos links. Cenkiuuuuuuu

Salu2!

P.D: Se me olvidaba! El doxygen... buenísimo! Amos, no lo he probado pero parece más que interesante. Cenkiu again.
Edito: Joder... he ido a mirar lo de la curva de Harumi Nemoto... esto no es serio!!!XD.
Rurouni escribió:Hola de nuevo ^__^x

Yo realmente no lo haría así
for ( prev_index = 0; prev_index < MAX_INDEX_SET; dummy_var += prev_index, dummy_var += 10, prev_index++ );

Lo pondría asin
for ( prev_index = 0;
prev_index < MAX_INDEX_SET;
dummy_var += prev_index,
dummy_var += 10,
prev_index++ );

Pa gustos colores... e indentaciones. Como digo, depende de donde trabajes y a lo que estés acostumbrado. A ver, que esto último simplemente es una chulería, pero lo utilizamos para hacer estadísticas y optimización de líneas (queremos evitarnos los '{ }', los ';''). Como digo, pura chulería :D

Saludos!!!

Actualizo: no se ve la indentación, pero bueno... simplemente estructurar un poquito el for.


Los espacios en blanco son omitidos en html a partir del segundo, así que la indentación suele salir rana XD. Eso sí, al citar el texto, se ve, por si alguien no se hace la idea. Aún así, sigue pareciéndome menos claro el código, prefiero gastar líneas y que todo quede limpito y clarito (siempre según la concepción que tiene cada programador de limpito y clarito, que esa es otra XD).
Un for o while void no tiene por qué no ser claro y limpio... eso es una chorrada.

Salu2.Ferdy
Ferdy escribió:Un for o while void no tiene por qué no ser claro y limpio... eso es una chorrada.

Salu2.Ferdy


ein?
Yo por lo general intento que todo ocupe el menos espacio posible, por lo general hago codigo par ami, no para otros, ya que son programas chorras o webs en php y esas cosas personales sin importancia (lo digo pq no penseis que voy del palo de no liberar nada en mi P vida XD)

Ahora tiendo a hacer las webs bien escalonadas, para no perderme entre los div y los span para los estilos, y lo mismo cuando meto codigo php, pero pocas veces, muy pocas tiendo a poner comentarios.

La verdad es que a mi me gusta mucho el codigo limpio (sin comentarios), ya que si te pones a analizar un programa, que es lo que hace, te quedas mucho mas satisfecho...

Por ejemplo, cuando me estube mirando el codigo de DCMovie Player (reproductor multimedia para la DC), programado en C y por supuesto con las librerias de KalistOS y estube analizanbdo el codigo sin saber C (ole mis huevos... en aquellos momentos hacia unos 8 u 9 años que no tocaba C, pero vamos, como si nunca lo hubiera conocido XD) y la verdad que por los comentarios casi nulos (que recuerdo) estaba todo bastante bien...

Yo tambien soy de los que hacen:
if (n == 0 ) {
   echo "hola!";
}
else {
   echo "adios";
}


Es un ejemplo, sguramente lo pondria aún mas condensado todo eso, pero es que a mi no me mola usar una linia para un solo caracer (com perdon del final del IF, pero ese lo dejo por costumbre)

Tambien acostumbro bastante a dejar una linia en blanco para indicar que lo siguiente es como otro paso, aunque sea en la misma función, eso me ayuda a prestar mas atención a las partes de codigo...

Tambien soy de los que hace puntualizaciones y comentarios cortos (no mas de una linia), y en las practicas de la universidad siempre lo he hecho asi, si los profesores quieren preguntar algo, que pregunte, que contesto incluso habiendo copiado [angelito]

Vamos, mi consejo es que programes como te sientas comodo, la gente se sentira mas o menos incomoda con tu forma, pero la ha de entender pq es lo mismito que haciendolo de otra forma..

Mientras el codigo sea correcto, no declares chorrocientas variables, ademas de otras tantas publicas y tal, pues el resto es nada.

Siempre puedes añadir en plan comentario arriba:

/* I'm cool so my style is cool */

Ademas con los /* */ para joder aunque sea una sola linea XD

PD: pa que salgan los espacios y los tabs usad el [code*][/code*] que esta activo aunque no haya el botoncito :)
Pues a mi me gusta todo bien estructurado, cuestion de gustos, lo de los { al final de linea, para mi son incomodos de ver XD me gusta ponerlos en una linea sola. Sobre los comentarios, pues no los pongo largos, solo lo necesario para que se entienda el codigo, eso si me gusta poner comentarios para cualquier clase-metodo que hago.

Aqui os dejo una muestra de una clase hecha en java para eu veais como lo hago (Los /**...*/ aunque sean de una linea es para el javadoc XD )

import java.util.*;

/**
* <p>Título: sacardatos </p>
* <p>Descripción: Clase que guarda tanto los datos personales, como los datos bancarios del
* cliente en caso de ser necesarios, tambien implementa metodos para sacar estos datos
* de la tabla hash en la cual se ha guardado </p>
* @author Daniel & Alberto
* @see Datos
* @see Archivo
* @see Formulario
* @see VentanaVerificaDatos
*/
public class sacardatos
{
  /**Atributo que guarda el telefono del cliente*/
  private String Telefono;
  /**Atributo que guarda el nombre del cliente*/
  private String Nombre;
  /**Atributo que guarda los apellidos del cliente*/
  private String Apellidos;
  /**Atributo que guarda el Nif del cliente*/
  private String Nif;
  /**Atributo que guarda el domicilio del cliente*/
  private String Domicilio;
  /**Atributo que guarda el tipo de pago que realiza el cliente Tarjeta, Efectivo, Domiciliacion*/
  private String Tipodepago;
  /**Atributo que guarda el numero de cuenta del cliente*/
  private String Numcuenta;
  /**Atributo que guarda el numero de tarjeta del cliente*/
  private String Numtarjeta;
  /**Atributo que guarda la fecha de caducidad de la tarjeta del cliente*/
  private String Fechacaduci;
  /**Atributo que guarda el tipo de tarjeta con la que realiza el pago el cliente*/
  private String Tipotarjeta;
  /**Atributo que guarda */
  private Datos objdatos;
  /**Atributo que guarda */
  public static Hashtable datos = new Hashtable();

  /**Constructor de la clase el cual no realiza ninguna accion*/
  public sacardatos()
  {
  }

  /**Metodo con el cual se obtiene el telefono del cliente
   * @param d_tipo Tipo de pago que realiza el cliente
   * @return Telefono Telefono del cliente
   * */
  public String gethtelefono(String d_tipo)
  {
    objdatos = (Datos) datos.get(d_tipo);
    Telefono = objdatos.getTelefono();
    return Telefono;
  }

  /**Metodo con el cual se obtiene el nombre del cliente
   * @param d_tipo Tipo de pago que realiza el cliente
   * @return Nombre Nombre del cliente
   * */
  public String gethNombre (String d_tipo)
  {
    objdatos = (Datos) datos.get(d_tipo);
    Nombre = objdatos.getNombre();
    return Nombre;
  }

  /**Metodo con el cual se obtiene los apellidos del cliente
   * @param d_tipo Tipo de pago que realiza el cliente
   * @return Apellidos Apellidos del cliente
   * */
  public String gethApellidos (String d_tipo)
  {
    objdatos = (Datos) datos.get(d_tipo);
    Apellidos = objdatos.getApellidos();
    return Apellidos;
  }

  /**Metodo con el cual se obtiene el Nif del cliente
   * @param d_tipo Tipo de pago que realiza el cliente
   * @return Nif Nif del cliente
   * */
  public String gethnifletra (String d_tipo)
  {
    objdatos = (Datos) datos.get(d_tipo);
    Nif = objdatos.getNif() + "-" + objdatos.getLetraNif();
    return Nif;
  }

  /**Metodo con el cual se obtiene el Domicilio del cliente
   * @param d_tipo Tipo de pago que realiza el cliente
   * @return Domicilio Domicilio del cliente
   * */
  public String gethdomicilio (String d_tipo)
  {
    objdatos = (Datos) datos.get(d_tipo);
    Domicilio = objdatos.getDomicilio();
    return Domicilio;
  }

  /**Metodo con el cual se obtiene el numero de cuenta del cliente
   * @param d_tipo Tipo de pago que realiza el cliente
   * @return Numcuenta Numero de cuenta del cliente
   * */
  public String gethNumcuenta(String d_tipo)
  {
    objdatos = (Datos) datos.get(d_tipo);
    Numcuenta = objdatos.getNumeroCuenta();
    return Numcuenta;
  }

  /**Metodo con el cual se obtiene el numero de la tarjeta del cliente
   * @param d_tipo Tipo de pago que realiza el cliente
   * @return Numtarjeta Numero de tarjeta del cliente
   * */
  public String gethNumtarjeta(String d_tipo)
  {
    objdatos = (Datos) datos.get(d_tipo);
    Numtarjeta = objdatos.getNumeroTarjeta();
    return Numtarjeta;
  }

  /**Metodo con el cual se obtiene la fecha de caducidad de la tarjeta del cliente
   * @param d_tipo Tipo de pago que realiza el cliente
   * @return Fechacaduci Fecha de caducidad de la tarjeta del cliente
   * */
  public String gethFechatarjeta(String d_tipo)
  {
    objdatos = (Datos) datos.get(d_tipo);
    Fechacaduci = objdatos.getFechaCad();
    return Fechacaduci;
  }

  /**Metodo con el cual se obtiene el tipo de tarjeta utilizado por el cliente
   * @param d_tipo Tipo de pago que realiza el cliente
   * @return Tipotarjeta Tipo de tarjeta utilizado por el cliente
   * */
  public String gethTipotarjeta(String d_tipo)
  {
    objdatos = (Datos) datos.get(d_tipo);
    Tipotarjeta = objdatos.getTipoTarjeta();
    return Tipotarjeta;
  }
}



Y al igual que antes, por ejemplo los bucles, if y demas me gusta ponerlos asi:

      while ((entrada = br.readLine()) != null)
      {
        //leemos los componentes
        StringTokenizer st = new StringTokenizer(entrada, ";");
        codigo = st.nextToken();
        tipo = st.nextToken();
        marca = st.nextToken();
        formato = st.nextToken();
        medida = st.nextToken();
        preciostring = st.nextToken();
        precio = prec(preciostring);
        descripcion = st.nextToken();

        //creamos un objeto con cada componente leido
        objcompo = new componente(codigo, tipo, marca, formato, medida, precio,
                                  descripcion);

        //Lo introducimos en la tabla hash clasificado por el codigo
        h.compo.put(codigo, objcompo);
       }


Perdon por el post tan largo pero es para que lo vierais

Un saludo
Puedes cargarte esto:
  /**Constructor de la clase el cual no realiza ninguna accion*/
  public sacardatos()
  {
  }

Saludetes
¿ Realmente alguien usa JavaDoc para proyectos serios existiendo DoxyGen ?

Salu2.Ferdy
Ferdy escribió:¿ Realmente alguien usa JavaDoc para proyectos serios existiendo DoxyGen ?

Salu2.Ferdy


Pues supongo que no, pero a mi si me dicen en la universidad que la documentacion en javadoc, no les rechisto, se la entrego y punto XD Ya sabes venazos de los profesores, que tiene que ser como ellos digan y como ellos digan (Normal pro una parte)

Raulex, lo tendré encuenta para la proxima vez

Un saludo
Ya ya... la uni es otro tema... yo igual. Por eso decía para 'proyectos serios'

Salu2.Ferdy
Ferdy escribió:Ya ya... la uni es otro tema... yo igual. Por eso decía para 'proyectos serios'

Salu2.Ferdy


Hombre para java, el javadoc no esta mal, y mas cuando hay IDES que lo hacen automaticamente mientras se escribe el codigo, sin utilizar programas externos, l averdad que para java a mi me gusta el javadoc, para c/c++ el doxygen.

Un saludo
javadoc sux comparado con doxygen no sabes cuanto... no genera man, no genera rtf... SOLO html.

Muchos IDEs se integran perfectamente con doxygen (véase vim)

Por suerte doxygen entiende casi todo o todo el javadoc.

Salu2.Ferdy
27 respuestas
Archivado
Volver a Software libre