sábado, 30 de marzo de 2024

PHP: herramientas para probar nuestras aplicaciones

He aquí una lista de las herramientas más populares para probar nuestras aplicaciones PHP.

XAMPP

XAMPP es una distribución de Apache completamente gratuita y fácil de instalar que contiene MariaDB, PHP y Perl. El paquete de instalación de XAMPP ha sido diseñado para ser increíblemente fácil de instalar y usar.

https://www.apachefriends.org/es/index.html

WampServer

Es un entorno de desarrollo web de Windows. Te permite crear aplicaciones web con Apache2, PHP y una base de datos MySQL.

https://www.wampserver.com/en/

EasyPHP

Un entorno de desarrollo PHP completo y listo para usar en Windows que incluye el servidor web Apache, SQL Server MySQL y otras herramientas de desarrollo.

https://www.easyphp.org/

AppServ

Appserv es una herramienta para Windows con Apache, MySQL, PHP y otras adiciones, en la cual estas aplicaciones se configuran en forma automática, lo que permite ejecutar un servidor web completo.

https://www.appserv.org/en

Uw Amp

Servidor Wamp gratuito con Apache MySQL PHP y SQLite

https://www.uwamp.com/en/

jueves, 28 de marzo de 2024

Instalar PHP en Windows (vídeo Youtube)

Ya en un post anterior vimos como instalar PHP (CLI): https://codemonkeyjunior.blogspot.com/2023/01/instalar-php-cgi.html ahora veremos como hacerlo para sistemas Windows.
Acá el clásico script para obtener toda la información del intérprete PHP:
index.php
<?php
   phpinfo();
?>

Ejecutar con:
php -S localhost:8000

Enlaces:

domingo, 17 de marzo de 2024

OpenEdge ABL: Cómo definir variables y constantes

 



En otras publicaciones ya hemos hablado de éste lenguaje de programación. Sin embargo, faltó indicar indicar cómo se declaran las variables y constantes, además de como se puede asignar valores a ellas. En el post anterior vimos que podemos asignar valores con la palabra ``ASSIGN``, pero podemos omitirla. También vimos como iniciar un valor con la palabra ``INIT``.

DEFINE VARIABLE edad AS INTEGER NO-UNDO.

/* Usando la palabra clave ASSIGN */
ASSIGN edad = 30.

/* Usando el operador de asignación = */
edad = 30.

Podemos usar ``ASSIGN`` para asignar valores a las variables declaradas.

DEFINE VARIABLE RADIO AS DECIMAL NO-UNDO INITIAL 5.0.

DEFINE VARIABLE AREA AS DECIMAL NO-UNDO.

/* Declaración de la constante */
DEFINE VARIABLE PI AS DECIMAL NO-UNDO INITIAL 3.14159.

/* Cálculo del área del círculo */
AREA = PI * RADIO * RADIO.

/* Mostrar el área */
MESSAGE "El área del círculo es: " AREA VIEW-AS ALERT-BOX.

Podemos usar ``INITIAL`` para inicializar un valor en una variable y omitir ``ASSIGN``. Y también usamos la palabra ``INITIAL`` para inicializarla. En teoría una constante es una variable que no podrá cambiar de valor a lo largo del flujo del programa. En OpenEdge para declara una constante deberás usar una clase y dentro de ésta crear un campo público e inicializar el valor. Algo bastante engorroso. Aquí en este post solo simulamos crearla.

En OpenEdge existen variables de tipo:

CHAR o CHARACTER
DATE
INT o INTEGER
DEC o DECIMAL
LOGICAL

Ejemplos de declaración de variables y asignación de valores.

/* Declaración de variables */
DEFINE VARIABLE cliente AS HANDLE NO-UNDO.
DEFINE VARIABLE fechaNacimiento AS DATE NO-UNDO.
DEFINE VARIABLE esMayorDeEdad AS LOGICAL NO-UNDO.
DEFINE VARIABLE nombre AS CHARACTER NO-UNDO.
DEFINE VARIABLE precio AS DECIMAL NO-UNDO.
DEFINE VARIABLE edad AS INTEGER NO-UNDO.

/* Asignación de valores */
ASSIGN edad = 30.
ASSIGN precio = 19.99.
ASSIGN nombre = "Juan".
ASSIGN esMayorDeEdad = TRUE.
ASSIGN fechaNacimiento = DATE("1990-01-01").

CREATE CLIENTE.
ASSIGN cliente = LAST-RESULT.

Hemos aprendido cómo declarar variables y constantes en OpenEdge.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/03/openedge-abl-creando-funciones-y.html

OpenEdge ABL: creando funciones y procedimientos

Crear nuestras propias funciones o procedimientos nos sirve para la reducción de código y hacer el código más legible. Pero antes de comenzar, debemos hacer una diferencia: las funciones nos devolverán valores y los procedimientos no.

Ejemplo. Se requiere crear una función que convierta grados Celsius a grados Fahrenheit. Fórmula:

F = (9/5 * Celsius) + 32

fahrenheit.p

def var celsius as dec no-undo initial 33.9.

/* Función para realizar la conversión de Celsius a Fahrenheit */
function getFahrenheit dec(valor as dec):
    return (9.0 / 5.0) * valor + 32.0.
end.

display "Celsius: " celsius " , Fahrenheit: " getFahrenheit(celsius).

Nota: Para probar este código puedes entrar a este sitio: https://abldojo.services.progress.com/

Para que el programa funcione, se debe crear primero la función. Recordemos que muchos lenguajes de pogramación hacen una evaluación Top-down. Si invocas una función en el bloque de arriba sin antes definir una función, causará error.

También podríamos agregar otra función que obtenga lo grados Celsius:

/* Función para obtener grados Celsius */
function getCelsius dec (valor as dec):
    return (valor - 32.0) / (1.8).
end function.

También podríamos escribir la misma función pero de esta manera:

FUNCTION getCelsius RETURNS DECIMAL (
    INPUT valor AS DECIMAL
):
    DEFINE VARIABLE celsius AS DECIMAL.
    
    ASSIGN
        celsius = (valor - 32.0) * (5.0 / 9.0).
        
    RETURN celsius.
END FUNCTION.

Código completo:

def var celsius as dec no-undo initial 33.9.

/* Función para realizar la conversión de Celsius a Fahrenheit */
function getFahrenheit dec(valor as dec):
    return (9.0 / 5.0) * valor + 32.0.
end.

FUNCTION getCelsius RETURNS DECIMAL (
    INPUT valor AS DECIMAL
):
    DEFINE VARIABLE celsius AS DECIMAL.
    
    ASSIGN
        celsius = (valor - 32.0) * (5.0 / 9.0).
        
    RETURN celsius.
END FUNCTION.

display "Celsius: " celsius " , Fahrenheit: " getFahrenheit(celsius).
display "Celsius: " getCelsius(getFahrenheit(celsius)).

Como se pude ver usamos ``ASSIGN`` para asignar valores. En este caso asignamos el resultado de la conversión a la variable ``celsius``. El resultado será:

   celsius
          ----------
Celsius:       33.90  , Fahrenheit:       93.02 Celsius:       33.90

Para realizar la conversión de grados Fahrenheit a Celsius usamos ésta fórmula:

Celsius = (valor - 32.0) * (5.0 / 9.0).

Ejemplo 2. Crear un procedimiento que solo imprima un simple "Hola, mundo".

PROCEDURE imprimirHolaMundo():
    MESSAGE "Hola, mundo" VIEW-AS ALERT-BOX.
END PROCEDURE.

Para invocarlo:

RUN imprimirHolaMundo.

Ejemplo 3. Crear una función que no necesite parámetros de entrada.

FUNCTION getSaludo RETURNS CHARACTER:
    RETURN "Hola, programador de OpenEdge".
END FUNCTION.

DISPLAY getSaludo().

Ejemplo 4. Crear una función que calcule el factorial de un número

FUNCTION calcularFactorial RETURNS DECIMAL (
    INPUT numero AS DECIMAL
):
    DEFINE VARIABLE resultado AS DECIMAL INIT 1.
    DEFINE VARIABLE contador AS DECIMAL.
    
    DO contador = 1 TO numero:
        resultado = resultado * contador.
    END.
    
    RETURN resultado.
END FUNCTION.

DISPLAY calcularFactorial(5).

En este caso el resultado será: 120.00

Podríamos modificar la función usando la técnica de recursión:

FUNCTION calcularFactorial RETURNS DECIMAL (
    INPUT numero AS DECIMAL
):
    IF numero = 0 THEN
       RETURN 1.
    ELSE
       RETURN numero * calcularFactorial(numero - 1).
END FUNCTION.

DISPLAY calcularFactorial(5).

Ambas funciones resuelven el mismo problema. Como se ha visto en los primeros ejemplos: OpenEdge nos permite algunas cosas como omitir colocar la palabra ``INPUT`` o no colocar la palabra ``FUNCTION`` al final de una función.

Más ejemplos en próximas entregas.

Enlaces:

https://www.progresstalk.com/
https://abldojo.services.progress.com/

domingo, 3 de marzo de 2024

Creando un proyecto con Gleam

En un post anterior vimos qué es el lenguaje Gleam, además de como instalarlo. Esta ocasión vamos a crear un proyecto con este lenguaje de programación funcional.

Creando un proyecto con Gleam

Abrimos una terminal y tecleamos:

gleam new proyecto

Esto nos creará un proyecto.

$ tree
Listado de rutas de carpetas
El número de serie del volumen es F4A1-89BE
C:.
├───.github
│   └───workflows
├───build
│   ├───dev
│   │   ├───erlang
│   │   │   ├───gleam_stdlib
│   │   │   │   ├───ebin
│   │   │   │   ├───include
│   │   │   │   └───_gleam_artefacts
│   │   │   ├───gleeunit
│   │   │   │   ├───ebin
│   │   │   │   └───_gleam_artefacts
│   │   │   └───proyecto
│   │   │       ├───ebin
│   │   │       └───_gleam_artefacts
│   │   └───javascript
│   ├───lsp
│   │   ├───erlang
│   │   └───javascript
│   ├───packages
│   │   ├───gleam_stdlib
│   │   │   ├───include
│   │   │   └───src
│   │   │       └───gleam
│   │   └───gleeunit
│   │       └───src
│   │           └───gleeunit
│   └───prod
│       ├───erlang
│       └───javascript
├───src
└───test

El programa principal será src/proyecto.gleam . Lo editaremos:

// Pruebas con Gleam

import gleam/io

pub fn main() {
  io.println("\t===== Programando en Gleam =====")
}

Para compilar y ejecutar tecleamos:

$ gleam build
$ gleam run

Nota: Podemos solo teclear el segundo comando, iniciará la compilación y después ejecutará el código:

Si la compilación es correcta, se ejecutará:

$ gleam run
  Compiling proyecto
   Compiled in 1.32s
    Running proyecto.main
        ===== Programando en Gleam =====

Variables en Gleam

La declaración de variables es algo con lo que comenzaremos a ver.

// Int
let entero = 33

// String
let cadena = "ABC"

// Int con formato
let num_binario = 0b00001111
let num_octal = 0o17
let num_hexa = 0xF

// Float
let num_flotante = 7.0e7

// Boolean
let booleano = 43 < 33 // Esto es False
	

Se pude apreciar que la declaración de variables es similar a Rust. Existen tipos Int, Float, String y Boolean.

Si queremos declarar una variable sin usar podemos hacer esto:

// Int
let _no_se_usa = 33


	

Notar que usamos el guión bajo para declarar variables que no usamos.

Código completo:

src/proyecto.gleam

// Pruebas con Gleam

import gleam/io

pub fn main() {
  io.println("\t===== Programando en Gleam =====")
  test_a()
}


pub fn test_a(){
	let entero = 33
	let cadena = "ABC"
	let num_binario = 0b00001111
	let num_octal = 0o17
	let num_hexa = 0xF
	let num_flotante = 7.0e7
	let booleano = 43 < 33 // Esto es False
	io.println("\t ====== Variables en Gleam ======")
	io.println("Entero: ")
	io.debug(entero)
	io.println("Cadena: ")
	io.debug(cadena)
	io.println("Booleano: ")
	io.debug(booleano)
	io.println("Numero binario: ")
	io.debug(num_binario)
	io.println("Numero hexadecimal: ")
	io.debug(num_hexa)
	io.println("Numero octal: ")
	io.debug(num_octal)
	io.println("Numero flotante: ")
	io.debug(num_flotante)
}

Ejecutamos el proyecto:

 gleam run
  Compiling proyecto
   Compiled in 1.32s
    Running proyecto.main
        ===== Programando en Gleam =====
         ====== Variables en Gleam ======
Entero:
33
Cadena:
"ABC"
Booleano:
False
Numero binario:
15
Numero hexadecimal:
15
Numero octal:
15
Numero flotante:
7.0e7

Hemos creado nuestro primer proyecto con este lenguaje de programación. Más en próximos posts.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/03/conociendo-gleam-un-lenguaje-que-corre.html

Conociendo Gleam, un lenguaje que corre sobre la máquina de Erlang

 

Gleam es: un lenguaje de programación funcional que corre sobre la máquina virtual de Erlang (BEAM) o como lo dice el sitio oficial:

"Es un lenguaje amigable para construir sistemas con seguridad de tipos que escalan".

El clásico "Hello world" en Gleam:

// Import a Gleam module from the standard library
import gleam/io

pub fn main() {
  io.println("Hola, mundo en Gleam!")
}

Si quieres probarlo sin tener que instalarlo, checha este sitio: https://tour.gleam.run/

A primera vista Gleam nos recuerda a lenguajes como Rust o quizás Golang y hasta Ballerina language.

Instalando Gleam

En Linux:

sudo xbps-install gleam

En Windows necesitamos instalar Scoop antes de Gleam. Debemos abrir una terminal de Powershell como administrador y teclear estos comandos:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

En caso de que no permita instalar, teclear este comando:

iex "& {$(irm get.scoop.sh)} -RunAsAdmin"

Verificar instalación de Scoop:

scoop help

Procedemos a instalar Gleam:

scoop install gleam

Verificar instalación de Gleam:

$ gleam --version
gleam 0.34.1

Más sobre este lenguaje en próximos posts.

Enlaces:

https://gleam.run/
https://emanuelpeg.blogspot.com/2023/03/gleam-un-lenguaje-funcional-que-corre.html
https://scoop.sh/
https://github.com/ScoopInstaller/Install#for-admin