LinuxParty

Otra cosa no pero no se puede negar que la gente de jQuery es currante, no paran de sacar nuevas versiones y refinar su ya de por si muy potente y sencillo de utilizar framework. Esta vez le toca el turno a la versión 2.0, que lleva disponible desde hace un par de días y que cuenta como mayor hecho diferenciador el haber retirado el soporte para los old-IE (es decir, Internet Explorer 6-7-8).

Esta retirada de soporte a los navegadores más vetustos de Microsoft ha supuesto una reducción del tamaño del código en un 12% por lo que hace a esta nueva versión de jQuery ideal para su inclusión en aplicaciones móviles (PhoneGap, Blackberry 10, Firefox OS), extensiones de navegadores o aplicaciones para Windows 8. Para aplicaciones web que requieran soporte para un amplio espectro de navegadores recomiendan seguir usando jQuery 1.x y anuncian la próxima salida de jQuery 1.10.

CodeQuery es una herramienta de indexación del código fuente, para hacer consultas o búsquedas de C, C++, Java y Python. Se basa en las bases de datos de cscope y ctags, que son procesados por la herramienta cqmakedb para generar un archivo de base de datos de CodeQuery. Puede ser visto y consultado con una herramienta GUI. Las características incluyen la finalización automática de términos de búsquedas y visualización de gráficos de las llamadas de función y herencia de clases. Pueden hacerse las siguientes consultas: símbolo, función o macro, clase o estructura, las funciones de llamada, la clase que posee el miembro o método, miembros y métodos de la clase, los padres de la clase (herencia), los childs de la clase (herencia), archivos incluyendo el archivo "this" y ruta de acceso completa para el archivo de funciones.

jQuery es una librería gratuita de JavaScript que facilita muchísimo el trabajo al momento de trabajar con el HTML de páginas web y la más popular en el mundo JavaScript, su slogan es “Escribe menos, haz más” y lo cumple al pie de la letra, tiene métodos, funciones y una sintaxis que mejora el rendimiento del trabajo cuando trabajar con HTML se trate, permite crear animaciones, manejar eventos, crear plugins para la librería y especialmente, crear aplicaciones AJAX.

Aunque la librería y los métodos son expresivos, fáciles de usar y con una documentación completa y extensa nunca está de más tener a mano un buen tutorial práctico para comprender mejor su uso, para ello existe tryjQuery, un sitio web creado por CodeSchool y jQuery para ayudarte paso a paso y de una manera muy práctica conocer jQuery a través de vídeos, una consola interactiva en la cual puedes escribir código jQuery directamente en el navegador.

Fresh IDE es un IDE visual para el lenguaje ensamblador con un compilador integrado Flat assembler (FASM). Está escrito en Fresh IDE y es una aplicación independiente compilable. Es totalmente compatible con FASM y puede ser compilado también con todas las versiones de FASM. El objetivo principal de Fresh IDE es hacer la programación en ensamblador tan rápido y eficiente como en los lenguajes de alto nivel, sin sacrificar el tamaño de una pequeña aplicación que potencia el lenguaje ensamblador. Se trata de una aplicación Windows, pero se ejecuta en Wine muy bien y puede crear, compilar, depurar y ejecutar aplicaciones para Windows y Linux en Windows y Linux.

Eduardo Cuomo, ha desarrollado unos scripts bien interesantes para ayudar al desarrollo en PHP y MySQL. Si eres desarrollador es posible que alguno pueda serte de utilidad.

Pueden encontrar todos los scripts en GitHub en los siguientes enlaces:

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).