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

domingo, 25 de febrero de 2024

IDEs y editores de código que deberías conocer y usar

 

En este post veremos una pequeña lista de IDEs  y editores de código que todo programador debería conocer. La lista no tiene un orden específico.

Entre los IDEs más famosos están Eclipse, IntelliJ IDEA, Visual Studio y Netbeans. Algunos son muy específicos como Lazarus IDE que solo es para Pascal o Spyder IDE para Python. 

Y entre los editores de código más habituales están SublimeText, Notepad++ y Visual Studio Code.

IDEs

IntelliJ IDEA

https://www.jetbrains.com/es-es/idea/


Visual Studio 2022

https://visualstudio.microsoft.com/es/


NetBeans

https://netbeans.apache.org/front/main/index.html


Eclipse IDE

https://eclipseide.org/


PyCharm

https://www.jetbrains.com/es-es/pycharm/


Spyder IDE

https://www.spyder-ide.org/


Eric (Python) IDE

https://eric-ide.python-projects.org/


Lazarus IDE

https://www.lazarus-ide.org/


Aptana Studio

https://www.axway.com/en/aptana


Android Studio

https://developer.android.com/studio



Editores

Kate

https://kate-editor.org/es/


Notepad++

https://notepad-plus-plus.org/


Sublime Text

https://www.sublimetext.com/


Brackets

https://brackets.io/


Atom

https://atom-editor.cc/


Visual Studio Code

https://code.visualstudio.com/


MU Editor

https://codewith.mu/


Geany

https://www.geany.org/


CudaText

https://cudatext.github.io/


Enlaces:

https://www.techrepublic.com/article/best-ide-software/

https://en.wikipedia.org/wiki/List_of_text_editors

domingo, 18 de febrero de 2024

Intro to Elixir, APIs, and data architecture

Jacob Luetzow en este vídeo de Youtube nos da introducción de Elixir.

"My name is Jacob Luetzow, and I architect and build production-ready API's that scale with your company's growth. I will take you through step-by-step tutorials and teach you everything you need to know about building a robust backend for your apps". 

"You will get tips, tricks, and how-to's with building a REST API in Elixir, writing scripts to automate your build process, spinning up docker containers, and the DevOps skills required to maintain and load balance your servers". 

"Before starting your next API project, check out my hands-on tutorials and architect and build it the right way the first time".

Un programa en varios lenguajes

 

Esta ocasión veremos un ejemplo de programa escrito en varios lenguajes de programación como: Java, Erlang, Python, Powershell, Clojure y otros más.

Ejercicio: Un programa que determine si una cadena ("ABC") tiene una longitud distinta de cero. Si la longitud de cadena es distinta de cero, que imprima la cadena en pantalla. Si no cumple la condición deberá mandar el mensaje: "Cadena vacía".

En pseudo código sería algo como esto:

// Pseudo code language
prog longitud:{
     var cadena:String = "ABC";
     var longitud:Int = cadena.size;
     if longitud != 0 then
        disp "${cadena}"
     else
        disp "Cadena vacía"
}


Por temas de espacio algunos bloques de código son omitidos para no hacer más grande el código, usted disculpe.

En Powershell:

longitud.ps1

$cadena="ABC"

if($cadena.Length -ne 0){
   Write-Host $cadena  
}
else{
   Write-Host "Cadena vacia"
}

En Clojure:

longitud.clj

(ns longitud)

(def cadena "ABC")
(def longitud (count cadena))
(if (not= longitud 0)
   (println cadena)
   (println "Cadena vacia")
)

En Erlang:

longitud.erl

-module(longitud).
-author("Codemonkey Junior Blogspot").
-version("1.0.0").
-export([start/0]).

println(Cosa) -> io:format("~p~n", [Cosa]).

start()->
    Cadena="ABC",
    Longitud=string:length(Cadena),
    if 
     Longitud /= 0 ->
       println(Cadena);
    true ->
       println("Cadena vacia")
    end.

En OpenEdge ABL:

longitud.p

define var as char no-undo initial "ABC".

if length(cadena)<>0 then
   disp cadena.
else
   disp "Cadena vacia".

En Rust:

longitud.rs

let cadena:String = String::from("ABC");

if cadena.chars().count()!=0 {
   println!("{}",cadena)
}
else{
   println!("Cadena vacia")
}

En PL/SQL:

longitud.sql

SET SERVEROUTPUT ON
DECLARE
  cadena varchar2(3):='ABC';
  BEGIN
       IF LENGTH(cadena) != 0 THEN
          dbms_output.put_line(cadena);
       ELSE
          dbms_output.put_line('Cadena vacia');
       END IF;
  END;
/

En Elixir:

longitud.exs

cadena = "ABC"

if String.length(cadena) != 0 do
  IO.puts "#{cadena}"
else
  IO.puts "Cadena vacia"
end

En R:

longitud.r

cadena <- "ABC"

if(nchar(cadena) != 0) {
  sprintf("%s",cadena)
}else{
  print("Cadena vacia")
}

En DataStage BASIC:

longitud.dsx

Option Explicit

' Declaración de variables
Dim cadena As String

' Asignación de valor a la variable
cadena = "ABC"

' Verificación de la longitud de la cadena
If Len(cadena) <> 0 Then
    ' Imprimir la cadena si no está vacía
    Print cadena
Else
    ' Imprimir un mensaje si la cadena está vacía
    Print "Cadena vacia"
End If

En Ballerina:

longitud.bal

import ballerina/io;

public function main() {
    string cadena = "ABC";

    if (lengthof cadena != 0) {
        io:println(cadena);
    } else {
        io:println("Cadena vacia");
    }
}

En C:

longitud.c

#include <stdio.h>
#include <string.h>

int main() {
    char cadena[] = "ABC";

    if (strlen(cadena) != 0) {
        printf("%s\n", cadena);
    } else {
        printf("Cadena vacia\n");
    }

    return 0;
}

En C++:

longitud.cpp

#include <iostream>
#include <string>

int main() {
    std::string cadena = "ABC";

    if (!cadena.empty()) {
        std::cout << cadena << std::endl;
    } else {
        std::cout << "Cadena vacia" << std::endl;
    }

    return 0;
}

En Haskell:

longitud.hs

main :: IO ()
main = do
    let cadena = "ABC"
    if length cadena /= 0
        then putStrLn cadena
        else putStrLn "Cadena vacia"

En Prolog:

longitud.pl

cadena_valida('ABC') :- write('ABC').
cadena_valida('') :- write('Cadena vacia').

main :- cadena_valida('ABC').

Este post se irá actualizando... see you later !!