Christian Vega

Guía Práctica: Protege tus Datos en el Mundo Digital

2025-10-26T16:45:00.000-04:00

Cada día compartimos información personal en internet: compramos en línea, usamos redes sociales, realizamos transferencias bancarias y guardamos datos en aplicaciones. Pero, ¿realmente sabemos qué estamos compartiendo y con quién? Esta guía te ayudará a navegar el mundo digital de forma segura y consciente.

📱 Redes sociales

Configura tu privacidad correctamente

Revisa regularmente la configuración de privacidad de tus redes sociales (Facebook, Instagram, TikTok, WhatsApp)

Decide quién puede ver tus publicaciones: ¿público, amigos o solo tú?

Desactiva la geolocalización automática en tus fotos y publicaciones

Piensa antes de publicar

Evita compartir información sensible como tu dirección exacta, número de cédula de identidad, datos bancarios o boletos de avión, vouchers o entradas de conciertos/cine/teatro.

Las fotos de tus hijos requieren especial cuidado: no reveles nombres completos, ubicaciones de escuelas o rutinas diarias Recuerda: lo que publicas hoy puede permanecer en internet para siempre

Administra tus conexiones

Acepta solicitudes de amistad solo de personas que realmente conoces Revisa periódicamente tu lista de seguidores y elimina perfiles sospechosos

Ten cuidado con los juegos y cuestionarios que piden acceso a tu perfil o solicitan información adicional puedes verificar sitios antes de acceder en https://www.virustotal.com/ para ver la reputación del mismo o si es un sitio malicioso.

⚠️ Consecuencias de Compartir Excesivamente

Robo de identidad: Delincuentes pueden usar tu información para suplantar tu identidad

Fraudes financieros: Datos personales pueden ser utilizados para solicitar créditos a tu nombre

Acoso y extorsión: Información privada compartida puede ser usada en tu contra

Pérdida de oportunidades: Empleadores y instituciones educativas revisan perfiles en redes sociales

https://www.facebook.com/privacy/policy/?locale=es_LA https://www.youtube.com/intl/es_us/howyoutubeworks/our-commitments/protecting-user-data/ https://www.tiktok.com/legal/page/eea/privacy-policy/es 🛒 Compras en Línea y Marketplaces

Verifica antes de comprar

Compra solo en sitios web seguros (busca el candado 🔒 y "https" en la URL)

Investiga la reputación del vendedor en marketplaces como Mercado Libre, Facebook Marketplace o páginas de comercio local, valida que la cuenta que lo publica tiene tiempo, varios contactos, es activo en su feed, tiene varias fotos reales, interactúa de ida y vuelta con al menos más de 5 contactos.

Lee las políticas de privacidad y términos de uso antes de crear una cuenta

Protege tu información de pago

Nunca compartas fotos de tu tarjeta de crédito o débito por WhatsApp o redes sociales

Usa métodos de pago seguros con protección al comprador Activa notificaciones de transacciones en tu banco para detectar movimientos sospechosos

Considera usar tarjetas virtuales o prepagadas para compras en línea

Ten tu tarjeta deshabilitada y solo habilítala cuando requieras hacer una compra es engorroso pero ayuda a que no te debiten sin estar enterado ya que el proceso de devolución/cancelación suele ser tedioso.

Minimiza la información compartida, proporciona solo los datos estrictamente necesarios para la compra

Usa direcciones de entrega alternativas cuando sea posible (oficina, punto de recojo o directamente oficina de correos)

No aceptes solicitudes de amistad de vendedores que quieren acceder a tu perfil completo o te piden información adicional que no es necesaria como fotocopia de cedula de identidad.

⚠️ Consecuencias de no proteger tus datos de compra

Clonación de tarjetas : Tus datos bancarios pueden ser copiados y usados en compras fraudulentas

Estafas y productos falsos: Vendedores no verificados pueden tomar tu dinero sin entregar productos, varios vendedores suelen pedir pago por adelantado del 50% y luego desaparecer

Spam y phishing: tu correo y teléfono pueden ser vendidos a empresas que envían publicidad no deseada o intentan estafarte

Pérdidas económicas: Transacciones no protegidas pueden dejarte sin dinero y sin producto

💰 Billeteras Digitales, Criptomonedas y Transferencias

Seguridad en billeteras digitales

Activa la autenticación de dos factores (2FA) en todas tus aplicaciones financieras

Nunca compartas tus códigos PIN, contraseñas o códigos de verificación con nadie

Usa contraseñas únicas y complejas para cada aplicación (combina letras, números y símbolos)

Mantén actualizada la aplicación de tu billetera digital Criptomonedas y Bitcoin con precaución

Guarda tus claves privadas en lugares seguros y nunca las compartas

Usa billeteras de criptomonedas reconocidas, con buena reputación y que ya tengan mas de un año en el mercado

Desconfía de "oportunidades de inversión" que prometen ganancias rápidas o extraordinarias

Verifica dos o tres veces las direcciones de billetera antes de enviar fondos (las transacciones son irreversibles)

Tus derechos: conocerlos es protegerte

Como usuario digital, tienes derechos sobre tus datos personales, puedes solicitar a cualquier empresa que te informe qué datos tuyos poseen

Facebook En el móvil: Toca el Menú (icono de tres líneas horizontales) y ve a Configuración y privacidad > Configuración > Centro de cuentas. En la web: Haz clic en tu foto de perfil, luego en Configuración y privacidad > Configuración. Accede a tus datos: Una vez en el Centro de cuentas, ve a Tu información y permisos > Exportar tu información.

X (antes Twitter) En la web: Haz clic en Más en el menú lateral y ve a Configuración y privacidad. Accede a tus datos: Selecciona Tu cuenta > Descargar un archivo de tus datos

TikTok En el móvil: Ve a tu perfil y toca el icono del Menú (tres líneas horizontales) en la esquina superior derecha. Accede a tus datos: Selecciona Ajustes y privacidad > Cuenta > Descargar tus datos.

Derecho de rectificación: Si tus datos son incorrectos, puedes pedir que los corrijan o puedes hacerlo tu mismo si la plataforma te permite

Derecho de cancelación: Puedes solicitar que eliminen tus datos cuando ya no sean necesarios, en las redes sociales básicamente seria dar de baja la cuenta definitivamente.

Derecho de oposición: Puedes negarte a que usen tus datos para publicidad o marketing.

Meta (Facebook e Instagram) Dentro del Centro de cuentas, ve a Tu información y permisos y busca la sección que habla sobre el uso de la información para modelos y funciones de IA generativa. Completa el formulario: Haz clic en Derecho a oponerte o Gestión de preferencias de datos y llena el formulario con tu información y los motivos de tu oposición. Meta te enviará un correo de confirmación una vez que acepte tu solicitud. Ajusta tus preferencias de anuncios: Para controlar los anuncios personalizados de forma más directa, ve a Centro de cuentas > Preferencias de anuncios. Aquí puedes elegir si deseas recibir anuncios personalizados o menos personalizados, basados en tu actividad con los socios publicitarios.

X (anteriormente Twitter) Ve a la configuración: Entra en tu perfil y haz clic en Más > Configuración y privacidad. Accede a la privacidad y seguridad: Selecciona Privacidad y seguridad y luego Anuncios personalizados. Desactiva los anuncios personalizados: Desmarca la casilla que indica "Anuncios personalizados".

TikTok Entra a la configuración: Ve a tu perfil y pulsa el icono de las tres líneas horizontales en la esquina superior derecha. Gestiona la privacidad: Selecciona Ajustes y privacidad > Anuncios. Desactiva la personalización: Deshabilita la opción de "Anuncios personalizados" o "Anuncios basados en la actividad" para reducir la relevancia de la publicidad que te aparece.

Recuerda: La Privacidad es Responsabilidad Compartida

La protección de tus datos personales no es solo responsabilidad de las empresas o del gobierno, sino también tuya.

Cada decisión que tomas en línea tiene consecuencias: desde qué publicas en redes sociales hasta cómo realizas tus transacciones digitales.

INDES-BID (2025). ¿Cómo ha evolucionado la protección de datos personales?. Disponible en: https://view.genially.com/68a9a407aa57a0f3d378a7a1

Si quieres también formarte y aprender más, inscríbete en: https://cursos.iadb.org/es/temas/desarrollo-instituciones/proteccion-datos-personales-bolivia (válido hasta el 18 de diciembre del 2025)

Radio chris

2023-06-18T19:09:00.006-04:00

radio

Ejecutar VSCode en ubuntu MATE via RDP desde windows

2017-03-22T19:21:00.000-04:00

Dentro de ubuntu MATE:
Paso 1: descargar el paquete de visual studio code .tar.gz
Paso 2: descomprimir
Paso 3: ejecutar en consola el comando:
# sudo sed -i 's/BIG-REQUESTS/_IG-REQUESTS/' /usr/lib/x86_64-linux-gnu/libxcb.so.1

Paso 4: ejecutar en consola el comando, dentro de la carpeta donde se descomprimio vs code:
# ./code
.

Escritorio remoto en ubuntu MATE

2017-03-22T18:54:00.000-04:00

Paso 1: Se debe instalar en ubuntu MATE:
sudo apt-get install xrdp

Paso 2: Luego acceder desde windows como si de un cliente windows se tratara, desde windows ingresar:
"mstsc.exe"

Paso 3: Colocar la direccion ip

Paso 4:
Ingresar usuario y contraseña

Instalar .Net Framework 3.5 en Windows 10

2017-03-07T16:22:00.001-04:00

En el cmd ingresar:

DISM /Online /Enable-Feature /FeatureName:NetFx3 /All /LimitAccess /Source:d:\sources\sxs

cuando d: es el volumen del disco de instalación

Musgo pared

2016-09-05T18:48:00.000-04:00

Graffiti natural

3 tazas de musgo (lavado, libre de partículas del suelo)
2 tazas de suero de leche o 2 tazas de yoghurt (debe ser yoghurt natural)
2 tazas de agua o cerveza
Media cucharadita de azúcar
jarabe de maíz (opcional)
una licuadora (que es probable que no quieras utilizar para otra cosa)

Procedimiento:
batir todo y pintar una pared porosa con la soluci´no, poco a poco ira creciendo y formandose musgo.

fuente:
http://www.aldeaviral.com/el-hizo-el-proyecto-mas-genial-y-posiblemente-ilegal-que-he-visto-el-resultado-es-lo-mejor/

INTEROPERABILIDAD JAVA .NET

2016-03-29T15:50:00.001-04:00

Interoperabilidad entre .Net y J2EE

Contenido

Introducción
La Necesidad es del Negocio
¿Cómo lograrlo?
Mecanismos Orientados a Servicios
CORBA y Remoting, la Misión
Construyendo Puentes
Máxima Velocidad
Conversión de Plataforma y Cross-Compiling
Conclusión: Abriendo la Caja de Pandora
Enlaces

Introducción

Más allá de nuestras preferencias personales todos sabemos que existen hoy dos plataformas dominantes para el desarrollo de software: .Net y J2EE. La tendencia aparente, y mi sensación personal, es que ninguna de ellas se impondrá de forma absoluta sino que, de alguna u otra manera, se repartirán el mercado. En la mayoría de los casos veremos cómo se establecen entornos mixtos donde ambas tecnologías trabajarán en conjunto.

La Necesidad es del Negocio

Más allá de lo estrictamente técnico, existen variadas razones que provocan la existencia de ambientes heterogéneos en las empresas. Casi una mezcla de circo y museo, se conjuga lo último y lo antiguo con distintos sistemas operativos, bases de datos y plataformas de aplicaciones.

Es que al entrar en juego factores tan diversos tales como los cambios de estrategia desde la alta dirección, la selección de nuevos proveedores de software, el outsourcing del desarrollo, los recortes presupuestarios, las fusiones entre empresas, crisis y otras cuestiones político/económicas, hacen que inevitablemente las medianas y grandes empresas tengan “un poco de cada cosa”.

Veamos algunos escenarios posibles que pueden hacer necesaria la integración entre aplicaciones J2EE y .Net:

Surge un proyecto nuevo basado en .Net que tiene que reutilizar un set de librerías Java cuya migración es inviable, ya sea por su complejidad, por la inexistencia de documentación o bien porque se dispone únicamente de binarios desarrollados por terceros (que no participan del proyecto, claro).
El mecanismo estándar definido por las políticas internas de la empresa para comunicarse con otros sistemas propietarios, SAP, AS400 o elDatawarehouse está implementado únicamente en una sola de las dos plataformas.
El directorio de una empresa toma una decisión estratégica que dicta la migración de todos los sistemas a una plataforma única. La casa matriz decide que a partir de ahora “todas las aplicaciones serán construidas en la plataforma X”.
Se decide instalar una misma aplicación para todas las empresas de un mismo grupo y surgen casos donde la plataforma dominante es distinta a la prevista. Se prueban prototipos que una vez aprobados tienen que pasar a producción interactuando con plataformas distintas a la original. Dado que .Net y J2EE tienen fortalezas y debilidades que se complementan, se decide que una solución mixta podría hacer valer las fortalezas de cada una.

Encontraremos que casi la totalidad de las soluciones que existen apuntan a resolver el problema haciendo que la lógica desarrollada en Java/J2EE sea accedida desde C#/.Net y, en muy pocos casos, en sentido contrario. Esto tiene que ver con el hecho de que Java, y en particular J2EE, dominan fuertemente el ambiente corporativo donde se establecieron bastante antes del surgimiento de Microsoft .Net.

Tengamos en cuenta que la publicación del modelo J2EE impactó fuertemente en este sector al establecer una infraestructura basada en estándares abiertos para aplicaciones distribuidas incluyendo transacciones, seguridad, componentes server-side, acceso a datos, persistencia, clustering y balanceo de carga. El bonus adicional del modelo tiene que ver con asegurarse la independencia de un proveedor específico ya que teóricamente un desarrollo particular puede instalarse en cualquier plataforma que respete el estándar (esta “compatibilidad asegurada” se vio afectada negativamente cuando los proveedores empezaron a incorporar mejoras adicionales cubriendo las falencias del estándar). En este sentido, a pesar de que .Net es una excelente opción para el desarrollo de software, como participante tardío de esta carrera todavía tiene camino por recorrer para consolidarse.

¿Cómo lograrlo?

La aproximación más sencilla que podemos implementar es una base de datos de uso compartido, donde a través de JDBC y ADO .Net nuestras aplicaciones J2EE y .Net, respectivamente, puedan acceder para escribir y leer información. Esta opción tiene mucho sentido si consideramos componentes que en ambos casos se encuentren en la capa de negocios. Para hacer interoperar componentes que se encuentren en diferentes capas, el mecanismo a emplear dependerá del punto de interconexión que estemos considerando (Ver Figura 1).

Figura 1: Puntos de interconexión para aplicaciones multi-capa.

Si el punto de interconexión se extiende a través de Internet o una intranet, la alternativa natural es la utilización de Web Services. Tenemos herramientas para generarlos y consumirlos en ambas plataformas y cuentan con la ventaja de ser estándares abiertos que nos permitirán conservar la compatibilidad con futuras aplicaciones. Estaremos limitados, eso sí, por la velocidad del enlace y el costo de emplear XML para transmitir los mensajes.

Si no disponemos de un enlace permanente o el que tenemos es poco confiable, tendremos que considerar servicios de mensajería asíncrona que usualmente emplearemos para la interacción entre las capas de negocios y de datos. Lo que se hace es implementar colas de mensajes en cada una de las plataformas e interconectarlas a través de un bridge (cada aplicación produce y consume mensajes a través de la API habitual). Por otra parte, si podemos sacrificar el soporte de transacciones y callbacks, es posible generar un wrapper que permita el acceso a través de un Web Service.

Cuando lo que estamos buscando es acceder a nivel de clases y métodos, tendremos que optar por un runtime bridge. Estos componentes se agregan en cada plataforma para administrar la interacción y comunicación entre objetos de diferente origen.

Si nos animamos a una solución de más bajo nivel podemos llegar a eliminar el overhead de la comunicación remota aprovechando los métodos de interacción con código nativo que tiene cada plataforma.

Por último, si estamos encarando una migración masiva a gran escala, lo que seguramente resulte más conveniente sea emplear herramientas de conversión de plataforma, las cuales se hacen cargo del mapeo de tipos y de proporcionar las APIs correspondientes.

Mecanismos Orientados a Servicios

¿Qué es lo primero que nos viene a la mente cuando nos hablan de integración de aplicaciones? Algo que la maquinaria publicitaria viene machacando desde hace algunos años: ¡Los Web Services, por supuesto! Tenemos la ventaja de que se trata de un mecanismo estándar y que existen en ambas plataformas (aunque lo de “estándar” es algo bastante relativo pues todavía falta un poco para que los proveedores se pongan de acuerdo al respecto).

Repasemos brevemente el funcionamiento de un Web Service como mecanismo de integración en la Figura 2, que se muestra a continuación:

Figura 2: Web Services.

La aplicación Java, que en este caso expone su funcionalidad a través de un Web Service, registra su descripción (1) a través de un archivo WDSL (Web Server Description Language) en un servidor UDDI (Universal Description , Discovery and Intregration), que funciona como un DNS para los servicios. La aplicación cliente (en este caso implementada en .Net) consulta (2) al servidor UDDI para poder generar un requerimiento con el formato adecuado. El requerimiento se envía (3) usando el protocolo SOAP (que encapsula la información con XML) sobre HTTP. El servicio recibe el requerimiento (4), lo procesa (5) y devuelve la respuesta (6) nuevamente utilizando SOAP. La aplicación cliente abre el “sobre” SOAP y interpreta el XML obteniendo la información (7) que necesitaba.

Los Web Services son útiles a la hora de integrar componentes a gran escala, dispersos geográficamente, y en donde se realizan unas pocas conexiones por unidad de tiempo. En otros casos, debido a sus limitaciones, pueden llegar a resultar poco recomendables. El overhead que introduce la serialización/deserialización de SOAP (XML) hace que tengamos que pagar un alto costo en la comunicación y en la conversión.

Tampoco será posible utilizarlos cuando necesitemos soporte nativo de transacciones, hacer callbacks, pasar objetos por referencia o estemos pensando en utilizar de forma extensiva la funcionalidad de una API (sería realmente poco práctico o más bien imposible tener que publicar cada uno de sus métodos). Si nuestra situación se identifica con esto último, sigamos avanzando para descubrir otras soluciones que nos permitan operar a nivel de clase.

CORBA y Remoting, la Misión

Si provienes del mundo Java, seguramente has escuchado acerca de CORBA (Common Object Request Broker Architecture), quizás no tanto si provienes de .Net. Dentro de este estándar para la comunicación de componentes distribuidos se emplea el protocolo IIOP (Internet Inter-ORB Protocol) para comunicar ciertas entidades definidas como ORB (Object Request Broker). Este estándar lleva bastante tiempo en el mercado y podríamos decir que tiene una difusión algo limitada debido a su alta complejidad (este punto genera ásperas discusiones entre sus defensores y detractores en los foros sobre aplicaciones distribuidas).

Dado que en Java se incluye una implementación parcial de CORBA con RMI/IIOP, varias soluciones de interoperabilidad aprovechan la flexibilidad deRemoting para armar channels y formatters específicos que den soporte al protocolo IIOP y a la conversión de tipos entre .NET e IDL (el lenguaje para definir interfases en CORBA). Esta sería la solución ideal para equipos de desarrollo que tengan experiencia usando CORBA entre aplicaciones Java o bien quieran establecer comunicación con otros ORB tales como mainframes o aplicaciones legacy.

Para empezar a jugar tenemos algunas soluciones freeware como Remoting .CORBA o IIOP .Net, que son muy interesantes. La última parece un poco más práctica porque incluye un generador para crear el archivo IDL, pero es todo cuestión de gustos.

Cualquiera sea el caso, es inevitable adquirir algo de experiencia en la plataforma destino ya que tendremos que meter bastante mano en las clases. La integración necesitará de un poco de refactoring tanto en la aplicación cliente como en la aplicación servidor. Podemos pensar en todo caso en soluciones comerciales. La apuesta es reducir el tiempo de desarrollo automatizando este proceso y ocultando la complejidad de la integración al programador. Por ejemplo, Janeva (un producto de Borland) se integra en el Visual Studio .Net. Cuando incluimos dentro de nuestro proyecto una referencia a un objeto Java remoto genera un proxy al cual podemos acceder en forma directa a través de Remoting, desentendiéndonos del mapeo entre tipos .Net e IDL en que se hace forma automática. (Ver Figura 3):

Figura 3: Acceso por CORBA con IIOP .Net y Janeva.

Al compilar el proyecto, se agrega al assembly un runtime que se hace cargo de la comunicación entre IIOP y Remoting, manteniendo actualizados los proxies para que “espejen” el comportamiento del objeto destino y su estado.

Construyendo Puentes

Si jamás utilizamos CORBA, IDL nos suena a aprender chino; si la cuestión de los ORB nos resulta algo confusa, tenemos otras opciones que utilizan el camino inverso: en lugar de implementar un protocolo Java-compatible, trasladan Remoting a Java. Los productos más representativos son: Ja.Net de Intrinsync y JNBridgePro de JNBridge. Para hacer el “bridging” instalan un runtime de cada lado el cual se encarga de:

Establecer la comunicación entre las plataformas usando Remoting, principalmente con TCP y serialización binaria, aunque HTTP/SOAP también esté soportado.
Crear un proxy C# para cada clase Java que se quiere acceder.
Crear un proxy Java para cada clase .Net que se quiere acceder.
El mapeo de clases y tipos y la conversión de los valores de retorno en cada caso.
La invocación de métodos en objetos .Net desde Java.
La invocación de métodos en objetos Java desde .Net.
Propagar excepciones entre Java y .Net, y viceversa.
Brindar soporte de callbacks.

Tal como aparece en el esquema de funcionamiento que se muestra en la Figura 4, soportado por ambas herramientas:

Figura 4: Esquema de un runtime bridge

Máxima Velocidad

Las alternativas que hemos visto hasta ahora comparten la restricción de tener que publicar obligatoriamente una referencia remota para hacer que el objeto esté disponible en la otra plataforma. Esto necesita de una infraestructura de soporte para la comunicación, control y conversión de tipos.

En la búsqueda de una mayor performance podemos avanzar un paso más y operar directamente a bajo nivel para resolver este problema aprovechando los mecanismos para acceder a código nativo (binario propio del sistema) que proporcionan tanto Java como .Net.

JuggerNet es un producto que aprovecha esta vuelta de tuerca brindando herramientas para facilitar el proceso. Para usarlo, lo primero que tenemos que hacer es seleccionar las clases Java y generar (cuando no) los correspondientes proxies en .Net, para luego poder programar directamente contra estas clases sin inconvenientes o servicios adicionales. Las clases proxy tienen que comportarse y tener el mismo estado que sus homólogas Java. Para conseguirlo, el runtime C# de JuggerNET emplea JNI (Java Native Interfase) para instanciar una JVM (Java Virtual Machine) donde se crean los objetos de las clases Java que queremos acceder y manipular. Ahora, como JNI es una API en C no es posible usarla directamente desde C#, sino es a través de una DLL que se accede con Pinvoke (Platform Invocation Services), el mecanismo que .Net ofrece para acceder a código nativo escrito como funciones sueltas no orientadas a objetos tales como las DLLs de la API Win32.

Veamos cómo es la secuencia de funcionamiento. El runtime en C# que instala JuggerNet recibe los requerimientos que nuestro código le hace a las clases proxy que se generaron en el primer paso y se los reenvía a la DLL en C que se comunica a través de JNI con la máquina virtual Java que hemos creado para ejecutar los métodos correspondientes o bien leer el estado de algún objeto en particular (Ver Figura 5):

Figura 5: Interconexión C#/pInvoke/JNI/JVM.

El runtime se hace cargo además de la parte más compleja del asunto, la que tiene que ver con el mapeo de tipos, la propagación de excepciones y los callbacks. El siguiente fragmento de código genera una caja de dialogo Java hecha con Swing para ingresar información en una aplicación .Net:

Using System;
Using Java;
 
Clase Ejemplo 
{
public static void Main()
{
string color = JoptionPane.showInputDialog ("Cual es tu color preferido?");
Console.WriteLine("Elegiste: " + color.ToLower());
}
}

Como vemos, la integración a nivel código es la más transparente de todas pero exige un nivel de conocimiento mucho más profundo.

Conversión de Plataforma y Cross-Compiling

Finalmente, para el escenario de migración a plataforma única hablaremos del enfoque más drástico de todos, que consiste en realizar una conversión total de nuestras aplicaciones. Nos llevaría muchísimo tiempo, demasiado, revisar y convertir todo nuestro código fuente en forma manual. Peor aún resulta la búsqueda de equivalencias entre tipos y servicios que nos brinda cada una de las APIs de las plataformas.

Conozcamos entonces cómo trabajan dos soluciones comerciales que se hacen cargo de esta tarea: iNET de Stryon y Visual MainWin de MainSoft.

Ambos productos se integran en Visual Studio haciendo que podamos usar referencias a clases Java, librerías de J2SE o a componentes tales como EJBs. Cuando compilamos, se generan assemblies "tradicionales" en MSIL (el "assembler" de .NET).

A partir del MSIL, MainWin produce el bytecode Java (archivos .class) directamente; en cambio, iNET genera primero el código fuente (archivos .java) y luego lo compila. El objetivo en ambos casos es el mismo: componer algo que pueda correr en una máquina virtual Java (Ver Figura 6):

Figura 6: Conversión de Plataforma / APIs.

En la conversión, estas herramientas aplican un conjunto de reglas para mapear llamadas a API, primitivas y tipos a sus equivalentes en Java. Para aquellas cosas que no tienen un equivalente, se genera código que lo resuelve aprovechando el runtime propietario que es necesario instalar en el server J2EE.

Este runtime además contiene la versión Java de distintas API del .Net Framework, tales como ASP .Net, ADO .Net, WinForms, Remoting, y otras. Cuando finaliza la conversión, se empaqueta la aplicación en un JAR, WAR o en un EAR para su deployment en el server J2EE.

Como todo el código se termina ejecutando en la plataforma Java, si la implementación de las API es eficiente, no notaremos diferencia alguna en su funcionamiento respecto de otras aplicaciones que tengamos corriendo.

Sin embargo, el framework .Net es grande, tiene miles de clases y resulta muy complejo (¡Pregunta a los muchachos del proyecto MONO si no lo crees así!). A menos que tengamos totalmente controlado el código que generemos, es muy probable que algunas funciones que usemos no estén totalmente soportadas. El desarrollo en Java por su parte, pierde en portabilidad ya que depende del runtime que contiene la implementación de las API de .Net.

Conclusión: Abriendo la Caja de Pandora

La integración de aplicaciones sigue siendo una tarea artesanal; no existe nada que pueda reemplazar la experiencia real programando en cada una de las plataformas. Mi consejo es que llegado el caso, lo más conveniente es en primer lugar evaluar detalladamente la necesidad, luego identificar un par de estrategias factibles y testear cómo se comportan en una prueba de concepto. La aplicación de prueba de concepto debe incluir código que atraviese todas las capas que la conforman (lo que comúnmente se conoce como slice) y debe ser testeada con un volumen de carga acorde a su destino real.

Si no es hoy, será mañana, pero seguramente pronto vas a tener la oportunidad de cruzar la frontera que separa ambos mundos, ¡Buena suerte, pionero!

Enlaces

Remoting
JNBridge Pro, www.jnbridge.com/jnbpropg.htm
Ja.NET, http://ja.net.intrinsyc.com/

Remoting y IIOP
Janeva, www.borland.com/janeva/
Remoting .CORBA, remoting-corba.sourceforge.net/IIOP .NET, iiop-net.sourceforge.net/

Conversión de Plataforma
MainWin, www.mainsoft.com/

Conversión Directa por JNI
JuggerNET, www.codemesh.com/

Interop con .COM
J-Integra Pure Java Runtime, j-integra.intrinsyc.com/

Fuente
https://msdn.microsoft.com/es-es/library/bb972252.aspx

Error Entity developer

2016-02-26T17:34:00.003-04:00

Cuando quise remapear mi base de datos me encontré con este error

La solución es sustituir dichas fuentes, con otras de otra computadora. Las fuentes se sustituyen ingresando a Panel de control/apariencia y presentación/Fuentes

Sustituir ambas fuentes:

Reiniciar Visual studio y ya se encontrara solucionado el error y se podrá remapear con normalidad

Compatibilidad y consideraciones C#-Java

2016-02-18T16:27:00.000-04:00

En este tema se describen algunas de las similitudes y diferencias principales en cómo se representan y asignan los datos, y se recolectan los elementos no utilizados en Java y en C#.

Tipos de datos compuestos

El concepto de clase como tipo de datos compuesto de campos, métodos y eventos es similar en Java y C#. (La herencia de clases se describe independientemente en el tema titulado Herencia y clases derivadas (C# y Java).) C# introduce el concepto de estructura como tipo de datos compuesto asignado por pila que no admite la herencia. En la mayoría de los otros aspectos, las estructuras son muy similares a las clases. Las estructuras proporcionan una manera ligera de agrupar campos y métodos relacionados para el uso en los bucles de pequeñas dimensiones y otros escenarios donde el rendimiento es crucial.

C# permite crear un método de destructor al que se llama antes de que se destruyan las instancias de una clase. En Java, se puede utilizar un método finalize para contener código que limpia los recursos antes de que se recolecten los elementos no utilizados del objeto. En C#, el que realiza esta función es el destructor de clase. El destructor se parece a un constructor sin los argumentos y con un carácter de tilde delante (~).

Tipos de datos integrados

C# proporciona todos los tipos de datos que están disponibles en Java y agrega compatibilidad para los números sin signo y un nuevo tipo de punto flotante de 128 bits de alta precisión.

Para cada tipo de datos primitivo en Java, la biblioteca de clases principal proporciona una clase contenedora, que lo representa como un objeto de Java. Por ejemplo, la clase Int32 contiene el tipo de datos int y la clase Double contiene el tipo de datos double.

Por otro lado, todos los tipos de datos primitivos en C# son objetos en el espacio de nombres System. Para cada tipo de datos, se proporciona un nombre corto o alias. Por ejemplo, int es el nombre corto correspondiente a System.Int32 y double es la forma abreviada de System.Double.

En la tabla siguiente se proporciona la lista de tipos de datos de C# y sus alias. Como puede ver, los primeros ocho de estos tipos corresponden a los tipos primitivos disponibles en Java. Sin embargo, tenga en cuenta que el tipo boolean de Java se denomina boolen C#.

Nombre corto	Clase .NET	Tipo	Ancho	Intervalo (bits)
byte	Byte	Entero sin signo	8	0 a 255
sbyte	SByte	Entero con signo	8	-128 a 127
int	Int32	Entero con signo	32	-2.147.483.648 a 2.147.483.647
uint	UInt32	Entero sin signo	32	0 a 4294967295
short	Int16	Entero con signo	16	-32.768 a 32.767
ushort	UInt16	Entero sin signo	16	0 a 65535
long	Int64	Entero con signo	64	-922337203685477508 a 922337203685477507
ulong	UInt64	Entero sin signo	64	0 a 18446744073709551615
float	Single	Tipo de punto flotante de precisión simple	32	-3,402823e38 a 3,402823e38
double	Double	Tipo de punto flotante de precisión doble	64	-1,79769313486232e308 a 1,79769313486232e308
char	Char	Un carácter Unicode	16	Símbolos Unicode utilizados en el texto
bool	Boolean	Tipo Boolean lógico	8	True o false
object	Object	Tipo base de todos los otros tipos
string	String	Una secuencia de caracteres
decimal	Decimal	Tipo preciso fraccionario o integral, que puede representar números decimales con 29 dígitos significativos	128	±1.0 × 10e−28 a ±7.9 × 10e28

Dado que C# representa todos los tipos de datos primitivos como objetos, es posible llamar a un método de objeto de un tipo de datos primitivo. Por ejemplo:

static void Main()
{
    int i = 10;
    object o = i;
    System.Console.WriteLine(o.ToString());
}

Esto se logra con la ayuda de las conversiones automáticas boxing y unboxing. Para obtener más información, vea Conversión boxing y unboxing (Guía de programación de C#).

Constantes

Java y C# proporcionan la capacidad para declarar una variable cuyo valor se especifica en tiempo de compilación y no se puede cambiar en tiempo de ejecución. Java utiliza el modificador de campo final para declarar este tipo de variable, mientras que C# utiliza la palabra clave const. Además de const, C# proporciona la palabra clave readonly para declarar variables a las que se puede asignar un valor una vez en tiempo de ejecución, ya sea en la instrucción de declaración o en otra parte del constructor. Después de la inicialización, el valor de una variable readonly no puede cambiar. Un escenario en el que las variables readonly son útiles es cuando los módulos que se han compilado independientemente tienen que compartir datos como un número de versión. Si el módulo A se actualiza y se vuelve a compilar con un nuevo número de versión, el módulo B se puede inicializar con ese nuevo valor constante sin tener que volver a compilarlo.

Enumeraciones

Las enumeraciones se utilizan para agrupar constantes con nombres en forma similar a la forma en que se utilizan en C y C++; no están disponibles en Java. En el ejemplo siguiente se define una enumeración Color sencilla.

public enum Color
{
    Green,   //defaults to 0
    Orange,  //defaults to 1
    Red,     //defaults to 2
    Blue     //defaults to 3
}

También se pueden asignar valores integrales a las enumeraciones, tal como se muestra en la siguiente declaración de enumeración:

public enum Color2
{
    Green = 10,
    Orange = 20,
    Red = 30,
    Blue = 40
}

En el siguiente ejemplo de código se llama al método GetNames del tipo Enum para mostrar las constantes disponibles para una enumeración. Luego, asigna un valor a una enumeración y muestra el valor.

class TestEnums
{
    static void Main()
    {
        System.Console.WriteLine("Possible color choices: ");

        //Enum.GetNames returns a string array of named constants for the enum.
        foreach(string s in System.Enum.GetNames(typeof(Color)))
        {
            System.Console.WriteLine(s);
        }

        Color favorite = Color.Blue;

        System.Console.WriteLine("Favorite Color is {0}", favorite);
        System.Console.WriteLine("Favorite Color value is {0}", (int) favorite);
    }
}

Resultado

Possible color choices:

Green

Orange

Red

Blue

Favorite Color is Blue

Favorite Color value is 3

Cadenas

Los tipos de cadena en Java y C# denotan un comportamiento similar con leves diferencias. Ambos tipos de cadena son inmutables, lo que significa que los valores de las cadenas no se pueden cambiar una vez que se han creado las cadenas. En ambos casos, los métodos que parecen modificar el contenido real de una cadena crean en realidad una nueva cadena que se devolverá como resultado, dejando la cadena original sin cambios. El proceso de comparación de los valores de cadena es diferente en C# y Java. Para comparar los valores de cadena en Java, los desarrolladores deben llamar al método equals de un tipo string, mientras que el operador == compara los tipos de referencia de forma predeterminada. En C#, los desarrolladores pueden utilizar los operadores == o != para comparar directamente valores de cadena. Aunque una cadena es un tipo de referencia en C#, los operadores == y != compararán, en forma predeterminada, los valores de las cadenas en lugar de las referencias.

Como en Java, los desarrolladores de C# no deben usar el tipo string para concatenar cadenas con el fin de evitar la sobrecarga de crear nuevas clases de cadenas cada vez que se concatene la cadena. En su lugar, los desarrolladores pueden utilizar la clase StringBuilder, que es funcionalmente equivalente a la clase StringBuffer de Java.

Literales de cadena

C# proporciona la posibilidad de evitar el uso de secuencias de escape como "\t" para la ficha o "\" para los caracteres de barra diagonal inversa dentro de las constantes de cadena. Para ello, simplemente declare la cadena textual mediante el símbolo @ para preceder la asignación del valor de cadena. Los siguientes ejemplos muestran cómo utilizar los caracteres de escape y cómo asignar literales de cadena:

static void Main()
{
    //Using escaped characters:
    string path1 = "\\\\FileShare\\Directory\\file.txt";
    System.Console.WriteLine(path1);

    //Using String Literals:
    string path2 = @"\\FileShare\Directory\file.txt";
    System.Console.WriteLine(path2);
}

Conversión y conversión de tipos

Java y C# siguen reglas similares para la conversión automática y la conversión de tipos de datos.

Al igual que Java, C# admite conversiones de tipo implícitas y explícitas. En el caso de conversiones de ampliación, las conversiones son implícitas. Por ejemplo, la siguiente conversión de int a long es implícita, como en Java:

int int1 = 5;
long long1 = int1;  //implicit conversion

La siguiente es una lista de conversiones implícitas entre los tipos de datos de .NET Framework:

Tipo de origen	Tipo de destino
Byte	short, ushort, int, uint, long, ulong, float, double o decimal
Sbyte	short, int, long, float, double o decimal
Int	long, float, double o decimal
Uint	long, ulong, float, double o decimal
Short	int, long, float, double o decimal
Ushort	int, uint, long, ulong, float, double o decimal
Long	float, double o decimal
Ulong	float, double o decimal
Float	double
Char	ushort, int, uint, long, ulong, float, double o decimal

Puede convertir el tipo de expresiones que desee convertir explícitamente usando la misma sintaxis que en Java:

long long2 = 5483;
int int2 = (int)long2;  //explicit conversion

La tabla siguiente muestra las conversiones explícitas.

Tipo de origen	Tipo de destino
Byte	sbyte o char
Sbyte	byte, ushort, uint, ulong o char
Int	sbyte, byte, short, ushort, uint, ulong o char
Uint	sbyte, byte, short, ushort, int o char
Short	sbyte, byte, ushort, uint, ulong o char
Ushort	sbyte, byte, short o char
Long	sbyte, byte, short, ushort, int, uint, ulong o char
Ulong	sbyte, byte, short, ushort, int, uint, ulong o char
Float	sbyte, byte, short, ushort, int, uint, long, ulong, char o decimal
Double	sbyte, byte, short, ushort, int, uint, long, ulong, char o decimal
Char	sbyte, byte o short
Decimal	sbyte, byte, short, ushort, int, uint, long, ulong, char, float o double

Tipos de referencia y valor

C# admite dos tipos de variables:

Tipos de valor

Estos son los tipos de datos primitivos integrados, como char, int y float, así como también los tipos definidos por el usuario declarados con la estructura.
Tipos de referencia

Clases y otros tipos de datos complejos que se construyen a partir de los tipos primitivos. Las variables de estos tipos no contienen una instancia del tipo, sino sólo una referencia a una instancia.

Si se crean dos variables del tipo de valor, i y j, como se muestra a continuación, i y j son completamente independientes entre sí:

int i = 10;
int j = 20;

Tienen ubicaciones de memoria independiente:

Si cambia el valor de una de estas variables, la otra no se verá afectada de forma natural. Por ejemplo, si tiene una expresión como la siguiente, aún no existe ninguna conexión entre las variables:

int k = i;

Es decir, si cambia el valor de i, k permanecerá con el valor que tenía i en el momento de la asignación.

i = 30;

System.Console.WriteLine(i.ToString());  // 30
System.Console.WriteLine(k.ToString());  // 10

Sin embargo, los tipos de referencia actúan de forma diferente. Por ejemplo, podría declarar dos variables de la siguiente forma:

Employee ee1 = new Employee();
Employee ee2 = ee1;

Ahora, puesto que las clases son tipos de referencia de C#, ee1 se conoce como referencia a Employee. La primera de las dos líneas anteriores crea una instancia de Employee en memoria y define ee1 para que haga referencia a ella. Así, cuando se establece ee2 para que sea igual a ee1, el primero contiene un duplicado de la referencia a la clase de la memoria. Si ahora cambia las propiedades de ee2, las propiedades de ee1 reflejan estos cambios, ya que ambas apuntan al mismo objeto de la memoria, tal como aparece a continuación:

Conversiones boxing y unboxing

El proceso de convertir el tipo de un valor en el tipo de una referencia se denomina conversión boxing. El proceso inverso, convertir el tipo de una referencia en el tipo de un valor, se denomina conversión unboxing. Esto queda reflejado en el ejemplo de código siguiente:

int i = 123;      // a value type
object o = i;     // boxing
int j = (int)o;  // unboxing

Java requiere que esas conversiones se realicen manualmente. Los tipos de datos primitivos se pueden convertir en objetos de clases contenedoras construyendo esos objetos o aplicando la conversión boxing. De igual manera, los valores de los tipos de datos primitivos se pueden extraer de los objetos de las clases contenedoras llamando a un método adecuado de estos objetos, o realizar una conversión unboxing. Para obtener más información acerca de las conversiones boxing y unboxing, vea Conversión boxing y unboxing (Guía de programación de C#).

Conversión boxing y unboxing (Guía de programación de C#)

La conversión boxing es el proceso de convertir Tipos de valores (Referencia de C#) en el tipo object o en cualquier tipo de interfaz implementado por este tipo de valor. Cuando CLR aplica la conversión boxing a un tipo de valor, ajusta el valor dentro de un elemento System.Object y lo almacena en el montón administrado. La conversión unboxing extrae el tipo de valor del objeto. En el ejemplo siguiente, se aplica la conversión boxing a la variable de tipo entero i y esta se asigna al objeto o.

int i = 123;
object o = (object)i;  // boxing

A continuación, se puede aplicar la conversión unboxing al objeto o y asignarlo a la variable de entero i:

o = 123;
i = (int)o;  // unboxing

Rendimiento

Con relación a las asignaciones simples, las conversiones boxing y unboxing son procesos que consumen muchos recursos. Cuando se aplica la conversión boxing a un tipo de valor, se debe asignar y construir un objeto completamente nuevo. En menor grado, la conversión de tipos requerida para aplicar la conversión unboxing también es costosa. Para obtener más información, vea Rendimiento (Guía de programación de C#).

Boxing

La conversión boxing se utiliza para almacenar tipos de valor en el montón de recolección de elementos no utilizados. Boxing es una conversión implícita de Tipos de valores (Referencia de C#) al tipo object o a cualquier tipo de interfaz implementado por este tipo de valor. Al aplicar la conversión boxing a un tipo de valor se asigna una instancia de objeto en el montón y copia el valor en el nuevo objeto.

Considere la siguiente declaración de una variable de tipo de valor:

int i = 123;

La siguiente instrucción aplica implícitamente la operación de boxing sobre la variable i:

object o = i;  // Implicit boxing

El resultado de esta instrucción es crear una referencia de objeto o en la pila que hace referencia a un valor del tipo int en el montón. Este valor es una copia del valor del tipo de valor asignado a la variable i. La diferencia entre las dos variables, i y o, se muestra en la siguiente ilustración.

Conversión Boxing

También es posible realizar la conversión boxing de manera explícita, tal como se muestra en el ejemplo siguiente, pero ésta nunca es necesaria:

int i = 123;
object o = (object)i;  // explicit boxing

Descripción

Este ejemplo convierte una variable de entero i en un objeto o mediante la conversión boxing. A continuación, el valor almacenado en la variable ise cambia de 123 a 456. El ejemplo muestra que el tipo de valor original y el objeto empaquetado usan ubicaciones de memoria independientes y, por consiguiente, pueden almacenar valores diferentes.

Ejemplo

class TestBoxing
{
    static void Main()
    {
        int i = 123;
        object o = i;  // Implicit boxing

        i = 456;  // Change the contents of i

        System.Console.WriteLine("The value-type value = {0}", i);
        System.Console.WriteLine("The object-type value = {0}", o);
    }
}
/* Output:
    The value-type value = 456
    The object-type value = 123
*/

El ejemplo siguiente muestra un caso de conversión unboxing no válida y la excepción InvalidCastExceptionresultante. Si se utiliza try y catch, se muestra un mensaje de error cuando se produce el error.

class TestUnboxing
{
    static void Main()
    {
        int i = 123;
        object o = i;  // implicit boxing

        try
        {
            int j = (short)o;  // attempt to unbox

            System.Console.WriteLine("Unboxing OK.");
        }
        catch (System.InvalidCastException e)
        {
            System.Console.WriteLine("{0} Error: Incorrect unboxing.", e.Message);
        }
    }
}

Este programa produce el siguiente resultado:

Specified cast is not valid. Error: Incorrect unboxing.

Si cambia la instrucción:

int j = (short) o;

int j = (int) o;

la conversión se realizará y se obtendrá el resultado:

Unboxing OK.

Unboxing

Unboxing es una conversión explícita del tipo object a un tipo de valor o de un tipo de interfaz a un tipo de valor que implementa la interfaz. Una operación de unboxing consiste en:

Comprobar la instancia de objeto para asegurar que se trata de un valor de conversión boxing del tipo de valor dado.
Copiar el valor de la instancia en la variable de tipo de valor.

Las siguientes instrucciones muestran las operaciones de boxing y unboxing:

int i = 123;      // a value type
object o = i;     // boxing
int j = (int)o;  // unboxing

En la ilustración siguiente se muestra el resultado de las instrucciones anteriores.

Conversión Unboxing

Para que la conversión Unboxing de tipos de valores sea correcta en tiempo de ejecución, el elemento al que se aplica debe ser una referencia a un objeto creado previamente mediante la conversión Boxing de una instancia de dicho tipo de valor. Si se intenta aplicar la conversión unboxing anull o una referencia a un tipo de valor incompatible, se producirá una excepción InvalidCastException.

Herencia y clases derivadas (C# y Java)

La funcionalidad de una clase existente se puede extender al crear una nueva clase que se deriva de ella. La clase derivada hereda las propiedades de la clase base y es posible agregar o reemplazar métodos y propiedades según sea necesario.

En C#, el operador :, que equivale a extends e implements en Java, define la herencia e implementación de interfaces. La clase base siempre debe estar en el extremo izquierdo en la declaración de clase.

Como Java, C# no admite herencia múltiple, lo que significa que las clases no pueden heredar más de una clase. Sin embargo, se pueden utilizar interfaces para ese propósito, de la misma manera que en Java.

El código siguiente define una clase denominada CoOrds con dos variables miembro privadas x e y que representan la posición del punto. Se tiene acceso a estas variables mediante propiedades denominadas X e Y, respectivamente:

public class CoOrds
{
    private int x, y;

    public CoOrds()  // constructor
    {
        x = 0;
        y = 0;
    }

    public int X
    {
        get { return x; }
        set { x = value; }
    }

    public int Y
    {
        get { return y; }
        set { y = value; }
    }
}

Una nueva clase, denominada ColorCoOrds, se deriva de la clase CoOrds del siguiente modo:

public class ColorCoOrds : CoOrds

Luego, ColorCoOrds hereda todos los campos y métodos de la clase base, a la cual se pueden agregar nuevos campos y métodos para proporcionar características adicionales en la clase derivada, según sea necesario. En este ejemplo, se agrega un miembro privado y descriptores de acceso para agregar color a la clase:

public class ColorCoOrds : CoOrds
{
    private System.Drawing.Color screenColor;


    public ColorCoOrds()  // constructor
    {
        screenColor = System.Drawing.Color.Red;
    }

    public System.Drawing.Color ScreenColor
    {
        get { return screenColor; }
        set { screenColor = value; }
    }
}

El constructor de la clase derivada llama implícitamente al constructor de la clase base o la superclase, en terminología de Java. En caso de herencia, se llama a todos los constructores de clase base antes que a los constructores de la clase derivada en el orden en que las clases aparecen en la jerarquía de clases.

Convertir un tipo a una clase base

Como en Java, no se puede utilizar una referencia a una clase base para tener acceso a los miembros y métodos de una clase derivada, aunque la referencia de la clase base pueda contener una referencia válida a un objeto del tipo derivado.

Implícitamente, se puede hacer referencia a una clase derivada con una referencia al tipo derivado:

ColorCoOrds color1 = new ColorCoOrds();
CoOrds coords1 = color1;

En este código, la referencia de clase base, coords1, contiene una copia de la referencia color1.

La palabra clave base

Se puede tener acceso a los miembros de clase base en una subclase incluso cuando los miembros de base se reemplazan en la superclase utilizando la palabra clave base. Por ejemplo, puede crear una clase derivada que contenga un método con la misma firma que la clase base. Si se precede ese método con la palabra clave new, se indica que se trata de un método totalmente nuevo que pertenece a la clase derivada. También se podría proporcionar un método para tener acceso al método original de la clase base con la palabra clave base.

Por ejemplo, supongamos que la clase base CoOrds tuviera un método denominado Invert() que intercambia las coordenadas x e y. Se podría proporcionar un sustituto para este método en la clase derivada ColorCoOrds con un código como éste:

public new void Invert()
{
    int temp = X;
    X = Y;
    Y = temp;
    screenColor = System.Drawing.Color.Gray;
}

Como se puede observar, este método intercambia x e y, luego establece el color del punto en gris. Se podría proporcionar acceso a la implementación base para este método creando otro método en ColorCoOrds, como el de este ejemplo:

public void BaseInvert()
{
    base.Invert();
}

A continuación, se invoca el método base en un objeto ColorCoOrds mediante una llamada al método BaseInvert().

ColorCoOrds color1 = new ColorCoOrds();
color1.BaseInvert();

Recuerde que se obtendría el mismo efecto si se asignara una referencia de la clase base a una instancia de ColorCoOrds y, a continuación, se tuviera acceso a sus métodos:

CoOrds coords1 = color1;
coords1.Invert();

Seleccionar los constructores

Los objetos de clase base siempre se construyen antes que cualquier clase derivada. De esta forma, el constructor de la clase base se ejecuta antes que el constructor de la clase derivada. Si la clase base tiene más de un constructor, la clase derivada puede decidir a qué constructor se va a llamar. Por ejemplo, podría modificar la clase CoOrds para agregar un segundo constructor, del siguiente modo:

public class CoOrds
{
    private int x, y;

    public CoOrds()
    {
        x = 0;
        y = 0;
    }

    public CoOrds(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

Luego, podría cambiar la clase ColorCoOrds para utilizar uno de los constructores disponibles mediante la palabra clave base:

public class ColorCoOrds : CoOrds
{
    public System.Drawing.Color color;

    public ColorCoOrds() : base ()
    {
        color = System.Drawing.Color.Red;
    }

    public ColorCoOrds(int x, int y) : base (x, y)
    {
        color = System.Drawing.Color.Red;
    }
}

En Java, esta funcionalidad se implementa con la palabra clave super.

Reemplazar el método

Una clase derivada puede reemplazar el método de una clase base si se proporciona una nueva implementación del método declarado. Una diferencia importante entre Java y C# es que, de forma predeterminada, los métodos de Java se marcan como virtuales, mientras que en C# los métodos se deben marcar explícitamente como virtuales con el modificador virtual. Los descriptores de acceso de propiedades, así como los métodos, se pueden reemplazar de manera muy similar.

Métodos virtuales

Un método que será reemplazado en una clase derivada se declara con el modificador virtual. En una clase derivada, el método reemplazado se declara con el modificador override.

El modificador override denota un método o propiedad de una clase derivada que reemplaza un método o propiedad con el mismo nombre y firma en la clase base. El método base, que será reemplazado, se debe declarar como virtual, abstract u override: no es posible reemplazar un método no virtual o estático de esta forma. El método o la propiedad reemplazados y aquellos que se reemplazan deben tener los mismos modificadores de nivel de acceso.

El ejemplo siguiente muestra un método virtual denominado StepUp que es reemplazado en una clase derivada con el modificador que lo reemplaza:

public class CountClass 
{
    public int count; 

    public CountClass(int startValue)  // constructor
    {
        count = startValue;
    }

    public virtual int StepUp()
    {
        return ++count;
    }
}

class Count100Class : CountClass 
{
    public Count100Class(int x) : base(x)  // constructor 
    {
    }

    public override int StepUp()
    {
        return ((base.count) + 100);
    }
}

class TestCounters
{
    static void Main()
    {
        CountClass counter1 = new CountClass(1);
        CountClass counter100 = new Count100Class(1);

        System.Console.WriteLine("Count in base class = {0}", counter1.StepUp());
        System.Console.WriteLine("Count in derived class = {0}", counter100.StepUp());
    } 
}

Cuando se ejecuta este código, se observa que el constructor de la clase derivada utiliza el cuerpo del método proporcionado en la clase base, lo que permite inicializar el recuento de miembros sin duplicar el código. Éste es el resultado:

Count in base class = 2

Count in derived class = 101

Clases abstractas

Una clase abstracta declara uno o más métodos o propiedades como abstractos. La clase que declara dichos métodos no les proporciona una implementación, aunque una clase abstracta también puede contener métodos no abstractos, es decir, métodos para los que se ha proporcionado una implementación. No se puede crear directamente una instancia de una clase abstracta; sólo se puede crear una instancia de una clase derivada. Estas clases derivadas deben proporcionar implementaciones para todos los métodos y propiedades abstractos, mediante la palabra clave override, a menos que el miembro derivado se declare abstracto.

El ejemplo siguiente declara una clase abstracta Employee. También se crea una clase derivada denominada Manager, que proporciona una implementación del método abstracto Show() definido en la clase Employee:

public abstract class Employee 
{ 
    protected string name;

    public Employee(string name)  // constructor
    { 
        this.name = name;
    }

    public abstract void Show();  // abstract show method
}

public class Manager: Employee
{ 
    public Manager(string name) : base(name) {}  // constructor

    public override void Show()  //override the abstract show method
    {
        System.Console.WriteLine("Name : " + name);
    }
}

class TestEmployeeAndManager
{ 
    static void Main()
    { 
        // Create an instance of Manager and assign it to a Manager reference:
        Manager m1 = new Manager("H. Ackerman");
        m1.Show();

        // Create an instance of Manager and assign it to an Employee reference:
        Employee ee1 = new Manager("M. Knott");
        ee1.Show();  //call the show method of the Manager class
    } 
}

Este código invoca la implementación del método Show() proporcionado por la clase Manager e imprime el nombre del empleado en pantalla. Éste es el resultado:

Name : H. Ackerman

Name : M. Knott

Interfaces

Una interfaz es un tipo de clase esqueleto que contiene firmas de método pero no incluye ninguna implementación de método. De esta manera, las interfaces son como clases abstractas que contienen sólo métodos abstractos. Las interfaces de C# son muy similares a las de Java y funcionan de manera muy similar.

Todos los miembros de una interfaz son públicos por definición y una interfaz no puede contener constantes, campos (miembros de datos privados), constructores, destructores ni ningún tipo de miembro estático. El compilador generará un error si se especifica un modificador para los miembros de una interfaz.

Las clases se pueden derivar de una interfaz para implementar esa interfaz. Estas clases derivadas deben proporcionar implementaciones para todos los métodos de la interfaz, a menos que la clase derivada se declare abstracta.

Una interfaz se declara de forma idéntica en Java. En una definición de interfaz, una propiedad indica sólo su tipo y si es de sólo lectura, sólo escritura o de lectura y escritura únicamente por medio de las palabras clave get y set. La interfaz siguiente declara una propiedad de sólo lectura:

public interface ICDPlayer
{ 
    void Play();  // method signature
    void Stop();  // method signature

    int FastForward(float numberOfSeconds);

    int CurrentTrack  // read-only property
    {
        get;
    } 
}

Una clase se puede heredar de esta interfaz utilizando dos puntos, en lugar de la palabra clave implements de Java. La clase que se implementa debe proporcionar definiciones para todos los métodos y cualquier descriptor de acceso de la propiedad necesario, del siguiente modo:

public class CDPlayer : ICDPlayer
{
    private int currentTrack = 0;

    // implement methods defined in the interface
    public void Play()
    {
        // code to start CD...
    }

    public void Stop()
    {
        // code to stop CD...
    }

    public int FastForward(float numberOfSeconds)
    {
        // code to fast forward CD using numberOfSeconds...

        return 0;  //return success code
    }

    public int CurrentTrack  // read-only property
    { 
        get 
        { 
            return currentTrack; 
        } 
    }

    // Add additional methods if required...
}

Implementar múltiples interfaces

Una clase puede implementar múltiples interfaces mediante la sintaxis siguiente:

public class CDAndDVDComboPlayer : ICDPlayer, IDVDPlayer

Si una clase implementa más de una interfaz donde hay ambigüedad en los nombres de los miembros, se resuelve utilizando el calificador completo del nombre de la propiedad o método. Es decir, la clase derivada puede resolver el conflicto si se utiliza el nombre completo del método para indicar a qué interfaz pertenece, como en ICDPlayer.Play().

Fuente:
https://msdn.microsoft.com/es-bo/library/ms228360(v=vs.90).aspx
https://msdn.microsoft.com/es-bo/library/yz2be5wk(v=vs.90).aspx
https://msdn.microsoft.com/es-bo/library/ms228387(v=vs.90).aspx

Convierte tus imagenes y texto en ascii

2016-02-16T16:45:00.001-04:00

Picascii es una herramienta online que te permite convertir cualquier imagen en una pequeña obra maestra del arte ASCII, ese en el que una imagen es recreada usando únicamente texto para crear un efecto que no siempre será acertado aunque si curioso.
En el caso concreto de Picascii puedes elegir el tamaño de los caracteres -influye directamente en el tamaño de la imagen generada, si quieres que se conserven los colores de la imagen original y el origen de esta -un enlace web o un archivo de tu equipo, siempre con un tamaño no mayor a 1MB. Con estos parámetros definidos, lo único que tienes que hacer es pulsar el botón ‘Generate’ (generar) y esperar un poco.
Cuando termine el proceso de conversión, el resultado es tu pieza de arte ASCII mostrada en la parte superior de la página y un enlace para ver el código HTML o el texto con el que conseguir ese resultado. En el caso del código HTML se verán recreados los colores de la imagen original siempre que así lo hayas seleccionado.

Fuente:
http://picascii.com/

Interesante sitio para la generación de ASCII ART. Ojo: solo texto

Fuente:

http://patorjk.com/software/taag/#p=testall&f=Big%20Money-ne&t=Christian%20Marbel%20Vega%20Mamani

Mockaroo, generador de datos realista

2016-02-16T15:08:00.002-04:00

Si estás probando una aplicación lo normal es que quieras probarla usando las condiciones más realistas posibles, y usando los datos más reales que puedas. En una aplicación que ya está en producción son los propios usuarios los que llenan la base de datos de información, pero mientras estás desarrollando no tienes nada de esto, y debes inventarte los datos tú mismo. Si introduces esos datos a mano, uno por uno, no vas a ir muy lejos.

Si los generas de manera aleatoria es fácil para campos numéricos, pero muy complicado para otro tipo de datos, como nombres, direcciones o incluso tarjetas de crédito. Además a veces es importante generar los datos de manera realista, y no solo "que funcionen". Por ejemplo, para hacer una demo a clientes o crear documentación.

Existen muchas aplicaciones on-line para generar información aleatoria, pero pocas tan completas como esta que acabamos de descubrir hace poco: Mockaroo.

La verdad es que la cantidad de opciones que ofrece es impresionante y podemos crear todo tipo de datos, incluso con reglas propias.

El proceso es sencillo ya que solo tenemos que ir añadiendo nombres de campos y escoger su tipo. Por defecto nos ofrece 93 tipos de dato diferentes que van desde nombre y apellidos (pudiendo escoger estilo, género, etc...) hasta ISBNs, ubicaciones geográficas o datos encriptados simulados.

Además es posible hacer que los datos sigan una distribución Normal o de Poisson, secuencias, que cumplan una expresión regular o incluso que fuercen cadenas complicadas con caracteres extraños y cosas así. Si no nos sirve ninguno de los campos por defecto tenemos la posibilidad de crear fórmulas propias para generarlos, teniendo en cuenta otros campos, condicionales, etc... Es altamente flexible.

Los datos generados se exportan a CSV, JSON, Excel o incluso directamente a sentencias de inserción SQL estándar.

La herramienta es gratuita para generar datos de 1.000 en 1.000. Si queremos generar más datos de golpe y más rápido hay una opción de pago que, por 50 dólares al año, nos permite generar 100.000 registros de golpe 8 veces más rápido que la velocidad normal.

Es una herramienta muy a tener en cuenta.

fuentes:
http://stats2.mailcast.es/client/previewissue.asp?IssueId=31114
https://www.mockaroo.com/

5 cuestiones sobre seguridad que siempre deberías tener en cuenta

2016-02-16T12:31:00.001-04:00

Cada vez dependemos más del software. Está en todas partes, y no solo dentro de nuestras pantallas. Algunos fallos pueden ser catastróficos, y especialmente todos los que tienen que ver con la seguridad y la privacidad, que van siempre muy relacionadas. A pesar de ello sigue siendo muy frecuente que los programadores no tengan la seguridad presente todo el tiempo mientras desarrollan.

En ocasiones la actitud de los programadores hacia la seguridad es que ésta es cosas de la gente de sistemas, con sus cortafuegos, IDS y demás medidas de control. Sin embargo la mayor parte de las vulnerabilidades de seguridad tienen que ver con el código y cómo está escrito. Es indispensable hacerse a la idea de que la seguridad debe tenerse en cuenta en todas las fases de desarrollo de un proyecto de software, y no ser un pensamiento posterior, cuando ya lo principal está desarrollado.

Por eso hemos recopilado los 5 principales consejos sobre seguridad que deberías tener en mente siempre mientras programas, y que te ayudarán a conseguir sistemas más confiables y seguros:

Jamás te fíes de ningún dato. Este parece obvio, pero luego no siempre se tiene en cuenta. Cualquier dato que llegue a tu código desde un sistema del que tú no tienes control debe ser considerado sospechoso por defecto. No llega con validar en el lado cliente los datos que introducen los usuarios, siempre debe validarse en el servidor también. Si recibes una cadena de texto ten en cuenta todas las posibilidades, incluyendo símbolos "raros", la longitud máxima que esperas (no se vaya a producir un desbordamiento), que estén intentando colarla a la base de datos para inyectar instrucciones SQL. Verifica todos los datos siempre. Punto. Es un fastidio pero es la regla número 1 de cualquier sistema seguro.
Almacena exclusivamente lo que necesites. Ni un byte más de lo necesario. Cuando almacenas información que no necesitas estás ampliando la superficie de ataque posible. No solo nos referimos a almacenar esos datos en una base de datos o en un almacenamiento permanente (que también), sino incluso en memoria. Por ejemplo, un caso muy habitual es almacenar las contraseñas de los usuarios en claro en la base de datos. Esto aparte de ser un agujero de seguridad clarísimo es ilegal (al menos en Europa debido a las leyes de protección de datos). Almacena solamente un resumen digital de las claves y que ni siquiera vosotros conozcáis esas claves ni podáis recuperarlas.
No reinventes la rueda. Y lo anterior nos lleva a otro fallo muy común que es de "No inventado aquí". Hay programadores (y empresas) a los que no les gusta que haya código ajeno en sus desarrollos, y al final acaban por hacer por su cuenta cosas que están solucionadas hace tiempo. Aparte de ser un error empresarial es un error importante cuando se trata de esquemas que tienen que ver con la seguridad. La encriptación, los resúmenes digitales, etc... están basados en matemáticas complejas, se producen avances constantemente... y tenemos la suerte de vivir en la era del Open Source, así que -especialmente en seguridad- haz uso de alguna de las maravillosas bibliotecas existentes y probadas. Incluso aunque se descubra algún fallo en algún momento van a funcionar mejor que cualquiera que puedas hacer tú.
Limita los privilegios: lo más fácil, por ejemplo, es crear un usuario con acceso como administrador a la base de datos y utilizarlo desde nuestro código. Así nos evitamos errores por falta de permisos o el tener que hacer un ajuste fino tabla por tabla, campo por campo, para fijar los privilegios exactos que ese usuario necesita. El problema es que cuando se produce un problema de seguridad, nuestra aplicación actúa de intermediaria entre el atacante y la base de datos, dejándole las puertas abiertas de par en par. Grave error. Pues lo mismo en cualquier otro ámbito de la aplicación: hay que dar a cada usuario o proceso los privilegios exactos que necesite, y ni uno más. Es más trabajoso pero hará tus aplicaciones mucho más seguras.
La seguridad es una carretera de dos sentidos. Esto es algo que se piensa mucho menos todavía que lo anterior. Cuando un usuario "normal" se conecta a nuestra aplicación de banca, por poner un caso extremo, no solo debemos asegurarnos de que es quien dice ser, sino que es igualmente importante que esa persona tenga claro que nosotros somos quiénes decimos ser. Un certificado digital asegura eso, pero la mayor parte de los usuarios no se fijan en estas cosas y si un malhechor los lleva a un sitio que suplanta el nuestro y que no usa SSL, el 90% jamás se percatarán. Algunas empresas lo que hacen es permitir a los usuarios la personalización de sus accesos, de modo que una vez que están dentro del sistema se les muestra junto a la aplicación una foto o una frase que ellos mismos han elegido. Un sitio de phishing no puede tener esa información por lo que si no aparece enseguida se dan cuenta de que no están en donde debieran. Este tipo de cuestiones es importante tenerlas en cuenta también al desarrollar.

fuente:
http://stats2.mailcast.es/client/previewissue.asp?IssueId=31114

Symfony REST Edition

2015-08-18T12:21:00.001-04:00

Probando servicios REST con symfony

descargar el paquete

https://github.com/gimler/symfony-rest-edition

descomprimirlo en la ruta de nuestro apache para la publiacion web

/var/www/html

Se denominara a la carpeta descomprimida “rest”

/var/www/html/rest

Se procede a descargar los vendors necesarios con la instrucción:

php composer.phar install

Se verifica la funcionalidad del paquete y si las dependencias fueron resueltas con la instrucción:

php app/check.php

Tras validar eso en mi caso tenia una observacion en el php ini por no tener configurado el time zone, por tanto en caso de tener el mismo error ingresar al archivo y modificar el timezone como sigue(en mi caso Bolivia):

time.zone= “America/Caracas”

para dicha configuración pueden guiarse en:

http://php.net/manual/pt_BR/timezones.php

una vez verificado que todo las validaiones resultaron satisfatorias del diagnostico

php
app/check.php

Se
procede a probar la aplicación ingresando en el siguiente URL:

http://localhost/rest/web/config.php

Error 500 driver could not be found

2015-08-12T18:10:00.001-04:00

El error se produjo mientras desarrollaba con php 5.6,postgresql version 9.4 y doctrine2
la solucion es basicamente instalar el controlador con la siguiente instrucción:

pt-get install php5-pgsql

Saludos

Mapeo de tipos de datos de las BD con DOCTRINE

2015-07-28T18:32:00.000-04:00

A fin de realizar el mapeo de la base de datos a los objetos PHP se facilita la siguiente tabla que nos orientará sobre su implementación.

Doctrine	PHP	Database vendor
Doctrine	PHP	Name	Version	Type
smallint	`integer`	MySQL	all	`SMALLINT` `UNSIGNED` [10] `AUTO_INCREMENT` [11]
		Drizzle	all	`INT` `UNSIGNED` [10] `AUTO_INCREMENT` [11]
		PostgreSQL	all	`SMALLINT`
		Oracle	all	`NUMBER(5)`
		SQL Server	all	`SMALLINT` `IDENTITY` [11]
		SQL Anywhere	all	`UNSIGNED` [10] `SMALLINT` `IDENTITY` [11]
		SQLite	all	`INTEGER` [16]
integer	`integer`	MySQL	all	`INT` `UNSIGNED` [10] `AUTO_INCREMENT` [11]
		Drizzle	all	`INT` `UNSIGNED` [10] `AUTO_INCREMENT` [11]
		PostgreSQL	all	`INT` [12]
		PostgreSQL	all	`SERIAL` [11]
		Oracle	all	`NUMBER(10)`
		SQL Server	all	`INT` `IDENTITY` [11]
		SQL Anywhere	all	`UNSIGNED` [10] `INT` `IDENTITY` [11]
		SQLite	all	`INTEGER` [16]
bigint	`string` [8]	MySQL	all	`BIGINT` `UNSIGNED` [10] `AUTO_INCREMENT` [11]
		Drizzle	all	`BIGINT` `UNSIGNED` [10] `AUTO_INCREMENT` [11]
		PostgreSQL	all	`BIGINT` [12]
		PostgreSQL	all	`BIGSERIAL` [11]
		Oracle	all	`NUMBER(20)`
		SQL Server	all	`BIGINT` `IDENTITY` [11]
		SQL Anywhere	all	`UNSIGNED` [10] `BIGINT` `IDENTITY` [11]
		SQLite	all	`INTEGER` [16]
decimal [7]	`string` [9]	MySQL	all	`NUMERIC(p, s)` `UNSIGNED` [10]
		PostgreSQL	all	`NUMERIC(p, s)`
		Oracle
		SQL Server
		SQL Anywhere
		SQLite
		Drizzle
float	`float`	MySQL	all	`DOUBLE PRECISION` `UNSIGNED` [10]
		PostgreSQL	all	`DOUBLE PRECISION`
		Oracle
		SQL Server
		SQL Anywhere
		SQLite
		Drizzle
string [2] [5]	`string`	MySQL	all	`VARCHAR(n)` [3]
		PostgreSQL		`VARCHAR(n)` [3]
		SQL Anywhere		`CHAR(n)` [4]
		SQLite		`CHAR(n)` [4]
		Drizzle	all	`VARCHAR(n)`
		Oracle	all	`VARCHAR2(n)` [3]
		Oracle	all	`CHAR(n)` [4]
		SQL Server	all	`NVARCHAR(n)` [3]
		SQL Server	all	`NCHAR(n)` [4]
text	`string`	MySQL	all	`TINYTEXT` [17]
				`TEXT` [18]
				`MEDIUMTEXT` [19]
				`LONGTEXT` [20]
		PostgreSQL	all	`TEXT`
		SQL Anywhere
		Drizzle
		Oracle	all	`CLOB`
		SQLite	all	`CLOB`
		SQL Server	all	`VARCHAR(MAX)`
guid	`string`	MySQL	all	`VARCHAR(255)` [1]
		Oracle
		SQLite
		Drizzle
		SQL Server	all	`UNIQUEIDENTIFIER`
		SQL Anywhere	all	`UNIQUEIDENTIFIER`
		PostgreSQL	all	`UUID`
binary [2] [6]	`resource`	MySQL	all	`VARBINARY(n)` [3]
		SQL Server		`VARBINARY(n)` [3]
		SQL Server		`BINARY(n)` [4]
		SQL Anywhere		`BINARY(n)` [4]
		Drizzle	all	`VARBINARY(n)`
		Oracle	all	`RAW(n)`
		PostgreSQL	all	`BYTEA` [16]
		SQLite	all	`BLOB` [16]
blob	`resource`	MySQL	all	`TINYBLOB` [17]
				`BLOB` [18]
				`MEDIUMBLOB` [19]
				`LONGBLOB` [20]
		Oracle	all	`BLOB`
		SQLite
		Drizzle
		SQL Server	all	`VARBINARY(MAX)`
		SQL Anywhere	all	`LONG BINARY`
		PostgreSQL	all	`BYTEA`
boolean	`boolean`	MySQL	all	`TINYINT(1)`
		PostgreSQL	all	`BOOLEAN`
		SQLite
		Drizzle
		SQL Server	all	`BIT`
		SQL Anywhere	all	`BIT`
		Oracle	all	`NUMBER(1)`
date	`\DateTime`	MySQL	all	`DATE`
		PostgreSQL
		Oracle
		SQL Anywhere
		SQLite
		Drizzle
		SQL Server	>= 2008
		SQL Server	< 2008	`DATETIME` [16]
datetime	`\DateTime`	MySQL	all	`DATETIME` [13]
		Drizzle	all	`TIMESTAMP` [14]
		SQL Server	all	`DATETIME`
		SQL Anywhere
		SQLite
		PostgreSQL	all	`TIMESTAMP(0) WITHOUT TIME ZONE`
		Oracle	all	`TIMESTAMP(0)`
datetimetz	`\DateTime`	MySQL	all	`DATETIME` [15] [16]
		Drizzle
		SQLite
		SQL Server	< 2008
		SQL Server	>= 2008	`DATETIMEOFFSET(6)`
		PostgreSQL	all	`TIMESTAMP(0) WITH TIME ZONE`
		Oracle	all	`TIMESTAMP(0) WITH TIME ZONE`
		SQL Anywhere	< 12	`DATETIME` [15] [16]
		SQL Anywhere	>= 12	`TIMESTAMP WITH TIME ZONE`
time	`\DateTime`	MySQL	all	`TIME`
		SQL Anywhere
		SQLite
		Drizzle
		PostgreSQL	all	`TIME(0) WITHOUT TIME ZONE`
		Oracle	all	`DATE` [16]
		SQL Server	< 2008	`DATETIME` [16]
		SQL Server	>= 2008	`TIME(0)`
array [1]	`array`	MySQL	all	`TINYTEXT` [17]
simple array [1]				`TEXT` [18]
				`MEDIUMTEXT` [19]
				`LONGTEXT` [20]
		PostgreSQL	all	`TEXT`
		SQL Anywhere
		Drizzle
		Oracle	all	`CLOB`
		SQLite	all	`CLOB`
		SQL Server	all	`VARCHAR(MAX)`
json_array	`array`	MySQL [1]	all	`TINYTEXT` [17]
				`TEXT` [18]
				`MEDIUMTEXT` [19]
				`LONGTEXT` [20]
		PostgreSQL	>= 9.2	`JSON`
		PostgreSQL	< 9.2	`TEXT` [1]
		SQL Anywhere	all
		Drizzle	all
		Oracle	all	`CLOB` [1]
		SQLite	all	`CLOB` [1]
		SQL Server	all	`VARCHAR(MAX)` [1]
object [1]	`object`	MySQL	all	`TINYTEXT` [17]
				`TEXT` [18]
				`MEDIUMTEXT` [19]
				`LONGTEXT` [20]
		PostgreSQL	all	`TEXT`
		SQL Anywhere
		Drizzle
		Oracle	all	`CLOB`
		SQLite	all	`CLOB`
		SQL Server	all	`VARCHAR(MAX)`

fuente:
http://doctrine-dbal.readthedocs.org/en/latest/reference/types.html

Conectando el cliente al servidor GIT

2015-07-23T19:03:00.000-04:00

WINDOWS

Primero se realiza el mapeado de la carpeta creada en el servidor GIT en la ruta donde realizaremos el desarrollo en este caso en nuestro servidor WAMP:

Realizamos el comando $git clone git@DIRECCION_IP_SERVIDOR_GIT :/RUTA_PUBLICACION_ARCHIVO.git

Introducir el password

Con ello la carpeta se creara y se mapeara desde el servidor, dicha carpeta será nuestra área de trabajo donde iremos trabajando y subiendo nuestras versiones del código.

LINUX

Nos dirigimos a nuestra ruta donde queremos realizar el mapedo e introducimos la siguiente línea en la consola:

/home/Christian/documentos$git clone git@DIRECCION_IP_SERVIDOR_GIT :/RUTA_PUBLICACION_ARCHIVO.git

Con ello la carpeta se creara y se mapeara desde el servidor, dicha carpeta será nuestra área de trabajo donde iremos trabajando y subiendo nuestras versiones del código.

COMANDOS PARA REALIZAR UN CARGADO AL AREA DE TRABAJO

Para verificar el estado de nuestro codigo en cotraposicion con el codigo alojado en el servidor GIT:

#git status

WINDOWS-LINUX

Para agregar los cambios realizados en la carpeta

#git add .

Para agregar un archivo en especifico

#git add archivo_nuevo.css

Para realizar el commit inicial ingresando un comentario descriptivo:

#git commit -m "primer commit :)"

Para realizar un GLV(get last version-obtener la ultima version de código del servidor)

#git pull origin master

Para realizar el check in(subida del código) al repositorio GIT

#git push origin master

PAra realizar la verificación que el código se subió correctamente:

#git status

Para ver el histórico de las subidas y comentarios al servidor:

#git log

Conexion BD postgresql-symfony2

2015-07-23T16:46:00.001-04:00

Para la conexión de la base de datos postgresql con el framework symfony2 se deben seguir los siguientes pasos, en función al entorno en que se esta desarrollando.

WINDOWS

Dirigirse a al ruta

C:\wamp\bin\php\php5.5.12

Y descomentar las líneas

extension=php_pgsql.dll

extension=php_pdo_pgsql.dll

LINUX

Realizar la instalación del complemento:

apt-get install php5-pgsql

Reiniciar el sevicio apache

/home/christian#sudo /etc/init.d/apache2 restart

WINDOWS-LINUX

y luego realizar la configuración en los archivos del symfony

Diccionario de prefijos de lineas ENTEL,VIVA Y TIGO

2015-07-23T09:07:00.004-04:00

Como se si un celular de Bolivia es Viva Entel o Tigo?

Aquí le presentamos los prefijos de los celulares Viva Tigo Entel de Bolivia clasificados por empresas y los prefijos con los cuales inician los números de celulares indistinto al departamento que corresponda.

Configuración de proxy en CentOS a nivel consola

2015-07-14T19:41:00.000-04:00

Se ingresa a la siguiente ruta

[root@client ~]# vi /etc/profile
#Adicionar el siguiente código en el archivo de configuración
PROXY_URL="http://10.10.2.3:3128/"
HTTP_PROXY=$PROXY_URL
HTTPS_PROXY=$PROXY_URL
FTP_PROXY=$PROXY_URL
http_proxy=$PROXY_URL
https_proxy=$PROXY_URL
ftp_proxy=$PROXY_URL

#Comando que aplica las configuraciones definidas
export HTTP_PROXY HTTPS_PROXY FTP_PROXY http_proxy https_proxy ftp_proxy

A veces no es suficiente con esa configuración y se debe realizar la definición de la utilización del proxy para cada aplicación instalada y que requiera una conexión a internet para alguna acción.

# Para yum
[root@client ~]# vi /etc/yum.conf
# Se adiciona el siguiente codigo al final de la liena de configuración
proxy=http://prox.server.world:8080/

# Para wget
[root@client ~]# vi /etc/wgetrc
# Se adiciona el siguiente codigo al final de la liena de configuración
http_proxy = http://prox.server.world:8080/
https_proxy = http://prox.server.world:8080/
ftp_proxy = http://prox.server.world:8080/

Fuente: http://www.server-world.info/en/note?os=CentOS_7&p=squid&f=2

Tarea Semana 4

2013-07-15T18:34:00.000-04:00

Para la siguiente actividad tienen que elaborar una pagina con una aspecto similar a este:

Como ven, consta de una pagina maestra que contiene 4 paginas (Products,Downloads,Support,Shop), estas deben visualizarse dentro del contenedor(area de trabajo). asimismo la pagina maestra contiene una animación como en la figura que va variando cada cierto tiempo. La animación la pueden realizar en Flash o en Silverlight.
pueden ver el ejemplo aqui
La entrega del trabajo es el sábado 20 de Julio en aula.

"String or binary data would be truncated. The statement has been terminated."

2013-07-10T12:08:00.004-04:00

Existen 3 posibles acciones para solucionar este problema:

El tipo de dato que se quiere ingresar :

-No es el mismo que el definido en la Base de Datos por ejemplo ingresar "6955500LP" en ci int
-Es mas grande que el que quiere ingresar por ejemplo: ingresar "christian" en nombre varchar(5)

El punto de interrupción no se activara actualmente.el código fuente es distinto al de la versión original. ( VS2012 )

2013-07-10T11:43:00.002-04:00

Este problema generalmente aparece cuando el ejecutable o compilado de tu solucion no es el mismo con el que acabas de editar y guardar, para solucionarlo es necesario:

Limpiar la solución como se ve en la figura:

Limpiar el proyecto:

Luego ejecutar y funcionaran sin problemas los breakpoints:

Tarea semana 3

2013-07-08T12:56:00.001-04:00

Deben realizar un sistema web en aspx que tenga el aspecto de una calculadora que tenga el siguiente aspecto:

Numeros y Comandos son botones, el display donde se muestran las operaciones es un textbox. La fecha de entrega es el dia 14 de Julio en clase.
Pueden ver un modelo en: http://calculadora.us/

Hacking To The Gate

2012-08-23T14:15:00.001-04:00

Hacking To The Gate
Steins;Gate

Suujuuoku mono kodou no kazu sae
Anata ni wa matataki teido no saji na toukyuu
Kako ni torawarete mirai wo nageku mo
Chiri hitotsu gosan wo yurusanu hitsuzen
"mugen" ni hirogaru yume mo egaku mirai mo
Bokutachi ni yurusareta kyoei no genri
"yuugen" sore wa futatsu no hari ga shimesu
Zankoku na yakujou to sentaku e hacking to the gate---
Dakara ima ichibyou goto ni sekaisen wo koete
Kimi no sono egao mamoritai no sa
Soshite mata kanashimi no nai jikan no ruupu e to
Nomikomarete yuku kodoku no kansokusha
Inochi no shuchou to muimi no shoumei
Anata ni wa taikutsu shinogi ni taranu kokkei
Shihaisha kidori no oroka na shuzoku wa
Unuboreta chisetsu na teiri wo narabeta
"mugen" to shinjita ai mo sora no kanata mo
Bokutachi ni shimesareta kasou no jiyuu
"yuugen" sore wa mujihi ni toki wo kizami
Asu sae mo hitei suru sentaku e hacking to the gate---
Ikutsu mono kagayakeru hibi nakama to no yakusoku
Nakatta koto ni wa shite wa ikenai
Sono tame ni toki wo azamuku nokosareta shikake ni
Mou mayoi wa nai kodoku no kansokusha
Dakara ima ichibyou goto ni sekaisen wo koete
Kimi no sono egao mamoritai no sa
Soshite mata kanashimi no nai jikan no ruupu e to
Nomikomarete yuku kodoku no kansokusha

Como hacer un ensayo

2012-08-07T00:07:00.001-04:00

Que es un ensayo?
Consiste en poner por escrito una opinion.
Caracteristicas del ensayo:
-tono formal
-tener en cuenta:contenido relevante,argumento apropiado,ortografia

Pasos para elaborar un ensayo:
1. Hacer una lista de ideas
2. ordenar la lista
3. hacer un borrador
4. perfeccionarlo

Como escribir un ensayo
-presentar argumentos
desarrollar cada argumento y refutar el contraargumento

Estructura
Inicio->generar ideas sobre una pregunta concreta, organizarlo.Se pueden aplicar:sorpresa,confirmacion(se basa en la informacion que el lector ya conoce),contradiccion(empieza con algo aceptado pr la mayoria y demuestra que es erronea y la corrige),suspenso(se presentan los datos poco a poco dejand abierta la pregunta clave.
OJO:el inicio se escribe al final cuando ya se tiene una idea clara de todo el trabajo.

Desarrollo->contiene el desarrollo de los aspectos presentados en la introduccion.Por lo general, cada aspecto mencionado ocupara un parrafo del ensayo.Se pueden empearlas siguiente estrategias de organizacion para presentar el ensayo:Analisis(descripcion de componentes),Comparacion y contraste(senalar semejanzas y diferencias ente 2 o mas conjuntos o entidades),definicion(aclaracion de terminos o conceptos que el lector puede desconocer),Clasificacion(se parece al analisis, pero se pregunta por las diferentes clases de la entidad
OJO:se debe convencer no con la evidencia sino con la emotividad, es recomendable utilzar imagenes, metaforas y otras figuras retoricas.

Conclusion->se debe recoger o recapitular las ideas presentadas.Se comienza con un breve resumen del ensayo y se termina con una frase bien pensada que llame la atencion del lector sobre el punto clave del articulo.

Despues de escribir->
Primera revision:observar el contenido y la organizacion del ensayo, para ver si comunica su proposito al lector.
Segunda revision:aspectos gramaticales, es decir signos de puntuacion, la concordancia de genero y numero.
Le recomiendo que anote los problemas gramaticales que tuvo en este ensayo y que los
compare con los del ensayo anterior. Quizás sería de utilidad hacerse una lista de sus 6
errores comunes para revisarlos antes de entregar la siguiente tarea. Le ayudará a mejorar
en tareas siguientes.

Consejos:
Escriba mucho.Escriba frecuentemente para si mismo:anote momentos clave de su vida en un diario o escriba sobre asuntos importantes aunque no vaya a compartirlos con nadie.