Glosario (segunda parte) y apuntes

En esta nueva entrada de DatoByte les comparto nuevos conceptos relacionados con el mundo de sistemas (Hardware y software) adicional de unos apuntes del segundo capitulo del libro Ingenieria de Software 9na Edicion

Iniciemos con los conceptos:

Ingeniería del software: este término fue acuñado para definir la necesidad de una disciplina científica que, como ocurre en otras áreas, permita aplicar un enfoque sistemático, disciplinado y cuantificable al desarrollo, operación y mantenimiento del software.

Gestión Predictiva de proyectos: es una disciplina formal de gestión, basada en la planificación, ejecución y seguimiento a través de procesos sistemáticos y repetibles.

Producción basada en procesos: se crean modelos de procesos basados en el principio de Pareto, empleado con buenos resultados en la producción industrial. Dicho principio nos indica que la calidad del resultado depende básicamente de la calidad de los procesos.

Desarrollo guiado por pruebas de software, o Test-driven development (TDD): es una práctica de ingeniería de software que involucra otras dos prácticas: Escribir las pruebas primero (Test First Development) y Refactorización (Refactoring). Para escribir las pruebas generalmente se utilizan las pruebas unitarias (unit test en inglés). En primer lugar, se escribe una prueba y se verifica que las pruebas fallan. A continuación, se implementa el código que hace que la prueba pase satisfactoriamente y seguidamente se refactoriza el código escrito. El propósito del desarrollo guiado por pruebas es lograr un código limpio que funcione. La idea es que los requisitos sean traducidos a pruebas, de este modo, cuando las pruebas pasen se garantizará que el software cumple con los requisitos que se han establecido.

Glosario Programacion

XPath
XSLT



Apuntes

Actividades fundamentales en la Ingenieria de Software

Existen muchos diferentes procesos de software, pero todos deben incluir cuatro actividades
que son fundamentales para la ingeniería de software:
1. Especificación del software Tienen que definirse tanto la funcionalidad del software
como las restricciones de su operación.
2. Diseño e implementación del software Debe desarrollarse el software para cumplir
con las especificaciones.
3. Validación del software Hay que validar el software para asegurarse de que cumple
lo que el cliente quiere.
4. Evolución del software El software tiene que evolucionar para satisfacer las necesidades
cambiantes del cliente.

Causas Principales de los Fracasos en los proyectos de Software

Según el informe de Standish, las diez causas principales de los fracasos, por orden de importancia, son:

-Escasa participación de los usuarios

-Requerimientos y especificaciones incompletas

-Cambios frecuentes en los requerimientos y especificaciones

-Falta de soporte ejecutivo

-Incompetencia tecnológica

-Falta de recursos

-Expectativas no realistas

-Objetivos poco claros

-Cronogramas irreales

-Nuevas tecnologías

Principios del Manifiesto Agil

Individuos e interacciones sobre procesos y herramientas

Software que funciona sobre documentación exhaustiva

Colaboración con el cliente sobre negociación de contratos

Responder ante el cambio sobre seguimiento de un plan

Solucionario Ejercicios Capitulo 1 Ingenieria de software - Ian Sommervile (9na Edicion)

En esta nueva entrada de DatoByte les quiero Compartir la solucion a los ejercicios del capitulo 1 del libro  Ingenieria de software - Ian Sommervile (9na Edicion)

Actualmente me encuentro leyendo este libro el cual tengo que decir que su contenido me ha parecido muy interesante, espero a medica que finalice cada capitulo estarles compartiendo las respuestas a las preguntas.


1.1. Explique por qué el software profesional no sólo son programas que se desarrollan para un cliente.

Muchos suponen que el software es tan sólo otra palabra para los programas de cómputo. No obstante, cuando se habla de ingeniería de software, esto no sólo se refiere a los programas en sí, sino también a toda la documentación asociada y los datos de configuración requeridos para hacer que estos programas operen de manera correcta. Un sistema de software desarrollado profesionalmente es usualmente más que un solo programa. El sistema por lo regular consta de un número de programas separados y archivos de configuración que se usan para instalar dichos programas. Puede incluir documentación del sistema, que describe la estructura del sistema; documentación del usuario, que explica cómo usar el sistema, y los sitios web para que los usuarios descarguen información
reciente del producto.

1.2. ¿Cuál es la principal diferencia entre desarrollo de productos de software genéricos y desarrollo de software personalizado? ¿Qué significa esto en la práctica para los usuarios de productos de software genérico?

Una diferencia importante entre estos tipos de software es que, en productos genéricos, la organización que desarrolla el software controla la especificación del mismo. Para los productos personalizados, la organización que compra el software generalmente desarrolla y controla la especificación, por lo que los desarrolladores de software deben trabajar siguiendo dicha especificación.

1.3. ¿Cuáles son los cuatro atributos importantes que debe tener todo software profesional? Sugiera otros cuatro atributos que en ocasiones sean significativos.

Mantenimiento
El software debe escribirse de tal forma que pueda evolucionar para satisfacer las necesidades cambiantes de los clientes. Éste es un  atributo crítico porque el cambio del software es un requerimiento inevitable de un entorno empresarial variable.

Confiabilidad y seguridad
La confiabilidad del software incluye un rango de características que abarcan fiabilidad, seguridad y protección. El software confiable no tiene que causar daño físico ni económico, en caso de falla del
sistema. Los usuarios malintencionados no deben tener posibilidad de acceder al sistema o dañarlo.

Eficiencia
El software no tiene que desperdiciar los recursos del sistema, como la memoria y los ciclos del procesador. Por lo tanto, la eficiencia incluye capacidad de respuesta, tiempo de procesamiento, utilización de memoria, etcétera.

Aceptabilidad
El software debe ser aceptable al tipo de usuarios para quienes se diseña. Esto significa que necesita ser comprensible, utilizable y compatible con otros sistemas que ellos usan.

1.4. Además de los retos de la heterogeneidad, cambio empresarial y social, y confianza y seguridad, identifique otros problemas y retos que sea probable que enfrente la ingeniería de software en el siglo XXI. (Sugerencia: piense en el ambiente).

Pregunta abierta:
Pensando en el ambiente ->Tecnologia con obsolecencia programada
Sin pensar en el medio ambiente -> Capacidad de procesamiento


1.5. Con base en su conocimiento de algunos tipos de aplicación estudiados en la sección 1.1.2, explique, con ejemplos, por qué diferentes tipos de aplicación requieren técnicas especializadas de ingeniería de software, para apoyar su diseño y desarrollo.

Para cada tipo de sistema se usan distintas técnicas de ingeniería de software, porque el software tiene características muy diferentes. Por ejemplo, un sistema de control embebido en un automóvil es crítico para la seguridad y se quema en la ROM cuando se instala en el vehículo; por consiguiente, es muy costoso cambiarlo. Tal sistema necesita verificación y validación muy exhaustivas, de tal modo que se minimicen las probabilidades de volver a llamar para revisión a automóviles, después de su venta, para corregir los problemas del software. La interacción del usuario es mínima (o quizás inexistente), por lo que no hay necesidad de usar un proceso de desarrollo que se apoye en el prototipo de interfaz de usuario.

1.6. Explique por qué existen ideas fundamentales de la ingeniería de software que se aplican a todos los tipos de sistemas de software.

Las nociones fundamentales de la ingeniería de software son universalmente aplicables a todos los tipos de desarrollo de sistema.


1.7. Explique cómo el uso universal de la Web cambió los sistemas de software.

Los sistemas basados en la Web podían desarrollarse donde se tuviera acceso a dichos sistemas usando un navegador Web, en lugar de una interfaz de usuario de propósito específico. Esta situación condujo al desarrollo de una gran variedad de nuevos productos de sistemas que entregaban servicios innovadores, a los cuales se ingresaba desde la Web.

Así como estos productos de sistemas, el desarrollo de navegadores Web que corrieran pequeños programas y realizaran cierto procesamiento local condujo a una evolución en los negocios y el software organizacional. En lugar de elaborar software e implementarlo en las PC de los usuarios, el software se implementaba en un servidor Web. Este avance hizo mucho más barato cambiar y actualizar el software, pues no había necesidad de instalar el software en cada PC. También redujo costos, ya que el desarrollo de interfaces de usuario es bastante caro. En consecuencia, dondequiera que fuera posible hacerlo, muchos negocios se mudaron a la interacción basada en la Web con sistemas de software de la compañía.

1.8. Analice el hecho de si los ingenieros profesionales deben ser certificados en la misma forma que los médicos o abogados.

Rotundamente si, pues sobra decir que debe mantener estándares normales de honestidad e integridad. No debe usar sus habilidades y experiencia para comportarse de forma deshonesta o de un modo que desacredite la profesión de ingeniería de software. Sin embargo, existen áreas donde los estándares de comportamiento aceptable no están acotados por la legislación, sino por la noción más difusa de responsabilidad profesional.

1.9. Para cada una de las cláusulas del Código de ética ACM/IEEE que se muestra en la figura 1.3, sugiera un ejemplo adecuado que ilustre dicha cláusula.

Pregunta abierta:
-Publico: No realizar software que vaya en contra de la destruccion del ser humano, "Software para maquinas que destruyan a la sociedad"
-Cliente y empleador: Laborar bajo la modalidad de OutSourcing
-Producto: Desarrollar Softwares que sea certificable.
-Juicio: No usar las habilidades para cometer delitos informaticos
-Gestion: Actuar en pro del desarrollo de software profesional
-Profesion: Ejercer profesionalmente y promover el continuo desarrollo de la profesion
-Colegas: Trabajo en equipo de forma colaborativa
-Uno mismo: Autoaprendizaje en el campo de accion de la ingenieria de software


1.10. Para ayudar a contrarrestar el terrorismo, muchos países planean o desarrollaron sistemas de cómputo que siguen la pista a gran cantidad de sus ciudadanos y sus acciones. Claramente esto tiene implicaciones en cuanto a la privacidad. Discuta la ética de trabajar en el desarrollo de este tipo de sistema.

Pregunta abierta

Un conflicto ético es la participación en el desarrollo de sistemas militares y nucleares. Al respecto, algunas personas se sienten muy afectadas por estos temas y evitan participar en el desarrollo de algún sistema asociado con los sistemas militares. Otras más trabajarán en los sistemas militares, pero no en los de armamento. Incluso otras sentirán que la seguridad nacional es un principio fundamental y no tienen objeciones éticas para trabajar en sistemas de armamento.

En tal situación es importante que tanto empleadores como empleados dejen en claro con antelación sus percepciones o puntos de vista. Cuando una organización participa en trabajo militar o nuclear, debe contar con la capacidad de especificar que los empleados tienen la voluntad de aceptar cualquier trabajo asignado. De igual forma, si un empleado toma la responsabilidad y deja en claro que no quiere trabajar en tales sistemas, los empleadores no tendrán que presionarlo para que éste lo haga más tarde.

Ingenieria de Software - ¿Por que estudiar Ingenieria de sistemas?

En esta nueva entrada de DatoByte les comparto una opinión algo personal desde el punto de vista de la experiencia que he tenido en este corto periodo de 5 años.

Iniciare diciendo que me siento muy orgullo de haber elegido esta carrera profesional,  de nunca cambiar de opinión mientras la estaba estudiando y de haber culminado mis estudios, recuerdo el día en el que realice mi primer algoritmo de "Hola mundo" para ese entonces nuestro profesor nos enseño en uno de los mejores lenguajes de programación que he conocido, hablo de JAVA, ver en pantalla un simple mensaje despierta mas motivación para saber dominar mas a fondo el hecho de programar.

Cada vez que aprobaba una materia que tenia relación con ejercer en este amplio mundo de la ingeniería de sistemas sentía un gran cambio en mi forma de pensar, materias que van desde Calculo, Matemáticas discretas, Geometría vectorial, de las cuales posiblemente sean las mas complicadas de aprobar, pasando por materias de gran interés como Circuitos digitales, Arquitectura de computadores, hasta posiblemente las materias que nos hacían quemar mas neuronas aquellas relacionadas con aprender una nueva sentencia y crear nuevas lineas de código como por ejemplo Lenguajes de programación. Todas esas materias aportan de gran manera un gran conocimiento que todo ingeniero de sistemas debe aprender a dominar, entiéndase dominar al menos conocer su aplicación, valga este ultimo comentario como Escudo ante la popular mentira "Para que voy a aprender eso si no lo voy a usar" sin embargo como ingeniero de sistemas puedo afirmar que todo es de vital interés en esta gran carrera que proyecta nuevos horizontes.

La ingeniería de sistemas se interesa por todos los aspectos del desarrollo de sistemas basados en computadoras, incluidos hardware, software e ingeniería de procesos, en este punto hacemos una división en 3 enfoques:

-Ingeniería de Hardware:

Los ingenieros informáticos de hardware trabajan en el diseño, desarrollo y fabricación de equipamientos informáticos. Se especializan en áreas tales como las comunicaciones, los sistemas de control, la robótica, los microprocesadores o los dispositivos semiconductores. Deben tener en cuenta la eficiencia, la seguridad y los factores ambientales.

-Ingeniería de Procesos:

Es la integración sistémica de metodologías y procedimientos de diversas áreas de las ciencias naturales y la Ingeniería, que se aplican al diseño, administración, mejoramiento e innovación de procesos, especialmente de base fisicoquímica y biotecnológica. ​​​​​​​​​​​​​​​​​​​​​​

-Ingeniería de Software:

La ingeniería de software es una disciplina de la ingeniería que se interesa por todos los aspectos de la producción de software, Este ultimo en mi opinión es posiblemente el campo de acción mas grande que se posee un ingeniero de sistemas y esto solo por un comentario "La ingeniería de software no tiene limites naturales a su potencial", esto implica que prácticamente si algo se puede imaginar, ese algo puede ser convertido en software o al menos tendrá un campo de software.

Acorde a el libro de Ingeniería de software de Ian Sommerville La ingeniería de software es importante por dos razones:
1. Cada vez con mayor frecuencia, los individuos y la sociedad se apoyan en los avanzados sistemas de software. Por ende, se requiere producir económica y rápidamente sistemas confiables.

2. A menudo resulta más barato a largo plazo usar métodos y técnicas de ingeniería de software para los sistemas de software, que sólo diseñar los programas como si fuera un proyecto de programación personal. Para muchos tipos de sistemas, la mayoría de los costos consisten en cambiar el software después de ponerlo en operación.

Sin embargo el asunto a destacar es Ingeniería de sistemas y no una de estas en particular, sin embargo es bueno aclarar esta posible división de la ingeniería de sistemas.

Ahora bien si todo lo anterior no te ha convencido de Estudiar una Ingeniería de sistemas no te preocupes, Posiblemente no sea la emoción que estas buscando o tal vez pienses que no es para ti, pero ten en cuenta que es una de las carreras que mas le ha aportado en los últimos años al desarrollo del ser humano, sencillamente la tecnología y el ser humano se han convertido en un par de entes con una relación simbiotica, ya que mutuamente se encuentran en constante colaboración, a tal punto hemos llegado que a diaria un gran porcentaje de personas tienen acceso a algún sistema, y en este momento estas viendo esta publicación en el sistema de Blogger, usando un software como tu navegador y también tu sistema operativo, y ni que decir de el computador o celular desde el que estas viendo, todos esos fueron pensados por ingenieros de sistemas, así que si quieres contribuir con este mundo tecnológico es mas que suficiente para que inicies esta travesía por el mundo de la Ingeniería de sistemas.

Por ultimo, para finalizar esta entrada, me quiero despedir con lo siguiente:

public class BienvenidoNuevoIngeniero {
  public static void main(String[] args) {
    System.out.println("Hola mundo");
    System.out.println("Estudia Ingenieria de sistemas");
    System.out.println("Datobyte te desea lo mejor");
  }
}

Atributos esenciales del buen software

En esta nueva entrada de DatoByte les quiero enseñar acerca de los Atributos esenciales del buen software

El software debe entregar la funcionalidad y el funcionamiento requeridos por el usuario al él mismo, y debe ser mantenible, confiable y aceptable.


Mantenimiento 
El software debe escribirse de tal forma que pueda evolucionar para satisfacer las necesidades cambiantes de los clientes. Éste es un atributo crítico porque el cambio del software es un requerimiento inevitable de un entorno empresarial variable.

Confiabilidad y seguridad 
La confiabilidad del software incluye un rango de características que abarcan fiabilidad, seguridad y protección. El software confiable no tiene que causar daño físico ni económico, en caso de falla del sistema. Los usuarios malintencionados no deben tener posibilidad de acceder al sistema o dañarlo.

Eficiencia 
El software no tiene que desperdiciar los recursos del sistema, como la memoria y los ciclos del procesador. Por lo tanto, la eficiencia incluye capacidad de respuesta, tiempo de procesamiento, utilización de memoria, etcétera.

Aceptabilidad 
El software debe ser aceptable al tipo de usuarios para quienes se diseña. Esto significa que necesita ser comprensible, utilizable y compatible con otros sistemas que ellos usan.

Básicamente estos 4 aspectos pueden ser considerados como indicadores al momento de calificar un software.

XSLT (stylesheet) Para ELIMINAR / BORRAR / LIMPIAR nodos sin datos de un xml

En esta nueva entrada de DatoByte les quiero Compartir mi experiencia con la elaboración de un XSLT Para ELIMINAR / BORRAR / LIMPIAR nodos sin datos de un xml

Antes que nada cabe mencionar que el siguiente stylesheet(xsl) es producto de la necesidad de hacer una limpieza a todos aquellos nodos que al momento de procesar no aportan valor alguno, y que a su vez en el respectivo esquema (XSD) dichos campos se encuentren como opcionales, ya que si en la firma  se encuentran como obligatorios lo ideal es no  eliminarlos.

Partiendo de esta necesidad, se realiza xsl que permita dicha conversión como explicación general, el siguiente codigo utiliza recursividad, partiendo de que existen basicamente 2 tipos de nodos, Nodos complejos y Nodos simples, siendo asi se realiza un recorrido RECURSIVO teniendo en cuenta si el nodo seleccionado tiene nodos Hijos, si este tiene hijos es por que es un nodo complejo, por ende se hace un llamado a el template nodoPadre en caso contrario se realizara un llamado a el template templateNodo el cual se aplica a los Nodos simples. de esta manera se va construyendo de forma recursiva el xml completo.

El sgte stylesheet:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:exsl="http://exslt.org/common"
exclude-result-prefixes="exsl">

<!--=================================================================-->
<!--               Transformacion para Borrar Nodos VACIOS en xml                   -->
<!--               Tomado de Datobyte.blogSpot.com                      -->
<!--               Desarrollado por Wilfer Giraldo                      -->
<!--=================================================================-->

<xsl:output method="xml" omit-xml-declaration="yes" />

<xsl:template match="/">
<xsl:variable name="cargaTemp">
<xsl:call-template name="nodoPadre">
<xsl:with-param name="nombreNodo" select="name(./*)" />
<xsl:with-param name="nameSpaceInput" select="namespace-uri(./*)" />
<xsl:with-param name="datoNodo" select="./*" />
<xsl:with-param name="hijos" select="count(./*/child::*)" />
</xsl:call-template>
</xsl:variable>
<xsl:copy-of  select="exsl:node-set($cargaTemp)/extra/*"  />
</xsl:template>

<xsl:template name="nodoPadre">
<xsl:param name="nombreNodo" />
<xsl:param name="nameSpaceInput" />
<xsl:param name="datoNodo" />
<xsl:param name="hijos" />

<xsl:choose>
<xsl:when test="$hijos &gt; 0 ">
<xsl:variable name="contenido">
<xsl:for-each select="$datoNodo/child::*">
<xsl:variable name="cargaTemp">
<xsl:call-template name="nodoPadre">
<xsl:with-param name="nombreNodo" select="name()" />
<xsl:with-param name="nameSpaceInput" select="namespace-uri()" />
<xsl:with-param name="datoNodo" select="." />
<xsl:with-param name="hijos" select="count(*)" />
</xsl:call-template>
</xsl:variable>
<xsl:choose>
<xsl:when test="$cargaTemp != ''">
<extra>
<xsl:copy-of  select="exsl:node-set($cargaTemp)/extra/*"  />
</extra>
</xsl:when>
</xsl:choose>

</xsl:for-each>

</xsl:variable>
<xsl:choose>
<xsl:when test="$contenido != ''">
<extra>
<xsl:element name="{$nombreNodo}" namespace="{$nameSpaceInput}">
<xsl:copy-of select="exsl:node-set($contenido)/extra/*" />
</xsl:element>
</extra>
</xsl:when>
</xsl:choose>
</xsl:when>
<xsl:otherwise>
   
<xsl:variable name="contenido2" >
<xsl:value-of select="$datoNodo" />
</xsl:variable>
<xsl:variable name="contenido">
<extra>
<xsl:call-template name="templateNodo">
<xsl:with-param name="nombreNodo" select="$nombreNodo" />
<xsl:with-param name="datoNodo" select="$contenido2" />
<xsl:with-param name="nameSpaceInput" select="$nameSpaceInput" />
</xsl:call-template>
</extra>
</xsl:variable>
<extra>
<xsl:copy-of select="exsl:node-set($contenido)/extra/*" />
</extra>
</xsl:otherwise>
</xsl:choose>
     
    </xsl:template>
 
<xsl:template name="templateNodo">
<xsl:param name="nombreNodo" />
<xsl:param name="datoNodo" />
<xsl:param name="nameSpaceInput" />
<xsl:choose>
<xsl:when test="$datoNodo != ''">
<xsl:element name="{$nombreNodo}" namespace="{$nameSpaceInput}">
<xsl:value-of select="$datoNodo" />
</xsl:element>
</xsl:when>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>

Aplicado al sgte XML:

<db:datos xmlns:db="datobyte.blogspot.com">
<ubicacionFuente>
<pais>Colombia</pais>
<departamento/>
<municipio/>
</ubicacionFuente>
<nombrePersona>
<primerNombre>WILFER</primerNombre>
<segundoNombre/>
<primerApellido>GIRALDO </primerApellido>
<segundoApellido/>
</nombrePersona>
<sexo>MASCULINO</sexo>
<email/>
<blog>datobyte.blogspot.com</blog>
</db:datos>

Obtiene Como resultado el Sgte XML:

<db:datos xmlns:db="datobyte.blogspot.com">
<ubicacionFuente>
<pais>Colombia</pais>
</ubicacionFuente>
<nombrePersona>
<primerNombre>WILFER</primerNombre>
<primerApellido>GIRALDO </primerApellido>
</nombrePersona>
<sexo>MASCULINO</sexo>
<blog>datobyte.blogspot.com</blog>
</db:datos>

XSLT (stylesheet) Para Transformar JSON A XML

En esta nueva entrada de DatoByte les quiero Compartir mi experiencia con la elaboracion de un XSLT para Transformar Json a XML

Antes del codigo algo de teoria.

JSON, acrónimo de JavaScript Object Notation, es un formato de texto ligero para el intercambio de datos. JSON es un subconjunto de la notación literal de objetos de JavaScript aunque hoy, debido a su amplia adopción como alternativa a XML, se considera un formato de lenguaje independiente.

Una de las supuestas ventajas de JSON sobre XML como formato de intercambio de datos es que es mucho más sencillo escribir un analizador sintáctico (parser) de JSON. En JavaScript, un texto JSON se puede analizar fácilmente usando la función eval(), lo cual ha sido fundamental para que JSON haya sido aceptado por parte de la comunidad de desarrolladores AJAX, debido a la ubicuidad de JavaScript en casi cualquier navegador web.

Si bien es frecuente ver JSON posicionado contra XML, también es frecuente el uso de JSON y XML en la misma aplicación. Por ejemplo, una aplicación de cliente que integra datos de Google Maps con datos meteorológicos en SOAP hacen necesario soportar ambos formatos.

También cabe mencionar que el siguiente código solo es aplicable  para la convención PARKER bajo otras convenciones posiblemente toque realizar algunas modificaciones.

Para mas información de las convenciones JSON te sugiero revisar el sgte Link Convensiones Json y XML

El sgte stylesheet

<xsl:stylesheet version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xs="http://www.w3.org/2001/XMLSchema"
  xmlns:json="http://www.ibm.com/xmlns/prod/2009/jsonx"
  xmlns:exsl="http://exslt.org/common"
  exclude-result-prefixes="xsl xs json exsl">
<xsl:output indent="yes" encoding="UTF-8" omit-xml-declaration="yes" />
<xsl:strip-space elements="*" />



<!--====================================================================-->
<!--               Transformacion Texto en Json a XML                   -->
<!--               Tomado de Datobyte.blogSpot.com                      -->
<!--               Desarrollado por Wilfer Giraldo                      -->
<!--====================================================================-->
<!--Descripcion: La siguiente Transformacion convierte texto Json       -->
<!--             a estructura XML, Usando la convencion PARKER          -->
<!--Convencion parker: http://wiki.open311.org/JSON_and_XML_Conversion/ -->
<!--             tomar especial atencion a los Input y output de        -->
<!--             cada template, estatransformacion usa recursividad     -->
<!--====================================================================-->
<!--NOTA ESPECIAL: Esta transformacion trabaja con tipos de datos       -->
<!--               String y int                                         -->
<!--====================================================================-->


<xsl:variable name="quot" select="'&quot;'" />

<xsl:template match="/*">
  <xsl:variable name="t1">
    <xsl:call-template name="object">
     <xsl:with-param name="json-in" select="." />
    </xsl:call-template>
  </xsl:variable>
  <xsl:apply-templates select="exsl:node-set($t1)/output/*" mode="copy-sans-namespace" />
</xsl:template>

<xsl:template match="*" mode="copy-sans-namespace">
  <xsl:element name="{name()}" namespace="{namespace-uri()}">
    <xsl:copy-of select="@*"/>
    <xsl:apply-templates mode="copy-sans-namespace" />
  </xsl:element>
</xsl:template>

<xsl:template name="field">
  <!-- Input like: "Open": "25.15" bla -->
  <!-- output like: <so:output><Open>25.15</Open></so:output> <so:extra>bla</so:extra> -->
  <xsl:param name="json-in" />
  <xsl:variable name="field-name" select="substring-before(substring-after($json-in,$quot),$quot)" />
  <xsl:variable name="remainder" select="substring-after($json-in,':')" />
  <xsl:call-template name="value">
    <xsl:with-param name="json-in" select="$remainder" />
    <xsl:with-param name="parent-ele" select="$field-name" />
  </xsl:call-template>
</xsl:template>

<xsl:template name="fields">
  <!-- Input like: "Open": "25.15" , "High": "25.15" } bla -->
  <!-- output like: <so:output><Open>25.15</Open><High>25.15</High></so:output> <so:extra>} bla</so:extra> -->
  <xsl:param name="json-in" />
  <xsl:variable name="n" select="normalize-space($json-in)" />
  <xsl:choose>
    <xsl:when test="substring($n,1,1) = $quot">
    <xsl:variable name="t1">
        <xsl:call-template name="field">
          <xsl:with-param name="json-in" select="$n" />
      </xsl:call-template>
    </xsl:variable>
    <xsl:variable name="t2" select="normalize-space( exsl:node-set($t1)/extra) " />
    <xsl:variable name="t3">
      <xsl:choose>
      <xsl:when test="substring($t2,1,1)=','">
            <xsl:call-template name="fields">
              <xsl:with-param name="json-in" select="substring-after($t2,',')" />
          </xsl:call-template>
      </xsl:when>
      <xsl:when test="$t2">
        <extra><xsl:value-of select="$t2" /></extra>
      </xsl:when>
      </xsl:choose>
    </xsl:variable>
    <output>
      <xsl:copy-of select="exsl:node-set($t1)/output/* | exsl:node-set($t3)/output/*" />
    </output>
    <xsl:copy-of select="exsl:node-set($t3)/extra" />
  </xsl:when>
    <xsl:when test="$n">
      <extra><xsl:value-of select="$n" /></extra>
    </xsl:when>
  </xsl:choose>
</xsl:template>

<xsl:template name="object">
  <!-- Input like: { X } bla -->
  <!-- output like: <so:output>fields(X)</so:output> <so:extra>bla</so:extra> -->
  <xsl:param name="json-in" />
  <xsl:param name="parent-ele" select="''" />
  <xsl:variable name="t1" select="normalize-space(substring-after($json-in,'{'))" />
  <xsl:variable name="t2">
    <xsl:call-template name="fields">
      <xsl:with-param name="json-in" select="$t1" />
    </xsl:call-template>
  </xsl:variable>
  <xsl:variable name="t3" select="normalize-space(substring-after( exsl:node-set($t2)/extra, '}'))" />
  <output>
    <xsl:choose>
    <xsl:when test="$parent-ele">
      <xsl:element name="{$parent-ele}">
        <xsl:copy-of select="exsl:node-set($t2)/output/node()" />
      </xsl:element>
    </xsl:when>
      <xsl:otherwise>  
        <xsl:copy-of select="exsl:node-set($t2)/output/node()" />
      </xsl:otherwise>  
    </xsl:choose>
  </output>
  <xsl:if test="$t3">
    <extra><xsl:value-of select="$t3" /></extra>
  </xsl:if>
</xsl:template>

<xsl:template name="objects">
  <xsl:param name="json-in" />
  <xsl:param name="parent-ele" />
  <xsl:variable name="n" select="normalize-space($json-in)" />
  <xsl:choose>
    <xsl:when test="substring($n,1,1) = '{'">
    <xsl:variable name="t1">
        <xsl:call-template name="object">
          <xsl:with-param name="json-in" select="$n" />
          <xsl:with-param name="parent-ele" select="$parent-ele" />
      </xsl:call-template>
    </xsl:variable>
    <xsl:variable name="t2" select="normalize-space( exsl:node-set($t1)/extra) " />
    <xsl:variable name="t3">
      <xsl:choose>
      <xsl:when test="substring($t2,1,1)=','">
            <xsl:call-template name="objects">
              <xsl:with-param name="json-in" select="normalize-space(substring-after($t2,','))" />
              <xsl:with-param name="parent-ele" select="$parent-ele" />
          </xsl:call-template>
      </xsl:when>
      <xsl:when test="$t2">
        <extra><xsl:value-of select="$t2" /></extra>
      </xsl:when>
      </xsl:choose>
    </xsl:variable>
    <output>
      <xsl:copy-of select="exsl:node-set($t1)/output/* | exsl:node-set($t3)/output/*" />
    </output>
    <xsl:copy-of select="exsl:node-set($t3)/extra" />
  </xsl:when>
    <xsl:when test="$n">
      <extra><xsl:value-of select="$n" /></extra>
    </xsl:when>
  </xsl:choose>
</xsl:template>

<xsl:template name="array">
  <!-- Input like: [ X1 X2 ] bla -->
  <!-- output like: <so:output><Y>X1</Y><Y>X2</Y></so:output> <so:extra>}bla</so:extra> -->
  <xsl:param name="json-in" />
  <xsl:param name="parent-ele" />
  <xsl:variable name="t1" select="normalize-space(substring-after($json-in,'['))" />
  <xsl:variable name="t2">
    <xsl:call-template name="objects">
      <xsl:with-param name="json-in" select="$t1" />
      <xsl:with-param name="parent-ele" select="$parent-ele" />
    </xsl:call-template>
  </xsl:variable>
  <xsl:variable name="t3" select="normalize-space(substring-after( exsl:node-set($t2)/extra, ']'))" />
  <xsl:copy-of select="exsl:node-set($t2)/output" />
  <xsl:if test="$t3">
    <extra><xsl:value-of select="$t3" /></extra>
  </xsl:if>
</xsl:template>

<xsl:template name="value">
  <!-- Input like either array, object or string -->
  <!-- output like either array, object or string -->
  <xsl:param name="json-in" />
  <xsl:param name="parent-ele" />
  <xsl:variable name="first-letter" select="substring(normalize-space($json-in),1,1)" />
  <xsl:choose>
    <xsl:when test="$first-letter='{'">
    <xsl:call-template name="object">
        <xsl:with-param name="json-in" select="$json-in" />
        <xsl:with-param name="parent-ele" select="$parent-ele" />
    </xsl:call-template>
    </xsl:when>
    <xsl:when test="$first-letter='['">
    <xsl:call-template name="array">
        <xsl:with-param name="json-in" select="$json-in" />
        <xsl:with-param name="parent-ele" select="$parent-ele" />
    </xsl:call-template>
    </xsl:when>
    <xsl:when test="$first-letter=$quot">
    <xsl:call-template name="string">
        <xsl:with-param name="json-in" select="$json-in" />
        <xsl:with-param name="parent-ele" select="$parent-ele" />
    </xsl:call-template>
    </xsl:when>
    <xsl:when test="$first-letter='0' or $first-letter='1' or $first-letter='2' or $first-letter='3' or $first-letter='4' or $first-letter='5' or $first-letter='6' or $first-letter='7' or $first-letter='8' or $first-letter='9'">
    <xsl:call-template name="entero">
        <xsl:with-param name="json-in" select="$json-in" />
        <xsl:with-param name="parent-ele" select="$parent-ele" />
    </xsl:call-template>
    </xsl:when>
  <xsl:otherwise>
    <output>ERROR</output>
  </xsl:otherwise>
  </xsl:choose>
</xsl:template>

<xsl:template name="string">
  <!-- Input like: "X" bla -->
  <!-- output like: <so:output><Y>X</Y></so:output> <so:extra>bla</so:extra> -->
  <xsl:param name="json-in" />
  <xsl:param name="parent-ele" />
  <xsl:variable name="value" select="substring-before(substring-after($json-in,$quot),$quot)" />
  <xsl:variable name="remainder" select="normalize-space(substring-after(substring-after($json-in,$quot),$quot))" />
  <output>
   <xsl:element name="{$parent-ele}">
    <xsl:value-of select="$value" />
   </xsl:element>
  </output>
  <xsl:if test="$remainder">
    <extra><xsl:value-of select="$remainder" /></extra>
  </xsl:if>
</xsl:template>

<xsl:template name="entero">
  <!-- Input like: "X" bla -->
  <!-- output like: <so:output><Y>X</Y></so:output> <so:extra>bla</so:extra> -->
  <xsl:param name="json-in" />
  <xsl:param name="parent-ele" />




  <xsl:variable name="value">
  <xsl:call-template name="loopNumber">
<xsl:with-param name="json-in" select="$json-in" />
</xsl:call-template>
  </xsl:variable>
  <xsl:variable name="remainder" select="normalize-space(substring-after($json-in,$value))" />
  <output>
   <xsl:element name="{$parent-ele}">
    <xsl:value-of select="$value" />
   </xsl:element>
  </output>
  <xsl:if test="$remainder">
    <extra><xsl:value-of select="$remainder" /></extra>
  </xsl:if>
</xsl:template>

 <xsl:template name="loopNumber">
   <xsl:param name="json-in" />
   <xsl:variable name="first-number" select="substring(normalize-space($json-in),1,1)" />
  <xsl:choose>
    <xsl:when test="$first-number='0' or $first-number='1' or $first-number='2' or $first-number='3' or $first-number='4' or $first-number='5' or $first-number='6' or $first-number='7' or $first-number='8' or $first-number='9'">
      <xsl:variable name="t1">
     <xsl:call-template name="loopNumber">
       <xsl:with-param name="json-in" select="substring-after($json-in,$first-number)" />
     </xsl:call-template>
      </xsl:variable>
      <xsl:value-of select="concat($first-number,t1)" />
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="''" />
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

</xsl:stylesheet>

Aplicado al sgte JSON (OJO A LA ETIQUETA ENVOLVENTE, es necesario que exista al menos esta etiqueta sin importar el nombre de esta):

<JsonInput>{
"informacion": {
"persona": {
"numeroDocumento": "123456",
"nombres": {
"Nombre": "Wilfer",
"Apellido": "Giraldo",
}
},
"estadoPersona": "ACTIVA",
"correosElectronicos": [{
"correo": "leuco18",
"servidor": "Hotmail.com",
"fecha": "28/07/2010"
},
{
"correo": "leuco18",
"servidor": "Google.com",
"fecha": "01/05/2008"
},
{
"correo": "leuco18",
"servidor": "Facebook",
"fecha": "12/09/2012"
}],
"otrosDatos": "NO"
}
}</JsonInput>

Obtiene Como resultado el Sgte XML:

<informacion>
<persona>
<numeroDocumento>123456</numeroDocumento>
<nombres>
<Nombre>Wilfer</Nombre>
<Apellido>Giraldo</Apellido>
</nombres>
</persona>
<estadoPersona>ACTIVA</estadoPersona>
<correosElectronicos>
<correo>leuco18</correo>
<servidor>Hotmail.com</servidor>
<fecha>28/07/2010</fecha>
</correosElectronicos>
<correosElectronicos>
<correo>leuco18</correo>
<servidor>Google.com</servidor>
<fecha>01/05/2008</fecha>
</correosElectronicos>
<correosElectronicos>
<correo>leuco18</correo>
<servidor>Facebook</servidor>
<fecha>12/09/2012</fecha>
</correosElectronicos>
<otrosDatos>NO</otrosDatos>
</informacion>

Espero te sea util este codigo XSL,No olvides de dejar un comentario

10 Preguntas Claves que debe saber un ingeniero de software

Para esta publicación dare por sentado que conoces algo de programación por ende quiero iniciar esta entrada trayendo como recuerdo el día en el que por primera vez observaste el  algoritmo para mostrar "HOLA MUNDO", quiero mencionar que a nivel personal visualice un mundo de posibilidades y me motive aun mas para conocer el mundo de la ingeniería de software.

Son muchas las habilidades que debe tener un Ingeniero de software, un pequeño listado de estas habilidades es el sgte
– Dirige y coordina proyectos de desarrollo y mantenimiento de software.
– Supervisa las etapas de la vida de un proyecto de desarrollo de software.
– Dirige equipos de trabajo compuestos por analistas, diseñadores y programadores.
– Analiza y selecciona nuevas técnicas y herramientas existentes en el mercado tecnológico y del software.
– Analiza y diseña aplicaciones de software.
– Realiza pruebas de verificación, integración y rendimiento de las aplicaciones de software.
– Integra sistemas existentes susceptibles de interrelacionarse.
– Brinda asesoría a usuarios en la resolución de problemas relacionados con los sistemas de software.
– Realiza consultoría individual o en colaboración con otros profesionistas.
– Administra sistemas de bases de datos.
– Participa en formular políticas de seguridad y técnicas criptográficas en empresas e instituciones donde se desempeñe.
– Verifica que el software desarrollado cumpla con la legislación en vigor.

y ni que decir de su campo laboral, sin embargo

Ahora bien a continuación les comparto 10 preguntas claves que todo ingeniero de software
debe saber responder.

¿Qué es software? 

Programas de cómputo y documentación asociada.
Los productos de software se desarrollan para un cliente en particular o para un mercado en general.

¿Cuáles son los atributos del buen software? 

El buen software debe entregar al usuario la funcionalidad y el desempeño requeridos, y debe ser sustentable, confiable y utilizable.

¿Qué es ingeniería de software? 

La ingeniería de software es una disciplina de la ingeniería que se interesa por todos los aspectos de la producción de software.

¿Cuáles son las actividades fundamentales de la ingeniería de software?

Especificación, desarrollo, validación y evolución del software.

¿Cuál es la diferencia entre ingeniería de software y ciencias de la computación?

Las ciencias de la computación se enfocan en teoría y fundamentos; mientras la ingeniería de software se enfoca en el sentido práctico del desarrollo y en la distribución de software.

¿Cuál es la diferencia entre ingeniería de software e ingeniería de sistemas?

La ingeniería de sistemas se interesa por todos los aspectos del desarrollo de sistemas basados en computadoras, incluidos hardware, software e ingeniería de procesos. La ingeniería de software es parte de este proceso más general.

¿Cuáles son los principales retos que enfrenta la ingeniería de software?

Se enfrentan con una diversidad creciente, demandas por tiempos de distribución limitados y desarrollo de software confiable.

¿Cuáles son los costos de la ingeniería de software?

Aproximadamente 60% de los costos del software son de desarrollo, y 40% de prueba. Para el software elaborado específicamente, los costos de evolución superan con frecuencia los costos de desarrollo.

¿Cuáles son los mejores métodos y técnicas de la ingeniería de software?

Aun cuando todos los proyectos de software deben gestionarse y desarrollarse de manera profesional, existen diferentes técnicas que son adecuadas para distintos tipos de sistema. Por ejemplo, los juegos siempre deben diseñarse usando una serie de prototipos, mientras que los sistemas críticos de control de seguridad requieren de una especificación completa y analizable para su desarrollo. Por lo tanto, no puede decirse que un método sea mejor que otro.

¿Qué diferencias ha marcado la Web a la ingeniería de software?

La Web ha llevado a la disponibilidad de servicios de software y a la posibilidad de desarrollar sistemas basados en servicios distribuidos ampliamente. El desarrollo de sistemas basados en Web ha conducido a importantes avances en lenguajes de programación y reutilización de software.





Bibliografia:
Ingenieria de software, 9na edicion - Ian Sommerville.

Herramientas para Emprendedores

En esta nueva entrada de DatoByte les quiero comentar acerca de un conjunto de herramientas para Emprendedores que te pueden ser útil al momento de iniciar tu emprendimiento sin importar el tipo, aunque supongo que si estas en este blog lo mas probable es que hablemos de un producto de software, sea cual sea estas herramientas no solo te servirán para tu emprendimiento, si no también en diferentes situación que lo meriten.

Las siguientes herramientas serán presentadas enunciando su nombre, una breve descripción y el sitio web.

Cabe mencionar que en este listado encontraras herramientas que en su mayoria seran gestionadas de forma WEB, esto con el fin de permitir a los usuarios la facilidad en el trabajo colaborativo

BMCanvas (Elaboracion Canvas):

The Bussines Model Canvas es una herramienta de gestión estratégica y empresarial . Se le permite describir , diseño , desafío, inventar , y el pivote de su modelo de negocio.

Assembla (Gestion de Proyectos):

Su principal producto es ofrecernos Espacios de Trabajo (Project Workspaces) Alojados a través de Assembla, estos ofrecen elementos para la administración de proyectos de software como seguimiento de defectos y tareas, repositorios subversion y Scrum. Estos servicios están dirigidos principalmente a programadores y  desarrolladores de software ofreciendo control de versiones como subversion,  Git y Mercurial. Un tercio de sus herramientas son herramientas de colaboración, entre ellas wikis y mensajes.

Dropbox (Almacenar Archivos):

Es un servicio de alojamiento de archivos multiplataforma en la nube, operado por la compañía Dropbox. El servicio permite a los usuarios almacenar y sincronizar archivos en línea y entre ordenadores y compartir archivos y carpetas con otros usuarios y con tabletas y móviles. Existen versiones gratuitas y de pago, cada una de las cuales tiene opciones variadas. La versión móvil está disponible para Android, Windows Phone, Blackberry e iOS (Apple).

Google Drive y Google Docs (Almacenar Archivos)

Al igual que Dropbox, Google Drive te permitira almacenar y sincronizar archivos en la Nube, cabe mencionar que al fusionarlo con Google Docs permite que los archivos de tipo oficina (Excel, Word y PowerPoint) puedan ser trabajados de forma colaborativa, lo cual también se puede realizar en Dropbox, cualquiera de los 2 son muy útiles en cuanto a estos aspectos .

Bitly (Cortador de links):

Su funcionamiento principal y acortar los enlaces que son demasiados extensos.

Bitrix24 (Gestion de proyectos):

Es una herramienta un poco avanzada  con ella se puede obtener un eficaz portal de Intranet que incluye lo último en comunicación integrada, colaboración en línea, redes sociales, gestión de documentos, flujo documentario, herramientas de gestión de tareas y otras grandes ventajas.

MindMeister (Mapas mentales):

Es una herramienta de elaboración de mapas mentales en línea que te permite capturar, desarrollar y compartir ideas de forma visual. Más de 4 millones de personas ya usan nuestro galardonado editor de mapas mentales para generar lluvias de ideas, tomar notas, planear proyectos y realizar muchas otras tareas creativas. MindMeister está basado totalmente en web, ¡lo que quiere decir que no necesitas descargar ni actualizar nada! Independientemente de si trabajas con Windows, Mac OS o Linux, siempre podrás acceder a tus mapas mentales desde tu propio navegador web.

EverNote (Herramienta de oficina):

Tomar notas a un nuevo nivel con Evernote , la aplicación de productividad que mantiene sus proyectos, ideas, inspiración y práctica en todos tus dispositivos digitales .

Hootsuite (Redes Sociales):

Con la capacidad de administrar todas sus redes sociales y programar mensajes para publicarlos en el futuro, Hootsuite le permite ampliar el alcance de sus actividades en las plataformas sociales.

Mikogo (Reuniones Virtuales):

Herramienta alemana; muy segura, simple y con gran calidad gráfica. Intercambie y muestre el contenido de su pantalla a varias personas. Ideal para reuniones online, presentaciones y soporte remoto.

PikToChart (Imagenes e infografias):

Es una aplicación de diseño infografía fácil que requiere muy poco esfuerzo para producir gráficos hermoso, de alta calidad.

Producteev (Gestion de Tareas):

Es un gestor de tareas tanto para individuales como para equipos, pero con una filosofía un poco distinta a otros gestores de tareas para equipos. Aquí, tú eres un usuario apuntado a distintos workspaces o espacios de trabajo. En cada uno de ellos puede haber una o varias personas coordinándose para llevar a cabo las tareas.

Trello (Gestion de proyectos):

Es una herramienta de gestión de proyectos que hace que la colaboración sea sencilla y, me atrevería a decir, incluso divertida. La realidad es que sirve para casi todo, ya estés organizando proyectos en el trabajo, tareas del hogar, viajes o cualquier otra cosa. Aquí van algunas maneras en las que puedes utilizar Trello para organizarte.



Conoces alguna otra herramienta? Compartela con nosotros en los comentarios.

SQL - Consultas SELECT MultiTabla

Combinaciones internas - INNER JOIN

Las combinaciones internas se realizan mediante la instrucción INNER JOIN. Devuelven únicamente aquellos registros/filas que tienen valores idénticos en los dos campos que se comparan para unir ambas tablas. Es decir aquellas que tienen elementos en las dos tablas, identificados éstos por el campo de relación.

La mejor forma de verlo es con un diagrama de Venn que ilustre en qué parte de la relación deben existir registros:

INNER-JOIN

En este caso se devuelven los registros que tienen nexo de unión en ambas tablas.

Esto puede ocasionar la desaparición del resultado de filas de alguna de las dos tablas, por tener valores nulos, o por tener un valor que no exista en la otra tabla entre los campos/columnas que se están comparando.

Su sintaxis es:

SELECT T1.Col1, T1.Col2, T1.Col3, T2.Col7

FROM Tabla1 T1 INNER JOIN Tabla2 T2 ON T1.Col1 = T2.Col1

Por ejemplo suponiendo tenemos las siguientes tablas (Carro, Carroceria)

IdCarro	NombreCarro	IdCarroceria
1	Hiunday i35	1
2	Chevrolet Spark GT	2
3	Mazda 3	2
4	Renault Stepway	3
5	Ford Explorer	NULL
6	Nissan Sentra	NULL

IdCarroceria	NombreCarroceria
1	Sedan
2	HastBack
3	Camioneta
4	Convertible
5	Limosina
6	Furgoneta

Al momento de ejecutar la sgte Consulta con INNER JOIN:

SELECT T1. IdCarro, T1. NombreCarro, T1. IdCarroceria, T2. IdCarroceria, T2. NombreCarroceria

FROM Carro T1

INNER JOIN Carroceria T2 ON T1. IdCarroceria= T2. IdCarroceria

 Se obtendrá

INNER JOIN

IdCarro	NombreCarro	IdCarroceria	IdCarroceria	NombreCarroceria
1	Hiunday i35	1	1	Sedan
2	Chevrolet Spark GT	2	2	HastBack
3	Mazda 3	2	2	HastBack
4	Renault Stepway	3	3	Camioneta

Combinaciones externas (OUTER JOIN)

Las combinaciones externas se realizan mediante la instrucción OUTER JOIN. Como enseguida veremos, devuelven todos los valores de la tabla que hemos puesto a la derecha, los de la tabla que hemos puesto a la izquierda o los de ambas tablas según el caso, devolviendo además valores nulos en las columnas de las tablas que no tengan el valor existente en la otra tabla.

Es decir, que nos permite seleccionar algunas filas de una tabla aunque éstas no tengan correspondencia con las filas de la otra tabla con la que se combina. Ahora lo veremos mejor en cada caso concreto, ilustrándolo con un diagrama para una mejor comprensión.

La sintaxis general de las combinaciones externas es:

FROM Tabla1 [LEFT/RIGHT/FULL] [OUTER] JOIN Tabla2 ON Condiciones_Vinculos_Tablas

Como vemos existen tres variantes de las combinaciones externas.

En todas estas combinaciones externas el uso de la palabra OUTER es opcional. Si utilizamos LEFT, RIGHT o FULL y la combinación de columnas, el sistema sobreentiende que estamos haciendo una combinación externa.

Variante LEFT JOIN

Se obtienen todas las filas de la tabla colocada a la izquierda, aunque no tengan correspondencia en la tabla de la derecha.

Así, para seleccionar todas las filas de la Tabla1, aunque no tengan correspondencia con las filas de la Tabla2, suponiendo que se combinan por la columna Col1 de ambas tablas escribiríamos:

SELECT T1.Col1, T1.Col2, T1.Col3, T2.Col7

FROM Tabla1 T1 LEFT [OUTER] JOIN Tabla2 T2 ON T1.Col1 = T2.Col1

Esto se ilustra gráficamente de la siguiente manera:

  

Volviendo a nuestro ejemplo al momento de ejecutar la sgte Consulta con LEFT JOIN:

SELECT T1. IdCarro, T1. NombreCarro, T1. IdCarroceria, T2. IdCarroceria, T2. NombreCarroceria

FROM Carro T1

LEFT JOIN Carroceria T2 ON T1. IdCarroceria= T2. IdCarroceria

Se obtendrá

IdCarro	NombreCarro	IdCarroceria	IdCarroceria	NombreCarroceria
1	Hiunday i35	1	1	Sedan
2	Chevrolet Spark GT	2	2	HastBack
3	Mazda 3	2	2	HastBack
4	Renault Stepway	3	3	Camioneta
5	Ford Explorer	NULL	NULL	NULL
6	Nissan Sentra	NULL	NULL	NULL

Variante RIGHT JOIN

Análogamente, usando RIGHT JOIN se obtienen todas las filas de la tabla de la derecha, aunque no tengan correspondencia en la tabla de la izquierda.

Así, para seleccionar todas las filas de la Tabla2, aunque no tengan correspondencia con las filas de la Tabla1 podemos utilizar la cláusula RIGHT:

SELECT T1.Col1, T1.Col2, T1.Col3, T2.Col7

FROM Tabla1 T1 RIGHT [OUTER] JOIN Tabla2 T2 ON T1.Col1 = T2.Col1

El diagrama en este caso es complementario al anterior:

Volviendo a nuestro ejemplo al momento de ejecutar la sgte Consulta con LEFT JOIN:

SELECT T1. IdCarro, T1. NombreCarro, T1. IdCarroceria, T2. IdCarroceria, T2. NombreCarroceria

FROM Carro T1

RIGTH JOIN Carroceria T2 ON T1. IdCarroceria= T2. IdCarroceria

Se obtendrá

IdCarro	NombreCarro	IdCarroceria	IdCarroceria	NombreCarroceria
1	Hiunday i35	1	1	Sedan
2	Chevrolet Spark GT	2	2	HastBack
3	Mazda 3	2	2	HastBack
4	Renault Stepway	3	3	Camioneta
NULL	NULL	NULL	4	Convertible
NULL	NULL	NULL	5	Limosina
NULL	NULL	NULL	6	Furgoneta

 Variante FULL JOIN

Se obtienen todas las filas en ambas tablas, aunque no tengan correspondencia en la otra tabla. Es decir, todos los registros de A y de B aunque no haya correspondencia entre ellos, rellenando con nulos los campos que falten:

FULL-JOIN

Es equivalente a obtener los registros comunes (con un INNER) y luego añadirle los de la tabla A que no tienen correspondencia en la tabla B, con los campos de la tabla vacíos, y los registros de la tabla B que no tienen correspondencia en la tabla A, con los campos de la tabla A vacíos.

Su sintaxis es:

SELECT T1.Col1, T1.Col2, T1.Col3, T2.Col7

FROM Tabla1 T1 FULL [OUTER] JOIN Tabla2 T2 ON T1.Col1 = T2.Col1

Volviendo a nuestro ejemplo al momento de ejecutar la sgte Consulta con LEFT JOIN:

SELECT T1. IdCarro, T1. NombreCarro, T1. IdCarroceria, T2. IdCarroceria, T2. NombreCarroceria

FROM Carro T1

RIGTH JOIN Carroceria T2 ON T1. IdCarroceria= T2. IdCarroceria

Se obtendrá

IdCarro	NombreCarro	IdCarroceria	IdCarroceria	NombreCarroceria
1	Hiunday i35	1	1	Sedan
2	Chevrolet Spark GT	2	2	HastBack
3	Mazda 3	2	2	HastBack
4	Renault Stepway	3	3	Camioneta
5	Ford Explorer	NULL	NULL	NULL
6	Nissan Sentra	NULL	NULL	NULL
NULL	NULL	NULL	4	Convertible
NULL	NULL	NULL	5	Limosina
NULL	NULL	NULL	6	Furgoneta