En los últimos años parece que las metodologías ágiles convencen más a los desarrolladores que las complejas metodologías pesadas. Entre todas ellas, la eXtremme Programming es la que se lleva la palma, y una de las tareas más importantes dentro de la metodología XP son las pruebas unitarias y el TDD (Test Driven Development)

Este artículo trata en profundidad el tema de las pruebas unitarias, qué son, por qué debemos hacerlas, cómo se hacen, qué es el TDD... además de ejemplos detallados. El artículo viene acompañado de una versión para C++Builder 6 de CPPUnit, y se explica cómo usarla y sus peculiaridades (que alguna que otra tiene).

El primer artículo sobre la memoria en Win32 que trata sobre cómo se utiliza desde nuestros progrmas y la implementación que hace la plataforma Win32 de la memoria virtual.
Recomendado para programadores avanzados que quieren saber cómo funciona Windows por dentro.

En esta ocasión profundizamos en la implementación que hace Win32 de la pila. Todos la hemos utilizado, todos sabemos qué es una pila, pero no sabemos cómo se las arregla Win32 para manejar esta importante estructura de memoria. También se da una explicación de una técnica de hacking llamada buffer overflow que permite a los piratas ejecutar código maligno en un programa.

Artículo que profundiza en el gestor de montones (o montículos) dentro de Win32, así como su uso y su implementación interna. Se comienza explicando qué es un montón (en inglés heap) para pasar a explicar cómo usarlo correctamente para la creación de memoria dinámica y cómo se las arregla Windows para hacer una implementación eficiente.

El último artículo que trata el tema de la memoria en la plataforma Win32. En esta ocasión hablo sobre los archivos proyectados, un elemento muy importante para entender la comunicación entre procesos, así como un nuevo método para las E/S de datos en disco.

Comienzo con un nuevo tema dentro dentro de la serie Los rincones del API Win32. A lo largo de los próximos artículos vamos a tratar la programación de accesos a recusos en internet, utilizando para ello el API de Microsoft Wininet. Espero que os resulte de interés.
En este primer artículo introductorio, damos una panorámica general de esta librería, y nos adentramos en las primeras funciones para manipulación de URLs, conexión vía módem, gestión de cookies, etc.

Entramos en temas interesantes: el acceso a recursos remotos a través del protocolo de aplicación HTTP y el API Wininet.
En este artículo explico un primer método de acceder a un archivo remoto, como un página HTML, una imágen, etc., y dejaremos los temas más avanzados (como ejecución asíncrona o envío de formularios) para el próximo artículo.

En el anterior artículo dejamos muchos temas en el tintero, así que voy a terminar lo que tengo pendiente explicando el método detallado y algunos consejos para acceder a direcciones protegidas y el envío de formularios a través de WinInet.
Además, explicamos cómo podemos hacer nuestro propio gestor de descargas, para permitir descargas segmentadas y reanudaciones del proceso de descarga, utilizando una característica de la versión 1.1 de HTTP: la cabecera "Range".

Ya he dicho todo lo que sé sobre HTTP, así que ahora me centro en otra historia: el protocolo FTP desde el API WinInet. Con este artículo aprenderás a hacer un pequeño cliente FTP, para la descarga y envío de archivos, consultar información, gestionar la estructura de directorios... todo esto ayudándonos del API WinInet.

Y para terminar con WinInet, damos una visión detallada de una de las características más interesantes de esta tecnología de Microsoft: el caché de Internet Explorer. Explicamos cómo utilizalo desde nuestros programas y cómo actualizar su contenido.

Una migración libre para el entorno Borland C++Builder 6 del famoso framework de pruebas CppUnit. Se han mantenido las clases principales, aplicando patrones adapter y wrapper para crear un entorno de ejecución basado en VCL.
La migración original es de Marco Dorantes, y posteriormente le he hecho algunos cambios yo mismo.

Un pequeño sistema de acceso al gestor de montones de Win32, pero implementado con un diseño orientado a objetos.
Este sistema define las clases CHeap, CHeapBlock, CHeapList y CHeapBlockList.
Se incluye también el proyecto de Visual C++ 6 para compilar estas clases dentro de las librerías Heap.dll y Heap.lib.
Para más detalles, se puede consultar la documentación dentro del código fuente.

Se trata de la implementación de una clase base (llamada CHeapObject) que hace que todos los objetos creados de esta clase se almacenarán en un montón dedicado a tal efecto, con lo cual se incrementará la velocidad y seguridad de acceso a estos objetos. Un buen caso de uso podría ser una lista muy numerosa de elementos, siendo cada uno de estos elementos un objeto heredado de CHeapObject.
Para más detalles, se puede consultar la documentación dentro del código fuente.
Se incluye también un programa de ejemplo escrito en C++Builder 6, que hace una demostración del uso de esta clase.

Se trata de una aplicación de ejemplo que demuestra cómo utilizar archivos proyectados en memoria para la comunicación entre procesos y subprocesos.
El ejemplo consiste en un proceso padre que contiene pequeño editor de texto, y una serie de subprocesos (programas hijos) que muestran el mismo texto que el programa padre. Para ello se utiliza la clase CProyeccion (definida en los archivos "proyeccion.h" y "proyeccion.cpp").

Es un proyecto completo que demuestra el uso de las funciones, que proporciona el API WinInet, para el marcado del módem y gestión de cookies.

Se trata de una pequeña aplicación que nos permite realizar una descarga utilizando el método directo, y además modificar las opciones de descarga a través de distintas banderas.
Podéis jugar con ella para ver cómo se comporta la función y ver los resultados obtenidos.

Se trata de un pequeño programa que demuestra el uso del método detallado de descarga, junto con un pool de conexiones.
Se denomina "pool" (que significa reserva, fondo común o algo así) a un objeto que nos permite reutilizar un elemento dado, almacenando una lista y utilizando los elementos almacenados en vez de crearlos nuevos cada vez que sean necesarios. En nuestro caso, el "pool de conexiones" se encarga de reutilizar las conexiones a internet, creando el descriptor la primera vez, y reutilizarlo cada vez que sea necesaria, sin tener que crear y destruír varias veces la misma conexión.

Una pequeña aplicación que demuestra cómo podemos hacer uso de la cabecera “Range” desde WinInet, para implementar una reanudación de descarga. Para conseguirlo, se almacena en un archivo los datos de las descargas que se han cancelado antes de su finalización, y después se reanuda la descarga en el punto en que fue cancelada.
Como curiosidad, también se demuestra cómo diseñar el sistema para hacerlo compatible con distintos entornos de programación. Para conseguirlo, se ha modelado en capas, tal y como podéis ver en este diagrama UML. Como veréis, se comparte el código compatible a través de una capa de lógica de la descarga y reanudación, que sólo utiliza funciones propias del API Win32 y WinInet (en rojo), mientras que el interfaz gráfico se implementa en distintas capas, dependiendo del entorno con que trabajemos: formularios VCL desde C++Builder (azul) y diálogos de MFC desde Visual C++ (amarillo). De este modo, separando el interfaz gráfico de la lógica, conseguimos reutilizar código compatible.