martes, 14 de junio de 2016

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.

lunes, 13 de junio de 2016

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");
}
}

viernes, 10 de junio de 2016

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.

miércoles, 8 de junio de 2016

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">







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

jueves, 2 de junio de 2016

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="*" />
















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

<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">


<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">


<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">


<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">


<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">


<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">


<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">


<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

AdSense_BarHorizontal

martes, 14 de junio de 2016

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

lunes, 13 de junio de 2016

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

-Ingeniería de Hardware:

-Ingeniería de Procesos:

-Ingeniería de Software:

viernes, 10 de junio de 2016

Atributos esenciales del buen software

miércoles, 8 de junio de 2016

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

jueves, 2 de junio de 2016

XSLT (stylesheet) Para Transformar JSON A XML