Mostrando entradas con la etiqueta DELPHI. Mostrar todas las entradas
Mostrando entradas con la etiqueta DELPHI. Mostrar todas las entradas

sábado, 10 de diciembre de 2016

Curso de Delphi - Capítulo 4. Condicionales


Por fín podemos continuar con el curso de Delphi sobre Lazarus.
En este cuarto episodio os vamos a explicar las sentencias condicionales que existen en Pascal y cómo utilizarlas.

En concreto veremos:

  • If... then
  • If... then begin end
  • If... then... else
  • If... then anidados
  • If con condiciones compuestas
  • Sentencia Case

Además como novedad en ese episodio os proponemos una serie de ejercicios para que practiquéis en casa y que veremos resueltos en próximos episodios.   

Esperando que sea de vuestro total agrado os dejamos con el vídeo.


Capítulos:
Compartir:

martes, 28 de junio de 2016

Truco Delphi - Enviar emails usando el servicio Gmail de Google

En el truco de hoy os voy a enseñar como podéis enviar correos electrónicos desde vuestra aplicación Delphi mediante vuestra cuenta Gmail.


Para ello vamos a hacer uso de los componentes Indy disponibles en cualquier versión de RAD Studio (en el truco se utiliza la versión XE8 pero está testeado en XE5 también).

Vamos a crearnos una función SendGMail con el siguiente código:
 
procedure SendGmail(pUsuario, pPassword, pAsunto, pCuerpo, pDestino : string);
var
  Smtp : TidSMTP;
  ManejadorSSL : TidSSLIOHandlerSocketOpenSSL;
  Mensaje: TIdMessage;
begin
  ManejadorSSL := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
  with ManejadorSSL do
  begin
   Destination := 'smtp.gmail.com:587';
   Host := 'smtp.gmail.com';
   MaxLineAction := maException;
   Port := 587;
   SSLOptions.Method := sslvTLSv1;
   SSLOptions.Mode := sslmUnassigned;
   SSLOptions.VerifyMode := [];
   SSlOptions.VerifyDepth := 0;
  end;

  Smtp := TIdSMTP.Create( nil );

  with Smtp do
  begin
    IoHandler := ManejadorSSL;
    Host := 'smtp.gmail.com';
    Port := 25;
    Username := pUsuario;
    Password := pPassword;
    UseTLS := utUseExplicitTLS;
  end;

  Mensaje := TIdMessage.Create(nil);
  with Mensaje do
  begin
    Clear;
    Subject := pAsunto;
    Body.Text := pCuerpo;
    Recipients.Add;
    Recipients.Items[0].Address := pDestino;
  end;

  Smtp.Connect;
  if smtp.Connected then
  begin
    smtp.Send(Mensaje);
    smtp.Disconnect;
  end;

  FreeAndNil(Smtp);
  FreeAndNil(Mensaje);
  FreeAndNil(ManejadorSSL);

end;


Y ya está, solamente tendremos que llamar a esta función con los parámetros relativos a nuestra cuenta para enviar nuestro correo.

En lugar de crear los objetos dinámicamente, podéis pegar objetos directamente desde la paleta de componentes en vuestro formulario y ahorraros el create; si lo hacéis dinámicamente no olvidéis incluir en el uses las referencias necesarias:

uses
  [...] IdMessage, IdIOHandler, IdIOHandlerSocket, IdIOHandlerStack,
  IdSSL, IdSSLOpenSSL, IdBaseComponent, IdComponent, IdTCPConnection,
  IdTCPClient, IdExplicitTLSClientServerBase, IdMessageClient, IdSMTPBase,
  IdSMTP,IdAttachmentFile,IdGlobal;

Observaréis que falta la opción de adjuntar algún archivo, pero eso lo vamos a dejar para futuros trucos.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter facebook.

Compartir:

jueves, 23 de junio de 2016

Truco Delphi - MessageBox organizados y personalizados.

Si eres, o has sido, programador Delphi, seguramente te has encontrado muchas aplicaciones donde se utiliza la función Showmessage, MessageBox o Messagedlg o incluso todas a la vez de manera desorganizada y no unificada.


En este truco/post os voy a mostrar como organizar vuestros mensajes de aplicación en una única unidad y como personalizarlos con vuestros propios iconos sin necesidad de crear formularios específicos para ellos.

Mi recomendación es que utilicéis siempre MessageBox, por dos motivos:
  1. MessageBox es una función de la Api de Windows, por tanto, los textos de los botones estarán localizados al idioma del sistema.
  2. Permite una mayor personalización y control de los mensajes mostrados.
En toda aplicación suelen utilizarse, al menos, tres tipos de mensajes de diálogo con el usuario; Mensajes de error, mensajes de aviso y mensajes de pregunta.

Mi recomendación es que os creéis una unidad donde agrupéis todos esos mensajes de manera que podáis utilizarlos en toda la aplicación, por ejemplo algo así:

  
unit UDialogos;

interface

uses Windows;

procedure MensajeError(owner: HWND; p_texto :string);
procedure MensajeAviso(owner: HWND; p_texto :string);
function Pregunta(owner: HWND; p_texto, p_titulo: string) : boolean;

implementation

procedure MensajeError(owner: HWND; p_texto :string);
begin
  MessageBox(owner, pchar(p_texto), 'Error',
               MB_ICONERROR or MB_OK or MB_TASKMODAL)
end;

procedure MensajeAviso(owner: HWND; p_texto :string);
begin
  MessageBox(owner, pchar(p_texto),'Aviso',
               MB_ICONINFORMATION or MB_OK or MB_TASKMODAL )
end;

function Pregunta(owner: HWND; p_texto, p_titulo: string) : boolean;
begin
  result := MessageBox(owner, pchar(p_texto), pchar(p_titulo),
               MB_ICONQUESTION or MB_YESNO or MB_TASKMODAL) = IDYES
end;

end.


De esta manera tendremos todos los mensajes localizados en una unidad de nuestra aplicación y a nuestra disposición para cuando los necesitemos.

Es importante utilizar correctamente el parámetro "owner" de esas funciones y pasárles siempre el "Handle" del formulario que llama a la función ("Self.Handle") para que los diálogos sepan delante de quién deben mostrarse.

Si no os gustan los iconos por defecto que muestra Windows, siempre podéis utilizar los vuestros utilizando "MB_USERICON", pero en este caso deberéis utilizar la función MessageBoxIndirect.

Supongamos que tenemos un icono en los recursos de nuestra aplicación llamado 'ICONICO' y que queremos mostrarlo en un mensaje de dialogo concreto, escribiríamos lo siguiente:

  
procedure MensajePersonalizado(owner: HWND; p_texto, p_titulo :string);
var
  flags : uint;
  MsgPars: TMsgBoxParams;
begin
  flags := MB_USERICON or MB_OK or MB_DEFBUTTON1 or MB_TASKMODAL;

  //Establecemos los parámetros
  with MsgPars do
  begin
    cbSize := SizeOf(MsgPars);
    hwndOwner := owner;
    hInstance := Sysinit.hInstance;
    lpszText := PChar(p_texto);
    lpszCaption := pchar(p_titulo );
    dwStyle := flags;
    lpszIcon := 'ICONICO'; //Nuestro icono en los recursos
    dwContextHelpId := 0;
    lpfnMsgBoxCallback := nil;
    dwLanguageId := LANG_NEUTRAL;
  end;

  MessageBoxIndirect(MsgPars);

end;



Una última consideración sobre utilizar MB_OKCANCEL o MB_YESNO. Cualquier flag que incluya OK y/o CANCEL responderá a las teclas "Intro" para el OK y "Escape" para el CANCEL, es decir, si utilizáis MB_YESNO, "intro" y "escape" no funcionarán, si utilizáis MB_OKCANCEL, si que lo harán.

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter facebook.
Compartir:

lunes, 20 de junio de 2016

Truco Delphi - Ocultar icono de nuestra aplicación en barra de tareas

Hoy toca un truco rápido, fácil y para toda la familia que consiste en ocultar el icono de nuestra aplicación de la barra de tareas en Delphi.

¿Para que sirve esto? Bueno, eso depende; imaginad que necesitáis hacer una aplicación iconizada en el área de notificaciones (Al lado del reloj) y que queréis que cuando se muestre no aparezca el icono en la barra de tareas (igual que el reloj de Windows por ejemplo).

Para ello solamente tendremos que anular la función CreateParams de la clase TForm para codificar nosotros mismos lo que necesitamos de la siguiente manera:
  
TfrmPrincipal = class(TForm)
  private
    { Private declarations }
  protected
    procedure CreateParams(var Params: TCreateParams); override;
  public
    { Public declarations }
  end;

procedure TfrmPrincipal.CreateParams(var Params: TCreateParams);
begin
  inherited;
  Params.ExStyle := Params.ExStyle and not WS_EX_APPWINDOW;
  Params.WndParent := Application.Handle;
end;

Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.
Compartir:

jueves, 16 de junio de 2016

Truco Delphi - Alternar colores de filas en DBGrid

Hoy os presento un pequeño truco que hará que vuestros DBGrids luzcan mucho mejor añadiendo unas pocas lineas de código.

Lo que tratamos de conseguir es que nuestro DBGrid presente las filas con colores alternos y además que la fila seleccionada se resalte también de manera alterna.


Para conseguir este objetivo debemos escribir la función GridDrawColumnCell como sigue:


procedure TfrmPrincipal.GridDrawColumnCell(Sender: TObject; const Rect: TRect;
  DataCol: Integer; Column: TColumn; State: TGridDrawState);
const
  RowColors: array[Boolean] of TColor = (clSilver, clWhite);
  RowSelectedColors: array[Boolean] of TColor = (clHotLight, clHighlight);
var
  OddRow: Boolean;
begin
  if (Sender is TDBGrid) then
  begin
    OddRow := Odd(TDBGrid(Sender).DataSource.DataSet.RecNo);
    if (gdSelected in State) then
      TDBGrid(Sender).Canvas.Brush.Color := RowSelectedColors[OddRow]
    else
      TDBGrid(Sender).Canvas.Brush.Color := RowColors[OddRow];
    TDBGrid(Sender).DefaultDrawColumnCell(Rect, DataCol, Column, State);
  end;
end;


Este procedimiento lo podemos poner en el formulario donde esté el DBGrid o bien en una unidad aparte y luego importarla con el comando Uses. Si incluimos el procedimiento en el formulario, es importante hacerlo como procedimiento de clase:

 TfrmPrincipal = class(TForm)

    { Otros métodos y propiedades del formulario }

    procedure GridDrawColumnCell(Sender: TObject; const Rect: TRect;
                                 DataCol: Integer; Column: TColumn; State: TGridDrawState);
  private
    { Private declarations }

  public
    { Public declarations }
  end;



De esta manera podremos seleccionar el DBGrid y asignar el procedimiento al evento OnDrawColumnCell.


Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.
Compartir:

miércoles, 15 de junio de 2016

Truco Delphi - Prevenir la ejecución de más de una instancia de nuestra aplicación (I)


Hace ya bastante tiempo que no posteo, pero eso no quiere decir que me haya olvidado de vosotros.
Como no dispongo de mucho tiempo para continuar con el curso de Lazarus y postear de forma asidua los artículos que tenía previstos, voy a empezar a postear pequeños tips y códigos de ejemplo para resolver pequeños problemas que me surgen en el día a día.

Hoy quiero mostraros como hacer que vuestra aplicación no se ejecute más de una vez, pero, en lugar de manteniendo la instancia más antigua, haciendo que la nueva instancia tome el control, es decir, que la nueva ejecución sustituya a la antigua.

Para ello nos vamos a basar en el procedimiento de WinApi GetCurrentProcessId, que nos dará el id de proceso del programa que estamos ejecutando y en el objeto TApplication para obtener el ExeName que será el que buscaremos.



Básicamente lo que pretendemos es terminar cualquier proceso que se llame como el nuestro, pero que no sea el nuestro :D


Añadimos el siguiente código en el evento OnCreate de nuestro formulario principal.

procedure TfrmPrincipal.FormCreate(Sender: TObject);
begin
  FProcessID := GetCurrentProcessId;
  FExeName   := ExtractFileName(Application.ExeName);
  
  CerrarInstancias;
end;

Este es el código que recorrerá todos los procesos de Windows y eliminará las instancias que existan de nuestra aplicación excepto la actual.

procedure TfrmPrincipal.CerrarInstancias;
const
  PROCESS_TERMINATE = $0001;
var
  ContinueLoop: BOOL;
  FSnapshotHandle: THandle;
  FProcessEntry32: TProcessEntry32;
begin
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  FProcessEntry32.dwSize := SizeOf(FProcessEntry32);
  ContinueLoop := Process32First(FSnapshotHandle, FProcessEntry32);


  while Integer(ContinueLoop) <> 0 do
  begin

      if ((UpperCase(ExtractFileName(FProcessEntry32.szExeFile)) =
          UpperCase(FExeName)) or
          (UpperCase(FProcessEntry32.szExeFile) =
          UpperCase(FExeName)))  and
         (FProcessEntry32.th32ProcessID <> FProcessID)
      then
      begin
        TerminateProcess(OpenProcess(PROCESS_TERMINATE,
                                    BOOL(0),
                                    FProcessEntry32.th32ProcessID),
                                    0);
      end;

       ContinueLoop := Process32Next(FSnapshotHandle, FProcessEntry32);
  end;
  CloseHandle(FSnapshotHandle);

end;

Mas adelante pondré otras maneras de prevenir la ejecución de más de una instancia de nuestras aplicaciones.
Compartir:

domingo, 3 de abril de 2016

Curso de Delphi - Capítulo 3. Variables y Constantes


Ya está aquí el tercer episodio de nuestro curso de Delphi sobre Lazarus.
En este tercer capítulo nos vamos a centrar en:

  • Tipos de datos básicos y derivados
  • Variables y constantes
  • Ámbito y compatibilidad
  • Operaciones disponibles

En este tema es especialmente importante entender correctamente el concepto de ámbito y la compatibilidad entre los distintos tipos de datos disponibles en Pascal.

Esperando que sea de vuestro total agrado os dejamos con el vídeo.

Compartir:

jueves, 31 de marzo de 2016

Hola Mundo multilingüe

¡Hola Mundo!

Aprovechando que he implementado SyntaxHighLighter en el blog, vamos a hacer un repaso por la mayoría de lenguajes de programación haciendo lo primero que debería hacer todo programador que empieza con un nuevo lenguaje de programación; el programa "Hola Mundo"

Espero que os guste el formato. A partir de ahora empezaré a incluir entradas con tips de programación en diferentes lenguaje y rutinas interesantes para que las tengamos todos a mano.

ColdFusion

<html>
<head>
<title>Test</title>
</head>
<body>

  <cfset message = "¡Hola Mundo!">
  <cfoutput>#message#</cfoutput>

</body>
</html>

C#

using System;
namespace HelloWorld
{
    class Hello 
    {
        static void Main() 
        {
            Console.WriteLine("¡Hola Mundo!");           
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    }
}

C++

#include <iostream>
 
int main()
{
  std::cout << "¡Hola Mundo!" << std::endl;
  return 0;
}

Delphi/Pascal

program Hello;
begin
  writeln ('¡Hola Mundo!');
  readln
end.

JavaScript

<!DOCTYPE HTML>
<html>
<body>

  <p>Header...</p>

  <script>
    alert('¡Hola Mundo!')
  </script>

  <p>...Footer</p>

</body>
</html>

Java
public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("¡Hola Mundo!");
    }

}

Perl

  #!/usr/bin/env perl

  use v5.10.0;
  use warnings;
  use strict;

  say "¡Hola Mundo!";

Php

<html>
<head>
<title>Test</title>
</head>
<body>

 <?php
  $message = "¡Hola Mundo!";
  echo $message;
 ?>

</body>
</html>

PowerShell

$strString = "¡Hola Mundo!"
write-host $strString

Python

print("¡Hola Mundo!")

Ruby

puts '¡Hola Mundo!'

Visual Basic

Module Hello
  Sub Main()
      MsgBox("¡Hola Mundo!")  
  End Sub
End Module

Compartir:

miércoles, 2 de marzo de 2016

Retrospectiva. Febrero 2016



Ya estamos en Marzo y, de la misma manera que el mes pasado y como haremos todos los meses, toca hacer una retrospectiva sobre el mes que acaba de pasar.

A veces las cosas no salen como uno quiere, unas veces debido a imprevistos y otras (la mayoría) por errores de estimación o planificación. Este mes en el blog hemos tenido un poco de todo: Por un lado, como algunos ya sabéis, estoy viviendo en Mallorca, pero mi familia está en Almería. Esto implica que, aproximadamente, cada dos semana estoy yendo a ver a mi mujer y a mis hijas, y este mes no había tenido en cuenta estos viajes para la planificación del blog. En realidad esto no supone ningún problema ya que he decidido tomarme este blog como lo que es, mi hobbie, así que no pienso agobiarme por no publicar un post durante la semana ni nada por el estilo. Por otro lado muchos que me seguís en las redes sociales sabréis que he empezado un curso experto de Java, (J2SE, J2EE y Android) y el tiempo que me va a consumir su realización.

En la retrospectiva de Enero os comentaba que intentaría subir a 9 los post durante este Febrero; esto no ha podido ser así debido a lo que os comentaba un poco más arriba. También quería seguir añadiendo mejoras al blog que han tenido que posponerse para este mes. Lo que si ha podido empezar es el curso de Delphi sobre Lazarus cuyos dos primeros capítulos tenéis aquí:


Esta misma semana tendréis el siguiente capítulo disponible. Si no queréis perderos nada os recomiendo que os suscribáis al canal de youtube así como al feed de este blog, pero eso ya es cosa vuestra (aunque os lo agradecería enormemente).

Para este mes de Marzo voy a ser bastante conservador en cuanto objetivos. Voy a plantearme hacer entre 7-9 entradas de las cuales 4 serán capítulos del curso de Delphi, de manera que me quede tiempo suficiente para continuar mi curso de Delphi. Incluiré las mejoras que tenía pensadas para Febrero y añadiré una página destinada a los cursos y otra destinada a una recopilación de blogs que suelo leer y que me parecen interesantes.

Sin más, me despido hasta el próximo post.


Code Safe…
Compartir:

domingo, 21 de febrero de 2016

Curso de Delphi - Capítulo 2. Primera aplicación



Ya ha pasado una semana desde que publiqué el primer episodio de nuestro curso de Delphi sobre Lazarus y hoy toca que avancemos un poco.

En este capítulo trataremos los siguientes temas:

  • El IDE de Lazarus.
  • Proyectos en Delphi.
  • Componentes, métodos y eventos.
  • Nuestro primer programa.

Espero que os guste y que os suscribáis al canal. Un saludo!

Compartir:

domingo, 14 de febrero de 2016

Curso de Delphi - Capítulo 1. Introducción


¡Muy buenas a todos! Ya tocaba ir empezando el curso de Delphi sobre el IDE Lazarus, así que aquí tenéis el primer vídeo con la presentación del curso y la introducción al IDE que utilizaremos para llevarlo a cabo.


No obstante os dejo aquí el contenido que desarrollaremos en este primer sprint del curso para que lo tengáis a la mano. 

  • Un vistazo al IDE de Lazarus.
  • Estructura de un proyecto Delphi/Lazarus
  • Nuestro primer programa
  • Tipos de datos. Variables y constantes
  • Estructuras de control
  • Procedimientos y funciones
  • Objetos. Una breve introducción
  • Formularios

También crearé una sección de páginas fuera de las entradas típicas de blogger para estructurar el contenido de una manera más eficiente y que, de esa manera, tengáis un mejor acceso al mismo.

No os olvidéis de compartir el post, darle like al vídeo y todas esas cosas que sirven para hacerme ric... digooo para que más gente lo vea :D

Capítulos:
Compartir:

lunes, 1 de febrero de 2016

Retrospectiva. Enero 2016


Ya estamos en Febrero y toca hacer algo que se suele hacer cada vez que se finaliza un sprint en SCRUM (hablaremos de este tema en algún momento entre mañana y el fin de los tiempos) que se llama retrospectiva

Esto no es más que echar la vista atrás y comprobar lo que se ha hecho durante un periodo de tiempo determinado y analizar que es lo que se puede mejorar, cambiar, o simplemente hacer una valoración, del trabajo realizado.

A principios de Enero abrí este blog con el objetivo de acercaros un poco más ciertos aspectos de mi vida que no conocíais y de paso enseñaros algunas cosas que seguramente muchos ya conocéis y otros no (¿esto era así o al revés?)... En cualquier caso, me plantee como objetivo escribir al menos una entrada a la semana, objetivo que he conseguido alcanzar, aunque mirándolo en perspectiva me resulta algo pobre.

Como podréis observar, he cambiado el aspecto (tema) del blog, haciéndolo más atractivo y fácil de leer; he añadido la primera página fuera de entradas, llamada descargas, donde encontraréis programas interesantes relacionados con la programación y que iré actualizando de vez en cuando, y también, he conseguido activar el adsense gracias a las visitas que todos vosotros habéis realizado al blog. 


Objetivos para Febrero.

Para este Febrero que recién empieza me gustaría aumentar el número total de entradas de 6 a, al menos, 9 y empezar el curso de Delphi (lo haremos vía Lazarus), lo cual me servirá para reactivar el canal de youtube de InvalidExpresion. Continuaré con mejoras en el blog y, por supuesto, atendiendo a vuestros comentarios y peticiones mediante las redes sociales a las que podéis acceder mediante los iconos arriba a la derecha.

Un saludo y nos vemos en la siguiente entrada.


“Mucho del software hoy en día se parece a una pirámide egipcia: con
millones de ladrillos apilados uno encima del otro, sin integridad
estructural y hecho por pura fuerza bruta y miles de esclavos.”
Alan Kay
Compartir:

jueves, 28 de enero de 2016

Delphi - Un poco de (mi) historia

 Hace ya algunos años, en la carrera, me matriculé en una asignatura llamada "Herramientas de 4ª generación"; asignatura que, sin yo saberlo marcaría el resto de mi carrera profesional. 
Yo ya había utilizado Turbo Pascal en alguna que otra asignatura (incluso le había dedicado horas por libre) pero nunca había utilizado Delphi.

¿Que es Delphi?


Kylix sobre Linux
Delphi es una herramienta de Desarrollo Rápido de Aplicaciones (RAD). Cuenta con un Entorno de Desarrollo Integrado (IDE) y una Biblioteca de Componentes Visuales (VCL), orientada totalmente a objetos, que facilitan la programación tanto bajo Windows como bajo Linux (Kylix).

Como ya he mencionado, Delphi desciende directamente de Pascal, concretamente de su versión orientada a objetos Object Pascal, con la diferencia de que Delphi es un lenguaje orientado a eventos y con una gran potencia en la gestión de todo tipo de bases de datos. Yo lo he utilizado contra SQL Server (MicroSoft) , DB2 (IBM), Oracle (SUN), etc... con excelentes resultados.

Es extraño que, a pesar de su gran potencia, no esté mas extendido (quizá porque los buenos programadores Delphi escasean) ya que es una plataforma independiente del dispositivo, en la que no es necesario un Framework que la soporte y que tiene una curva de aprendizaje más que aceptable.

Además, el diseño de nuevos componentes a partir de la VCL es tremendamente sencillo, pudiendo construir desde pequeñas mejoras a los componentes ya existentes como componentes mucho más complejos.

Mi historia con Delphi



Las nuevas y potentes versiones Delphi
Hablando un poco de mi historia; después de salir de la carrera pase 2 años sin volver a utilizar Delphi, no fue hasta mi segundo trabajo cuando volví a tener contacto con esta plataforma. 11 años transcurrieron en los que pasamos de Delphi 4 a Delphi 7 sobre DB2 sin mayores cambios en el horizonte. En este tiempo Delphi pasó de ser distribuido por Borland a serlo por CodeGear (Embarcadero), desarrollándose nuevas versiones con las que yo no trabajaría hasta llegar a mi siguiente empleo donde estaban ya con Delphi XE5  y algunas licencias de Delphi XE8 sobre Oracle.

Antes de empezar en mi actual trabajo ya había "trasteado" un poco con algunas versiones de Delphi XE y la verdad es que su potencia me encantó. Aunque ya había realizado algunos cursos de C# y Java, volver a Delphi con un entorno renovado en apariencia y potencia ha sido, inesperadamente, placentero.

Lazarus sobre KDE - Linux

Existe una versión gratuita de Delphi llamada Lazarus con la que podéis empezar a probar este magnifico entorno de desarrollo sin ningún problema.

Si os apetece que haga un pequeño curso sobre Delphi (lo haría con Lazarus) hacédmelo saber en los comentarios y empezaré a desarrollar algo que puede ser interesante (quizá hasta incluya vídeos)

Compartir:

Stream

Con la tecnología de Blogger.

BoosterBlog

BoosterBlog
BoosterBlog

Timeline Twitter

Seguidores

Seguidores