LinuxParty

Es el momento para cambiar al fabuloso GNU as. Vamos a olvidarnos de DEBUG durante algún tiempo. Gracias depuración. GNU as, Gas, o GNU Assembler, es obviamente el ensamblador utilizado por el Proyecto GNU. Es parte del paquete Binutils, y actúa como el defecto de fondo de gcc. Gas es muy potente y puede apuntar a varias arquitecturas informáticas. Todo un programa, entonces.

Como la mayoría de los ensambladores, Gas 'se compone de directivas (también conocido como Pseudo Ops), comentarios, y por supuesto, las instrucciones. Las instrucciones son muy dependientes de la arquitectura de la computadora de destino. A la inversa, las directivas que tienden a ser relativamente homogénea.

Un módulo es un elemento de contenido que puede ser situado junto a un artículo. Por ejemplo, un menú es un módulo. El pequeño bloque de registro de la parte izquierda, también es un módulo. Puedes crear tantos módulos como quieras, y colocarlos en distintas áreas predefinidas de la plantilla.En este tutorial se explica cómo crear un módulo simple. A través del cual, aprenderá la estructura básica de archivos de un módulo. Esta estructura básica puede ser ampliada para producir módulos más elaborados.

Tenemos la programación de un módulo algo más sencillo en este artículo.

Programar un módulo para Joomla! 2.5

Todo el contenido expuesto en este artículo, está extraído y traducido de la documentación que la comunidad de Joomla! ofrece íntegramente en inglés en su sección para desarrolladores. Para más información siga este enlace.

Este tutorial le proporciona lo básico, de lo que se necesita saber para desarrollar tu propio módulo y un poquito más. Para lograr esto, la mejor forma es crear un módulo básico que nos muestre, que es lo que debe tener un módulo para su operabilidad en Joomla! 2.5. Nuestro módulo de ejemplo, su función será, mostrar otros artículos del mismo autor. Aunque en el transcurso del tutorial iremos explicando y exponiendo el código de nuestro módulo, al final de este artículo encontrarán un enlace a la descarga del fichero adjunto, donde podrá obtener el módulo con todos los pasos aquí expuesto y listo para su instalación.

Estructura de archivos

Hay cuatro archivos básicos que se utilizan dentro del patrón estándar en el desarrollo de un módulo:

• mod_author_related.php - Este archivo es el principal punto de entrada para el módulo. Se llevarán a cabo las rutinas de inicialización necesarias, llamar a las rutinas auxiliares para recoger todos los datos necesarios, e incluir la plantilla que muestra la salida del módulo.
• mod_author_related.xml - Este archivo contiene información acerca del módulo. En él se definen los archivos que necesitan ser instalados por el instalador de Joomla! y especifica los parámetros de configuración del módulo.
• helper.php - Este archivo contiene la clase helper que se utiliza para hacer el trabajo real en la recuperación de la información que se muestra en el módulo (por lo general a partir de la base de datos o alguna otra fuente).
• tmpl/default.php - Esta es la plantilla del módulo. Este archivo tomará los datos recogidos por el mod_author_related.php y generará el código HTML que se muestra en la página.

Creación del mod_author_related.php

El archivo mod_author_related.php llevará a cabo tres tareas:

• Incluir el archivo helper.php que contiene la clase que se utiliza para recoger los datos necesarios.
• Invocar el método apropiado para recuperar los datos.
• Incluir la plantilla para mostrar la salida.

Siguiendo estos tres puntos, vamos a colocar un poco de código en nuestro archivo. La clase helper está definida en nuestro archivo helper.php . Este archivo se incluye con la declaración require_once .

require_once dirname(__FILE__).'/helper.php';

require_once se utiliza porque nuestras funciones auxiliares se definen dentro de una clase, y sólo queremos la clase definida, una vez.

Para invocar a nuestro método utilizaremos las siguientes líneas:

mod_author_related.php

<?php
 $cacheparams = new stdClass;
 $cacheparams->class = 'modAuthorRelatedHelper';
 $cacheparams->method = 'authorRelated';
 $list = JModuleHelper::moduleCache ($module, $params, $cacheparams);
 require JModuleHelper::getLayoutPath('mod_author_related', $params->get('layout', 'default'));
?>

Y para incluir la plantilla que muestra el HTML de nuestro módulo, usamos está línea:

require JModuleHelper::getLayoutPath('mod_author_related', $params->get('layout', 'default'));

Visto esto, nuestro archivo mod_author_related.php completo es el siguiente:

<?php
 // No permitir el acceso directo al archivo
 defined('_JEXEC') or die;

 // Incluye las funciones sólo una vez
 require_once dirname(__FILE__).'/helper.php';

 // Invocar el método apropiado
 $cacheparams = new stdClass;
 $cacheparams->cachemode = 'safeuri';
 $cacheparams->class = 'modAuthorRelatedHelper';
 $cacheparams->method = 'authorRelated';
 $cacheparams->methodparams = $params;
 $cacheparams->modeparams = array('id'=>'int', 'Itemid'=>'int');

 $list = JModuleHelper::moduleCache ($module, $params, $cacheparams);

 if (!count($list)) {
  return;
 }

 $moduleclass_sfx = htmlspecialchars($params->get('moduleclass_sfx'));
 $showDate = $params->get('showDate', 0);

 // Incluir la plantilla que mostrará los datos recogidos
 require JModuleHelper::getLayoutPath('mod_author_related', $params->get('layout', 'default'));
?>

Creación del helper.php

El archivo helper.php contiene la clase necesaria para recuperar los datos que se muestran en la salida del módulo. Esta clase a su vez tendrá un método que se encargara de dicha tarea.
Aquí está el código para el archivo helper.php:

Observe que no se incluye la etiqueta de cierre de php “?>”.

<?php
// No permitir el acceso directo al archivo
defined('_JEXEC') or die;

// Utilizado para la ruta a los artículos
require_once JPATH_SITE.'/components/com_content/helpers/route.php';

// Clase helper que se utiliza para hacer el trabajo real en la recuperación de la información
abstract class modAuthorRelatedHelper
{

// Método que implementa la captura de la información necesaria a ser mostrada
public static function authorRelated($params)
 {
  $db  = JFactory::getDbo();
  $app  = JFactory::getApplication();
  $user  = JFactory::getUser();
  $userId = (int) $user->get('id');
  $count  = intval($params->get('count', 5));
  $groups = implode(',', $user->getAuthorisedViewLevels());
  $date  = JFactory::getDate();
  
  $option = JRequest::getCmd('option');
  $view  = JRequest::getCmd('view');

  $temp  = JRequest::getString('id');
  $temp  = explode(':', $temp);
  $id  = $temp[0];
  
  $showDate = $params->get('showDate', 0);
  $nullDate = $db->getNullDate();
  $now  = $date->toSql();
  $related = array();
  $query  = $db->getQuery(true);
  
  if ($option == 'com_content' && $view == 'article' && $id) 
  {  
   // seleccionar el autor del artículo

    $query->select('created_by');
    $query->from('#__content');
    $query->where('id = ' . (int) $id);
    $db->setQuery($query);
   
    $author = $db->loadResult();
    $query->clear();
   
   // Filtrar el contenido del autor 
  
    $query->select('a.id as art');
    $query->select('a.title');
    $query->select('DATE_FORMAT(a.created, "%Y-%m-%d") as created');
    $query->select('a.catid as cat');
                
    $query->from('#__content AS a');
    
    $query->where('a.id != ' . (int) $id);
    $query->where('a.state = 1');
    $query->where('a.access IN (' . $groups . ')');
    $query->where('(a.publish_up = '.$db->Quote($nullDate).' OR a.publish_up <= '.$db->Quote($now).')');
    $query->where('(a.publish_down = '.$db->Quote($nullDate).' OR a.publish_down >= '.$db->Quote($now).')');    
    $query->where('a.created_by = ' . (int) $author);
    // Filtrar por idioma
    if ($app->getLanguageFilter()) {
     $query->where('a.language in (' . $db->Quote(JFactory::getLanguage()->getTag()) . ',' . $db->Quote('*') . ')');
    }    
            
    $db->setQuery($query);
    $temp = $db->loadObjectList();
    
    if (count($temp))
    {
     foreach ($temp as $row)
     {
      $row->route = JRoute::_(ContentHelperRoute::getArticleRoute($row->art, $row->cat));
      $related[] = $row;     
     }
    }
    unset ($temp);
  }
  return $related;
 }
}

Como puedes darte cuenta, tenemos dos cosas importantes en este archivo:

• La clase modAuthorRelatedHelper : Que no existe ninguna regla, que obligue a escribir el nombre de dicha clase de esa forma, pero nos ayuda a hacer esto para que sea fácilmente identificable y localizable.
• Y el método authorRelated() : Que es donde dejamos volar nuestros conocimientos, y ponemos o programamos la captura de la información que se desea mostrar.

Creación del tmpl/default.php

El archivo default.php es la plantilla que muestra la salida del módulo. El código para el archivo default.php es el siguiente:

<?php
// No permitir el acceso directo al archivo
defined('_JEXEC') or die;
?>

<ul class="authorelated<?php echo $moduleclass_sfx; ?>">
 <?php foreach ($list as $item) : ?>
  <li>
   <a href="/<?php echo $item->route; ?>">
    <?php if ($showDate) echo JHTML::_('date', $item->created, JText::_('DATE_FORMAT_LC4')). " - "; ?>
    <?php echo $item->title; ?>
   </a>
  </li>
 <?php endforeach; ?>
</ul>

Aquí mostramos los títulos de los otros artículos del autor a través de $item->title, con la opción de mostrar o no la fecha. Esta opción de mostrar o no la fecha se hace a través del parámetro showDate, que vamos a definir a continuación en el archivo XML de nuestro módulo.

Ramsey Nasser ha anunciado el primer lenguaje de programación قلب que, en vez de utilizar caligrafía occidental (caracteres latinos), se basa en caligrafía árabe, al cual le da varias posibilidades estéticas.

Los lenguajes de programación no sólo tienen que ser eficientes, también pueden ser “elegantes” y una forma de arte no sólo por su contenido y estructura, sino intrínsecamente en la parte visual. Eso es lo que asegura Nasser que se consigue con su lenguaje de programación.

El termino checklist, se refiere a una lista de acciones o tareas que debemos de asegurar que hemos cumplimentado para dar por buena un trabajo. Es una forma muy sencilla y útil de realizar una serie de operaciones de forma ordenada asegurándonos no olvidarnos de ninguno de los pasos.

Quisiera compartir contigo una pequeña web en donde tenemos acceso a listas de revisión orientadas al desarrollo Web, Web Developer Checklist, que está en plena construcción pero que nos brinda checklist detallados que debiéramos revisar en todo Site que construyamos (y que muchas de ellas no cumplimento nunca).

Si coges a un programador al azar y le preguntas por sus hábitos de trabajo, es muy probable que responda que echa una gran cantidad de horas por la noche, y que estas suelen ser las que más cunden. Puede que algunos prefieran trabajar hasta altas horas de la madrugada, mientras que otros directamente opten por levantarse a las 4 y aprovechar para trabajar unas cuantas horas antes de que comience el ajetreo del día.

He tenido un pequeño momento friki de recuerdo de mis antiguas andanzas con la programación en ASM (ensamblador). Ese recuerdo me ha hecho pensar en intentar el típico “hola mundo” en ensamblador.

Siempre había programado en x86 bajo MS-DOS y recuerdo aquella interrupción para hacer casi de todo, la int 21h. Ahora, un aliciente mas ha sido que no tengo MS-DOS, sino Ubuntu y en 64bits (nada de 32bits), por lo que hay algunos pequeños cambios: por ejemplo la int 21h es la int 80h (la que tiene los servicios de kernel).

El programador Jeff Cogswell escribe: "Vamos a comparar Java vs C#, dos lenguajes de programación que cuentan tanto con un gran número de ardientes fans como de  virulentos detractores. Queremos saber el rendimiento real: ¿cómo funciona cada lenguaje cuando tienen que repartir millones de páginas web al día? ¿Cómo compararlos para poder recuperar los datos de una base de datos para la construcción de dichas páginas de forma dinámica?

Objective-C ha ganado el Premio TIOBE del Lenguaje de Programación por segunda vez consecutiva! El premio se otorga al lenguaje de programación que más adeptos consiguió en el mercado en 2012. La cuota de mercado de Objective-C es de 3.37% por encima de lo que era en enero de 2012. La causa principal de la victoria de Objective-C es, por supuesto, el gran negocio del desarrollo de aplicaciones móviles.

Otros movimientos interesantes en 2012 fue el resurgimiento de C++ (1,09%, impulsado por Microsoft) y Python (0,96%). Por otro lado, perdieron cuota de mercado C# (-2,57%, debido a su entrada tardía en el mercado de telefonía móvil) y Delphi (-0,65%) una cuota de mercado considerable.

El componente Xmap sirve para generar un sitemap en joomla (sitemap.xml). Podrás usar este sitemap para enviarlo a google.

Con el panel de control de Xmap podrás configurar y escoger que items deseas agregar al sitemap y así excluir algunos que no desees incluirlos en el mapa del sitio.