Arquitectura de datos. Identificación de las partes interesadas (Stakeholders)

Veremos cómo identificar a las partes interesadas que deben ser parte de un programa de gobierno de datos. El equipo lo es todo en una estrategia de gobierno de datos. Sus partes interesadas dan forma a la estrategia y las empresas quieren comprender quiénes se verán afectados por una nueva actividad porque eso ayudará a aplicar la geografía y los límites en torno a la política. Debemos alinear nuestras necesidades con las habilidades necesarias. Esto significa elegir a las personas que trabajarán con la tecnología o quienes realmente utilizarán los datos. 

Los técnicos no entenderán las necesidades del negocio y los analistas no entenderán la tecnología. La idea es darle a cada bando suficiente información para que entiendan que están haciendo. Para ello, el liderazgo es clave para cualquier grupo de partes interesadas (Stakeholders). Los líderes deben ser identificados y empoderados. No nos referimos a gerentes o superiores sino a personas que comprenden y llevan a otros con ellos. En términos generales, hay tres grupos principales que deseamos identificar como partes interesadas clave. 

Primero, los creadores de datos, los técnicos. Luego están los usuarios de los datos, las gente que utilizará los datos. Y tercero los creadores de reglas de datos, aquellos que tienen interés en las políticas y procedimientos. 

Una vez identificadas estas tres partes interesadas, hay distintas categorías en cada una de ellas. Y también existe la necesidad de una combinación de personas técnicas y no técnicas interesadas en la gestión de datos. Tendremos guardianes. Los que guardan y mantienen los datos, ya sean técnicos o usuarios, específicamente los guardianes de datos y los analistas de negocios. También hay partes interesadas en las actividades de recopilación de datos y gobernanza que se expanden a la alta dirección, la Junta Directiva. Los oficiales legales y de cumplimiento ciertamente tienen un gran interés en la recopilación de datos. Y luego están los proveedores o vendedores e incluso nuestros clientes. 

Todo esto nos ayudará a evaluar a las partes interesadas y nuestro grupo estará directamente involucrado en la gobernanza y el manejo de datos. También tenemos a los que estarán interesados y afectados por estas actividades. Una vez que hayamos identificado a todas las partes interesadas, hay un modelo que podemos utilizar para incorporarlas y obtener su apoyo. Generalmente, debemos tener tres argumentos para  que se adapten a nuestras necesidades. 

Primero, debemos tener una respuesta a la pregunta, ¿qué gano yo? Cada tipo de actor tendrá diferentes intereses y necesidades. Por lo tanto, determinaremos cómo se beneficiará un ingeniero de software con estas actividades. Debemos asegurarnos de que sepan cómo la estrategia de gobernanza les facilitará la vida. Si es alguien en ventas o marketing, no debería ser difícil argumentar cómo tendrán información mejor y más útil para dirigirse a los clientes. Identificaremos el potencial y las oportunidades y haremos que estas actividades sean valiosas. La gobernanza puede parecer aburrida a primera vista, pero es una necesidad absoluta. Lo mismo ocurre con los datos. Encontrar el valor tanto en la recopilación de datos como en una política de gobernanza arrojará luz sobre nuevas oportunidades de negocio.

Tecnologías en la nube y gobernanza de datos

A continuación veremos  las formas en que las tecnologías en la nube afectan la gobernanza de datos.

Un gran beneficio de la nube es que es rentable para las empresas que no quieran mantener sus propios equipos para el almacenamiento de datos. Además ofrece un tiempo de actividad del 100%, una necesidad fundamental para cualquier empresa. Y eso se debe en parte a su escalabilidad, con nuevos servidores virtuales en marcha cuando aumenta el tráfico. La nube es una excelente manera para las empresas que desean descargarse de sus operaciones de datos y concentrarse en el negocio. Los proveedores de la nube ofrecen experiencia y análisis integrados, lo que hace que sea una transición fácil incluso para las organizaciones más grandes.

Hay consideraciones importantes para las empresas que utilizan la nube o que están considerando un salto a la nube. 

Intimidad

Mantener la privacidad de la información de una empresa y la información de los clientes que recopilan es de suma importancia por todo tipo de razones. La seguridad también va de la mano con la privacidad porque para mantener la privacidad de la información, debemos protegerla de filtraciones y piratas informáticos. 

Confíanza 

En el proveedor de la nube, en sus procesos y políticas y, en última instancia, que nuestros clientes confíen en nuestra empresa. Si perdemos esa confianza, es muy difícil recuperarla. 

Gobernanza

La gobernanza en una nube es diferente. Por ejemplo, los datos que solíamos guardar en el sótano en un servidor,  ahora dicho servidor puede encontrarse en San Francisco, Londres o Berlín. 

Tener los datos en la nube elimina la mayor parte de los errores generados por el usuario, pues en este caso es el proveedor de la nube quien garantiza la privacidad y la seguridad de estos.

Generalmente hay dos tipos de nubes. Nubes privadas, que se ubican in situ incluso si la ubicación física no está emparejada con la sede de una empresa. Nubes públicas, que son soluciones alojadas por proveedores que tienen centros de datos ubicados en múltiples ubicaciones alrededor del mundo. Y nubes híbridas, que son una mezcla de las dos primeras. Y así, la gobernanza de datos, en lo que respecta a la nube, puede ser un objetivo en constante movimiento porque, además de preocuparnos por los errores de usuario, debemos comprender dónde se encuentran físicamente nuestros datos porque pueden estar sujetos a leyes en diferentes partes de el mundo.

Para establecer un gobierno adecuado para los datos basados en la nube, nuestra empresa debe cultivar un cierto nivel de experiencia.  Para utilizar eficazmente la nube, las empresas deben desarrollar una estrategia empresarial para la nube.

Curso avanzado de C#. Empaquetado y desempaquetado de tipos de valor (Boxing and Unboxing)

El empaquetado (boxing) es el proceso de convertir un tipo de valor como un int o booleano en un objeto o una interfaz que sea compatible con el tipo de valor. El desempaquetado (unboxing) es el proceso de convertir un valor empaquetado en su valor original. Por ejemplo, el siguiente código crea una variable entera y luego crea un objeto que hace referencia a su valor: 

// Declaramos  e inicializamos el entero i. 

int i = 10; 

// Empaquetamos i

object iObject = i; 

Después de ejecutar este código, la variable iObject es un objeto que hace referencia al valor 10.

El Empaquetamiento (boxing) y el desempaqutamiento (unboxing) consumen mucho más tiempo que simplemente asignar un tipo de variable de valor igual a otro, por lo que debemos evitar empaquetar y desempaquetar siempre que sea posible. 

Por lo general, el empaquetamiento y el desempaquetamiento se realizan  automáticamente sin tomar ninguna acción especial. Esto sucede cuando invocamos un método que espera un objeto como parámetro pero le pasamos un valor. Por ejemplo : 

int i = 2465; 

Console.WriteLine (string.Format ("i es: {0}", i)); 

La versión del método Format de la clase string que se utiliza aquí toma como parámetro una cadena con formato y una secuencia de objetos que vamos a imprimir. El método examina los objetos y los imprime adecuadamente. 

El código pasa la variable de valor i al método Format. Ese método espera un objeto como parámetro, por lo que el programa automáticamente empaqueta el valor.

Idealmente, podríamos evitar esto haciendo que el método Format tome un int como parámetro en lugar de un objeto, pero entonces, ¿qué haríamos si queremos pasar al método un objeto double, DateTime o Person? Incluso si creamos versiones sobrecargadas del método Format para manejar todos los tipos de datos básicos (int, double, string, DateTime, bool, etc.), no podríamos manejar todas las combinaciones posibles que pueden ocurrir en una lista de parámetros. 

La solución es hacer que Format tome objetos no específicos como parámetros y luego utilice la reflexión para saber cómo imprimirlos.

De forma similar, podemos utilizar objetos no específicos para los parámetros de los métodos que escribamos y luego usar la reflexión para averiguar qué hacer con los objetos. Por lo general, obtendremos mejor rendimiento si podemos utilizar un tipo de datos, una interfaz o un tipo genérico más específico para los parámetros. Incluso si estamos dispuestos a vivir con el éxito de la actuación del empaquetamiento y el desempaquetamiento tienen un efecto secundario sutil que puede llevar a un código confuso. 

Considerar nuevamente el siguiente código: 

// Declara e inicializa el entero i. 

int i = 10;

 // empaqueta i.

objeto iObject = i; 

Después de ejecuta este código, la variable iObject es un objeto que hace referencia al valor 10, pero no es el mismo valor 10 almacenado en la variable i. Eso significa que si el código cambia uno de los valores, el otro no cambia también. Por ejemplo, el siguiente código, agrega algunas declaraciones a la versión anterior: 

// Declara e inicializa el entero i. 

int i = 10;

 // empaqueta i.

objeto iObject = i; 

// Cambia los valores. 

i = 1;

iObject = 2;

// Muestra los valores. 

Console.WriteLine (i); 

Console.WriteLine (iObject); 

Este código crea una variable entera i y la empaqueta en la variable iObject. Luego establece i igual a 1 e iObject igual a 2. La salida que se obtiene es:

1

2

La variable iObject parece referirse a la variable i pero en realidad son dos valores separados. Por cierto, el método Console.WriteLine tiene muchas versiones sobrecargadas, incluida una que toma un int como parámetro, por lo que la primera declaración WriteLine en el código anterior no requiere boxing o unboxing. La segunda declaración WriteLine debe desempaquetar iObject para obtener su valor actual 2. 

La moraleja de la historia es que, si es posible, debemos evitar el empaquetado y  desempaquetado al no almacenar referencias a tipos de valores en los objetos. Si el programa empaqueta y desempaqueta automáticamente un valor como lo hace el método string.Format, generalmente no hay mucho que pueda hacer al respecto. Finalmente, no debemos declarar parámetros de método u otras variables para tener un objeto de tipo no específicado a menos que no tengamos otra opción. 

Garantizar la interoperabilidad de código no administrado 

La interoperabilidad, permite que un programa de C# utilice clases proporcionadas por código no administrado que no se haya escrito bajo el control de Common Language Runtime (CLR), que es el entorno de ejecución que ejecuta los programas C#. Los componentes ActiveX y la API de Win32 son ejemplos de código no administrado que se puede invocar desde un programa de C#. 

Las dos técnicas más comunes para permitir que los programas administrados utilicen código no administrado son COM Interop y Platform invoke (P/invoke). COM Interop se analiza brevemente en la siguiente sección. Esta sección trata sobre P/invoke. 

Para utilizar P/invoke y acceder a un recurso no administrado, como una llamada a la API, un programa primero incluye un atributo DllImport para definir los métodos no administrados que utilizará el programa administrado. El atributo DllImport es parte del espacio de nombres System.Runtime.InteropServices, por lo que muchos programas agregan ese espacio de nombres en una declaración de uso para facilitar el uso del atributo. El atributo DllImport toma parámetros que informan al programa administrado sobre un método no administrado. Los parámetros indican cosas como la DLL que contiene el método, el juego de caracteres utilizado por el método (Unicode o ANSI) y el punto de entrada en la DLL utilizada por el método. (Si omitimos esto, el valor predeterminado es el nombre del método).

El programa aplica la declaración de método con el el atributo Static extern. La declaración incluye los parámetros que requiere el método y define el tipo de retorno. Esta declaración debe estar dentro de una clase, por ejemplo en la clase que contiene el código que utiliza el método. 

Por ejemplo, el siguiente código muestra dónde se coloca la instrucción using y el atributo DllImport en el programa de ejemplo ShortPathNames (que se describe brevemente con mayor detalle). Se resalta la instrucción DllImport. 

Using System;

Using System.Collections.Generic;

 ... Otras declaraciones estandard "using"...

Using System.Runtime.InteropServices;

 

Namespace ShortPathNames

{

      Partial Public Class Form1 :  Form

      {

            Public Form1()

            {

                  InitializeComponent();

            }

            [DllImport("kernel32.dll", CharSet = CharSet.Auto,

            SetLastError = true)]

            Static extern uint GetShortPathName(String lpszLongPath,

            Char[] lpszShortPath, int cchBuffer);

            ... Continuamos con nuestro código ...

      }

} 

La instrucción DllImport indica que el método está en la biblioteca kernel32.dll, que el programa debe determinar automáticamente si quiere utilizar el juego de caracteres Unicode o ANSI y que el método debe llamar a SetLastError si hay un problema. Si hay un error, el programa puede usar GetLastWin32Error para ver qué salió mal. 

La declaración del método indica que el programa utilizará el método GetShortPathName, que convierte una ruta completa a un archivo en una ruta corta que Windows puede reconocer. (Si el método usa el juego de caracteres Unicode, el nombre del método generalmente termina con una "W" para "caracteres anchos" como en GetShortPathNameW). Este método devuelve un uint y toma como parámetros una cadena, una matriz de caracteres e int. 

Nota 

A menudo, los prefijos en los nombres de los parámetros nos dan pistas sobre los propósitos de esos parámetros. En este ejemplo, lpsz significa "puntero largo a una cadena que termina en cero" y cch significa "recuento de caracteres". Si leemos la ayuda en línea para la función API GetShortPathName, encontraremos que esos prefijos tienen sentido.

El primer parámetro es la ruta del archivo que deseamos convertir en una ruta corta. Cuando llamamos al método, P/Invoke lo convierte automáticamente en una cadena terminada en nulo. El segundo parámetro debe ser un búfer preasignado donde GetShortPathName pueda almacenar sus resultados. El tercer parámetro proporciona la longitud del búfer que asignamos, por lo que GetShortPathName sabe cuánto espacio tenemos para trabajar. 

El método devuelve un uint que indica la longitud de la cadena que el método depositó en el búfer lpszLongPath. 

Podemos ver la sintaxis de esta instrucción DllImport mirando la firma del método aquí

En http://www.pinvoke.net podemos ver declaraciones de DllImport para una gran cantidad de funciones de la API de Win32. Cuando necesitemos utilizar una función de la API de Win32, este es un buen sitio para comenzar. 

Una vez declarado el método, el programa puede comenzar a utilizarlo. A continuación, un ejemplo de utilización del método ShortPathNames.

// Obtiene el nombre de archivo largo.

String NombreLargo = txtArchivo.Text;

// Asigna un búfer para contener el resultado.

Char[] buffer = New Char[1024];

      Long length = GetShortPathName(

      NombreLargo, Buffer,

Buffer.Length);

// Obtiene el nombre corto.

String NombreCorto = New String(Buffer);

txtNombreCorto.Text = NombreCorto.Substring(0, (Int())length);

Este código recibe una ruta larga de archivo introducida por el usuario en el control txtArchivo y asigna un búfer de 1024 caracteres para mantener la ruta corta. Después llama al método GetShortPathName, al que le pasa la ruta larga de archivo el búfer y la longitud del búfer. Una vez que el método regresa, el programa usa el búfer para inicializar una nueva cadena. Utiliza el método Substring y la longitud devuelta por GetShortPathName para truncar la cadena a su longitud adecuada y muestra el resultado. 

En general, el tipo de instrucción DllImport que hemos visto es lo suficiente para hacer el trabajo. Pero si necesitamos más control para convertir valores entre código administrado y no administrado, podemos agregar el atributo MarshalAs a los parámetros del método o al valor de retorno. El siguiente código muestra una nueva versión de la instrucción DllImport para el método GetShortPathName que utiliza atributos MarshalAs: 

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError=true)]

Static extern uint GetShortPathName(

      [MarshalAs(UnmanagedType.LPTStr)] string lpszLongPath,

      [MarshalAs(UnmanagedType.LPTStr)] StringBuilder lpszShortPath,

      uint cchBuffer);

El primer atributo MarshalAs indica que el primer parámetro es un tipo de datos LPTStr en el código no administrado y debe tratarse como una cadena en el código administrado. El segundo atributo MarshalAs indica que el segundo parámetro es un tipo de datos LPTStr en el código no administrado y debe tratarse como un StringBuilder en el código administrado. Por supuesto, si utilizamos esta declaración, necesitaremos cambiar nuestro código para usar un StringBuilder para un búfer en lugar de una matriz de char.

¿Por qué Big Data es diferente?

Vamos a ver las diferencias entre Big data y paradigmas de datos tradicionales. Big data no son solo datos. Si lo fueran, se llamaría datos y no Big data. Y la distinción no radica solo en su tamaño. Contiene múltiples activos sobre prácticamente cualquier pieza de información imaginable que pueda resultarnos útil. Es el tipo de datos a los que no teníamos acceso en el pasado. El término Big data existe desde la década de 1990 aunque en esa época el almacenamiento de datos resultaba complicado y costoso.

Todo eso cambió en la década de 2000  cuando pudimos recopilar conjuntos de datos de extrema complejidad y alcance. Pero los macrodatos no son independientes, es decir, no basta con tener los datos. También tenemos que tener el poder de procesamiento y una forma de analizarlos para que sean significativos. Eso también ha cambiado con un procesamiento más barato y rápido, y las herramientas necesarias para obtener significado de los datos. Ahora podemos recopilar grandes cantidades de información,  almacenarla y analizarla. Big data significa más grande, más rápido y mejor. Pero no sólo la tecnología en sí, sino la forma en que vemos y analizamos los datos.

Podemos aplicar análisis estadístico sobre innumerables atributos, compararlos y extraer significado de ellos. Otra tecnología que se ha beneficiado de una potencia de procesamiento y almacenamiento exponencialmente mayores ha sido la inteligencia artificial y el aprendizaje automático. Ahora podemos incorporar la automatización en el análisis de datos, utilizando IA. Y esto crea nuevas oportunidades para comprender el comportamiento humano de formas que nunca imaginamos posibles. Ahora estamos en un mundo 24 horas al día, 7 días a la semana, 365 días al año, donde la información es accesible todo el tiempo. 

Esto es importante para las actividades de análisis de datos que están en curso y están sujetas a cambios constantes. Con Big Data, estamos encontrando nuevos conocimientos que simplemente no estaban disponibles antes. Podemos utilizar la información que recopilamos para comprender mejor el comportamiento de la gente respecto al mercado o a los productos de nuestra empresa.

IoT, el Internet de las cosas, es un gran ejemplo de información a la que nadie podría haber imaginado tener acceso. Ahora, podemos entender cómo las personas navegan por internet o  cómo utilizan el refrigerador, etc. Tenemos una capacidad asombrosa no solo para recopilar y almacenar los datos, sino para comprender realmente lo que significan, y eso es poder. 

Datos identificativos

Para crear un plan de gobierno de datos, primero debemos identificar el dominio de datos que nos interesa. Hay que mirar la visión corporativa de nuestra empresa y preguntarnos por qué necesitamos estos datos. Y estar preparados para cambiar de rumbo si la experiencia o los datos nos llevan en otra dirección. Los macrodatos por definición son complejos, y también las herramientas y la metodología de análisis de datos que adoptemos.  Hay que planificar un aumento gradual, comenzando con pequeños datos manejables . También tenemos que presupuestar una progresión en aumento de manejo de más datos a lo largo del tiempo. Esto consiste en identificar la tecnología y las herramientas que necesitaremos para cumplir nuestros objetivos, incluso aunque falten 12 o 24 meses para nuestro objetivo. Y eso requiere que comprendamos las herramientas.  Debemos tener las herramientas adecuadas para alinear la tecnología a nuestras  necesidades y no al revés. 

Un concepto erróneo común sobre el Big data es que podemos analizar todo y mirarlo desde un sinfín de ángulos diferentes para encontrar la solución a todos nuestros problemas. El Big data es complejo y, por lo tanto, puede serlo el análisis de esos datos. Tan malo como no tener el conocimiento que necesitamos puede ser no poder obtener conocimiento de nuestros datos porque no sabemos dónde buscar. No hay que hacerlo al azar.

La gobernanza requiere una política escrita y un plan de recopilación de datos. Finalmente, necesitamos identificar a los jugadores que entienden. Nuestro equipo de gobierno de datos, será una combinación de personas técnicas y no técnicas. Algunos comprenderán la tecnología y otros comprenderán la información. Los requisitos y necesidades comerciales. Algunos pueden entender ambos. Necesitamos una buena representación de lo que quiere nuestra empresa en términos de valor de la información. 

Requisitos para la gobernanza de Big Data

Existen  cinco requisitos principales para el gobierno de datos. Aunque esto no es exacto, en general, podemos aplicar cinco necesidades clave. 

Proteger los datos

Hay varias buenas razones para proteger los datos de los usuarios, Las filtraciones de datos son caras y pueden poner en peligro incluso a las empresas más fuertes. Y existen leyes que rodean la recopilación y gestión de datos, y eso también puede resultar costoso si se infringen esas leyes. 

Identificación e indexación de datos

Cualquier operación de Big data necesita comprender qué tienen los datos y cómo conservarlos. Big Data es grande. No es útil recopilar grandes cantidades de datos que nunca se utilizarán. Y no es una buena práctica catalogar o identificar incorrectamente la información que se recopila. Las diferentes unidades organizativas probablemente usarán los datos de manera diferente, y eso hace que catalogar los datos sea aún más importante. 

Confiabilidad y disponibilidad

Cualquiera que conozca la creación de redes comprenderá la importancia de estos dos principios. El Big Data suele ser tan gigantesco que debe tratarse de manera un poco diferente. Ya sea que se encuentre en un servidor en el edificio de al lado o en un edificio al otro lado del mundo. Los datos deben ser accesible las 24 horas del día, los 7 días de la semana, los 365 días del año, especialmente cuando se aprovechan para la toma de decisiones cruciales. Y tienen que estar protegidos, no en el sentido de protegerlos de violaciones de datos, eso es absolutamente crítico, pero también necesitan ser inmunizados contra desastres. Tiene que haber políticas y procedimientos de recuperación ante desastres para garantizar que los datos seguirán estando disponibles en caso de circunstancias inesperadas. 

Evitar la basura

Si entra basura, sale basura, esto significa que tenemos que entender no solo qué datos recopilamos, sino que datos son correctos. ¿Qué recopilamos que dará sentido a nuestras actividades de análisis de datos? Con Big Data, estamos recopilando casi literalmente todos los datos imaginables que se pueden recopilar. Y comprender el significado de estos datos puede ser una tarea abrumadora.

Validación de datos

 Para nuestros propósitos, la validación es un poco diferente a simplemente verificar si los datos son correctos. Significa asegurarse de que estamos recopilando los datos correctos, los datos que necesitamos y los requisitos para eso pueden cambiar con el tiempo. También significa asegurarse de que nuestros procedimientos existentes estén en sintonía con los datos que se recopilan. Que estamos utilizando las herramientas adecuadas para recopilar, almacenar y analizar los datos, y que estamos interpretando correctamente los datos. Ahora que tenemos los requisitos para la gobernanza de los datos, pasemos a los requisitos para implementar la gobernanza.

Primero, debemos tener un órgano de gobierno de datos, un grupo dentro de nuestra empresa que actúe como propietario y guía para las actividades de Big Data. Este grupo debe ser bastante diverso, pero debe estar bien capacitado e informado sobre el plan de datos, las políticas que rodean la recopilación de datos y los procedimientos para usar los datos. Debe haber profesionales de cumplimiento involucrados, personas que comprendan las reglas y regulaciones y cómo deben aplicarse a nuestra estructura corporativa. Luego, por supuesto, hay otras políticas,  cómo interactúa la empresa con los datos, los maneja y los trata. Aunque no siempre  es posible  tenerlo como requisito. Pero debemos siempre que sea posible, identificar todos los procedimientos concebibles para la recopilación y el manejo de datos.

Al emprender el viaje de Big Data como empresa, debemos hacer unas preguntas: 

¿quiénes son las partes interesadas?

Identificar a todas las personas o grupos que se verán afectados o que tendrán interés en los datos y cómo se utilizan. 

¿cuál es el soporte dentro de nuestra empresa para las actividades de Big data? 

Hay que comprender la importancia de recogerlos y almacenarlos Entendemos lo crucial que es protegerlos Y entendemos lo que pasará si algo sale mal, es muy importante saberlo. 

¿cuál es el dominio? 

¿Estamos recopilando una amplia gama de información para cada transacción. O estamos apuntando específicamente a uno o algunos dominios de un conjunto mayor de datos? Es importante saber que es, porque lo que recopilamos, quién utilizará los datos.

Es posible que sólo las unidades de ventas y contabilidad de una empresa necesiten la inteligencia obtenida de un conjunto de datos. Por lo tanto, no es necesario incorporar el marketing y las operaciones, porque no necesitamos analizar este tipo de datos. Si  ventas y contabilidad se están ocupando de eso, eventualmente se filtrará a las otras unidades de todas formas. El dominio puede significar diferentes cosas en diferentes escenarios. Por ejemplo, quizás un dominio esté orientado al cliente en lugar de a la empresa. Tal vez una empresa que fabrica consumibles, pero que también brinda servicios solo quiere analizar la forma en que sus clientes compran los consumibles, por lo que no es necesario centrarse en el lado de los servicios del negocio.

Es treméndamente tentador querer recopilar la mayor cantidad de datos posible y analizar tanto como sea posible. El síndrome quiero saberlo todo y quiero saberlo ahora. Pero es mucho mejor centrarse más en nuestro enfoque de Big data. 

¿por qué necesitamos gobernanza? 

La respuesta corta es que si recopilamos datos de clientes, definitivamente los necesitamos, porque existen implicaciones legales y prácticas de manejar los datos de alguien. 

Es probable que descubramos todo un subconjunto de razones por las que la gobernanza es importante para nuestra empresa.

Alguien nos preguntará en qué se beneficia la empresa o dónde está la justificación del gasto. Toda empresa quiere saber por qué debería gastar dinero en algo nuevo. La respuesta no satisfará a los contables ni a los directores financieros. 

Podemos hacerlo, especialmente si corremos el riesgo de recibir multas, sanciones o perder la confianza del cliente, pero no es por eso que debemos hacerlo. Es posible que ya tengamos procesos o políticas existentes que pueden ayudar a dar forma a nuestras actividades de gobernanza de Big data. Por lo tanto, aprovecharemos lo que tenemos para hacer que la transición sea más cómoda. Y siempre debemos recordar que si bien la tecnología no es el único y el fin de la gobernanza de Big data, sigue siendo el facilitador. Por eso hay que animar a adoptar la tecnología y comprenderla. En última instancia, las personas son la clave para nuestras actividades de Big Data y la gobernanza que establecerá un marco en torno a una mejor comprensión de nuestra empresa y nuestros clientes.

Curso avanzado de C#. Conversión de valores

La conversión permite a un programa convertir un valor de un tipo a otro tipo compatible, pero a veces es posible que deseemos convertir un valor de un tipo a un tipo incompatible. Por ejemplo, es posible que deseemos convertir el valor de cadena ‘123’ al valor int 123, o tal vez deseemos convertir el valor de cadena ‘True’ al valor booleano verdadero (true). En casos como estos, el casting no funcionará. Para convertir un valor de un tipo a un tipo incompatible, debemos utilizar algún tipo de clase auxiliar. El Framework de .NET nos proporciona tres métodos principales para este tipo de conversiones: 

-Métodos de análisis (parsing) 

-System.Convert

-System.BitConverter

Métodos de análisis (parsing)

Cada uno de los tipos de datos primitivos de C# (int, bool, double, etc.) tiene un método Parse que convierte una representación de cadena de un valor en ese tipo de datos. Por ejemplo, bool.Parse toma como argumento una cadena que representa un valor booleano como verdadero (true) y devuelve el valor booleano correspondiente verdadero (true). Estos métodos de análisis generan excepciones si su entrada está en un formato no reconocido. Por ejemplo, la declaración bool.Parse("yes") arroja una excepción del tipo FormatException porque ese método solo admite como entradas los valores “true” o “false” y devuelve sus homólogos en formato booleano.

Cuando utilizamos estos métodos para convertir la entrada del usuario, debemos tener en cuenta que se pueden generar excepciones si el usuario ingresa valores con un formato no válido. Si el usuario introduce ‘doce’ en una caja de texto donde el programa espera un entero (int), el método int.Parse devolverá una excepción. Si el usuario introduce 1E3 o 100000 donde el programa espera un entero corto, el método short.Parse devolverá un error de desbordamiento OverflowException. Podemos utilizar un bloque try-catch para proteger el programa de estas excepciones, pero para facilitar aún más la verificación de valores, cada una de estas clases también proporciona el método TryParse. Este método intenta analizar (parsear) una cadena y devuelve verdadero si tiene éxito o falso si falla. Si tiene éxito, el método también guarda el valor analizado (parseado) en una variable de salida que le pasa al método. La siguiente tabla enumera los tipos de datos más comunes que proporcionan métodos Parse y TryParse.

El siguiente código muestra dos formas en que un programa puede analizar (parsear) valores enteros que se ingresan desde TextBox: 

int cantidad;

try

{

      cantidad = int.Parse(txt_Cantidad.Text);

}

catch

{

      cantidad = 1;

}

int peso;

if (!int.TryParse(txt_Peso.Text, out peso)) peso = 10;

El código declara la variable cantidad dentro de un bloque try-catch, y  utiliza int.Parse para intentar convertir el texto de la caja de texto Txt_Cantidad en un entero. Si la conversión falla, el código establece la cantidad en el valor predeterminado 1.

A continuación, el código declara la variable peso. Después utiliza int.TryParse para intentar analizar el texto de la caja de texto txt_Peso. Si el intento tiene éxito, la variable  peso contendrá el valor que ingresó el usuario. Si el intento falla, TryParse devuelve falso y el código establece el peso en el valor predeterminado 10. 

Se recomienda como mejores prácticas, evitar analizar (parsear) cuando sea posible A veces, podemos evitarlo en valores numéricos y tratar con entradas no válidas como ‘diez’ usando un control para permitir que el usuario seleccione un valor en lugar de teclearlo. Por ejemplo, podríamos utilizar un control NumericUpDown para permitir que el usuario seleccione la cantidad en lugar de teclearla en un TextBox. 

En general, los métodos de análisis funcionan bastante bien si la entrada tiene sentido. Por ejemplo, la instrucción int.Parse ("645") devuelve el valor 645 sin confusión. Incluso el método Parse del tipo de datos DateTime puede tener sentido con la mayoría de las entradas razonables. Por ejemplo, en castellano, las siguientes declaraciones se analizan como 12 de abril de 2022 a las 16:32.

DateTime.Parse ("16:32 12 de abril de 2022").ToString()

DateTime.Parse ("12 de abril de 2022 16:32").ToString() 

DateTime.Parse ("16:32 12/4/22").ToString()

DateTime.Parse ("16:32 12-4-22"). ToString() 

Los métodos de análisis no manejan bien los valores de las divisas por defecto. Por ejemplo, el código siguiente arroja un FormatException (en la configuración regional de España.): 

decimal amount = decimal.Parse("€132.422,55"); 

La razón por la que este código falla es que, por defecto, el método decimal.Parse habilita miles y separadores decimales pero no símbolos de moneda. Podemos hacer que decimal.Parse habilite los símbolos de moneda agregando otro parámetro que sea una combinación de valores definidos por la enumeración

System.Globalization.NumberStyles. Esta enumeración nos permite indicar los caracteres especiales que se deben permitir, como los símbolos de moneda, un signo inicial y paréntesis. 

La tabla muestra los valores definidos

Estilo	Descripción
None	No admite caracteres especiales. El valor debe ser un entero decimal.
AllowLeadingWhite	Admite un espacio en blanco al principio
AllowTrailingWhite	Admite un espacio en blanco al final
AllowLeadingSign	Admite un carácter de signo principal (+, -). Los caracteres válidos vienen definidos en NumberFormatInfo.PositiveSign y NumberFormatInfo.NegativeSign.
AllowTrailingSign	Admite un carácter de signo (+, - ) al final. Los caracteres válidos vienen dados por las propiedades NumberFormatInfo.PositiveSign y NumberFormatInfo.NegativeSign.
AllowParentheses	Admite que el valor esté entre paréntesis para indicar un valor negativo.
AllowDecimalPoint	Permite que el valor contenga un punto decimal. Si también se especifica  AllowCurrencySymbol, el símbolo de moneda admitido viene dado por la propiedad NumberFormatInfo.CurrencyDecimalSeparator. Si AllowCurrencySymbol no está especificado, el símbolo de moneda admitido vendrá dado por NumberFormatInfo.NumberDecimalSeparator.
AllowThousands	Admite separadores de miles. Si AllowCurrencySymbol también es especificado, el separador viene dado por NumberFormatInfo.CurrencyGroupSeparator y el número de dígitos por grupo viene dado por la propiedad  NumberFormatInfo.CurrencyGroupSizes. Si no se especifica AllowCurrencySymbol, el separador es dado por la propiedad NumberFormatInfo.NumberGroupSeparator y el número de dígitos por grupo viene dado por la propiedad NumberFormatInfo .NumberGroupSizes.
AllowExponent	Habilita el símbolo exponente e o E opcionalmente seguido de un signo positivo o negativo.
AllowCurrencySymbol	Habilita un símbolo de moneda. Los símbolos de moneda permitidos vienen dados por la propiedad NumberFormatInfo.CurrencySymbol.
AllowHexSpecifier	Indica que el valor está en hexadecimal. Esto no significa que la cadena de entrada pueda comenzar con un especificador hexadecimal como 0x o & H. El valor debe incluir solo dígitos hexadecimales.
Integer	Este es un estilo compuesto que incluye AllowLeadingWhite, AllowTrailingWhite y AllowLeadingSign.
HexNumber	Este es un estilo compuesto que incluye AllowLeadingWhite, AllowTrailingWhite y AllowHexSpecifier.
Number	Este es un estilo compuesto que incluye AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign, AllowTrailingSign, AllowDecimalPoint y AllowThousands.
Float	Este es un estilo compuesto que incluye AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign, AllowDecimalPoint, y AllowExponent.
Currency	Este es un estilo compuesto que incluye todos los estilos excepto AllowExponent y AllowHexSpecifier
Any	Este es un estilo compuesto que incluye todos los estilos excepto AllowHexSpecifier.

Si proporcionamos valores de NumberStyles, se eliminan los valores predeterminados. Por ejemplo, por defecto decimal.Parse habilita miles y separadores decimales. Si pasamos el valor NumberStyles.AllowCurrencySymbol al método, ya no habilita miles y separadores decimales. Para permitir los tres, debemos pasar al método los tres valores como en el siguiente código: 

decimal amount = decimal.Parse("€132.422,55", 

NumberStyles.AllowCurrencySymbol | 

NumberStyles.AllowThousands | 

NumberStyles.AllowDecimalPoint); 

Alternativamente, podemos pasar al método el estilo compuesto Moneda, como se muestra en el siguiente código: 

decimal amount = decimal.Parse("€132.422,55", 

NumberStyles.AllowCurrencySymbol);

Análisis relativo  al entorno local 

Los métodos de análisis son relativos al entorno local, por lo que intentan interpretar sus entradas para el entorno local en el que se ejecuta el programa. Podemos verlo en las descripciones de la tabla anterior que mencionan la clase NumberFormatInfo. Por ejemplo, el símbolo de moneda permitido está definido por la propiedad NumberFormatInfo.CurrencySymbol, y esa propiedad tendrá diferentes valores según la configuración regional del ordenador. Si el ordenador está con la configuración española, DateTime.Parse entiende la fecha de estilo español "1 de mayo de 2022", pero no comprende la versión en alemán "1. Mai 2022 ”. (Aunque si entiende la versión en inglés "May 1, 2022" en la configuración regional española o alemana). 

De forma similar, si la configuración regional del ordenador es francesa, el método int.Parse puede analizar el texto "132 422,55" pero no puede analizar el español "132.422,55". 

Todos los valores literales dentro del código C# deben usar formatos de inglés de EEUU. Por ejemplo, no importa qué configuración regional utilice nuestro ordenador, un programa de C# utilizará la variable double para "0.05"  pero no para  "0,05"  dentro de su código. 

Errores en análisis de valores de moneda

Es preciso darse cuenta de que es necesario parsear los valores de moneda. Si un TextBox debe contener valores de moneda, debemos parsearlo  correctamente para que no se le diga al usuario que "1.25 €" tiene un formato numérico no válido.

System.Convert 

La clase System.Convert proporciona más de 300 métodos (incluidas las versiones sobrecargadas) para convertir un tipo de datos en otro. Por ejemplo, el método ToInt32 convierte un valor en un entero de 32 bits (un entero int). Las diferentes versiones sobrecargadas de los métodos toman parámetros de diferentes tipos, como booleanos, bytes, DateTimes, dobles, cadenas, etc. La Tabla enumera los métodos de conversión de tipos de datos más útiles proporcionados por la clase System.Convert.

Redondeo bancario

Los métodos que se convierten en tipos integrales (ToByte, ToIntXX y ToUIntXX) usan "redondeo bancario", lo que significa que los valores se redondean al número entero más cercano, pero si hay un empate, con el valor que termina exactamente en ,5, el valor se redondea al número entero par más cercano. Por ejemplo, ToInt16(9.5) y ToInt16(10.5) ambos devuelven 10. Todos estos métodos lanzan una excepción si su resultado está fuera del rango de valores permitidos.

Por ejemplo, ToByte (255,5) devuelve 256, que es demasiado grande para caber en un byte, y ToUInt32 (–3,3) devuelve 3, porque que es menor que cero, y no cabe en un entero sin signo. El método Math.Round utiliza el redondeo bancario de forma predeterminada, pero también nos permite utilizar parámetros para indicar si debe redondearse hacia 0. Este método devuelve un resultado que es decimal o doble, por lo que a menudo el código debe usar una conversión para convertir el resultado en un tipo de datos integral como en el siguiente código:

float total = 100; 

int numItems = 7; 

int promedio = (int)Math.Round (total/numItems);

La clase System.Convert también proporciona un método ChangeType que convierte un valor en un nuevo tipo determinado por un parámetro en tiempo de ejecución. Por ejemplo

(int)Convert.ChangeType(5.5,typeof(int)) 

devuelve el entero 6. A menudo, es más fácil utilizar uno de los métodos más específicos como ToInt32 en lugar de ChangeType.

System.BitConverter 

La clase System.BitConverter proporciona métodos para convertir valores hacia y desde matrices de bytes. El método GetBytes devuelve una matriz de bytes que representa el valor que le pasa. Por ejemplo, si pasa un int (que ocupa 4 bytes de memoria) en el método, devuelve una matriz de 4 bytes que representa el valor. La clase System.BitConverter también proporciona métodos como ToInt32 y ToSingle para convertir los valores de bytes almacenados en matrices nuevamente en tipos de datos específicos. 

Por ejemplo, suponemos que una función API devuelve dos valores de 16 bits empaquetados en las mitades izquierda y derecha de un entero de 32 bits. Podemos utilizar el siguiente código para descomprimir los dos valores: 

int packedValue;

// La llamada a la función API establece packValue aquí. 

... 

// Convierte el valor empaquetado en una matriz de bytes. 

byte[]valueBytes = BitConverter.GetBytes(packedValue);

// Desempaqueta los dos valores. 

Short valor1, valor2;

valor1 = BitConverter.ToInt16 (valueBytes, 0); 

valor2 = BitConverter.ToInt16 (valueBytes, 2); 

Una vez que la función API establece el valor de packedValue, el código usa el método GetBytes de la clase BitConverter para convertir el valor en una matriz de 4 bytes. El orden de los bytes depende de si la arquitectura del ordenador big-endian (Gran indio)  o little-endian (Pequeño Indio). (Podemos utilizar el campo IsLittleEndian de BitConverter para determinar si el valor es big-endian o little-endian). Los métodos de la clase BitConverter son bastante especializados, por lo que no nos extenderemos aquí. Para obtener más información, consultar "Clase BitConverter"