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

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').

En Python:

longitud.py

cadena="ABC"
if len(cadena) !=0:
   print(cadena) 
else:
   print("Cadena vacia")

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

Lo que conforma a un lenguaje de programación

 

De la Wikipedia:

Los lenguajes de programación están formados por un conjunto de símbolos (llamado alfabeto), reglas gramaticales (léxico/morfológicas y sintácticas) y semánticas, que en conjunto definen las estructuras válidas del lenguaje y su significado.

Es un sistema de notación para escribir programas de computadora; se describe por su sintaxis (forma) y semántica (significado), además de tener al menos una implementación en forma de compilador o intérprete, lo que permite ejecutar programas escritos en ese lenguaje.

La explicación simplista sería: es un lenguaje para hacer que la computadora obedezca nuestras instrucciones previamente creadas.

¿Pero qué diantres es lo que conforma a un lenguaje de programación?

Lo que conforma a un lenguaje de programación es:

• Reglas sintácticas: Conjunto de reglas que definen las secuencias correctas de los elementos.
• Reglas semánticas: Es el significado de las instrucciones en un lenguaje de programación y determina cómo se deben interpretar y ejecutar las acciones.
• Un intérprete o compilador.

La sintaxis describe cómo se ve, mientras que la semántica describe lo que debe hacer. Para mayor información ver esto: https://gus.chat/blog/semantica-en-programacion-tipos-y-usos-mas-comunes/

Ejemplos de sintaxis:

def var nombreVar as type no-undo.

function nameFunction returns type(param1 as type, param2 as type, paramN as type):
   /*  do stuff */
end.

Como podemos ver, la sintaxis nos indica cómo debemos escribir las instrucciones, ya sea declaración de variables, operaciones aritméticas y/o lógicas y la definición de funciones o procedimientos. En este caso vemos la forma en que debemos definir variables y crear una función (para el ejemplo usamos OpenEdge ABL, en otros lenguajes la sintaxis cambia).

Ejemplo de semántica:

Si tomamos los ejemplos de arriba. En primer lugar vemos la declaración de variables. Una variable debe ser definida, tener un valor y ser implementada. En el caso de una función deberá tener un propósito definido, realizar alguna operación y ser invocada. La semántica nos dice el signififcado, el por qué de una instrucción.

Intérprete: es un traductor. Verificará las reglas sintácticas (como se escribe la instrucción) y semánticas (el significado de la instrucción) y traducirá a un lenguaje que la máquina (computadora) podrá ejecutar. Python y Perl usan intérpretes que ejecutan el código.

Compilador: es un conversor. No solo verificará las reglas sintácticas y semánticas sino que además creará un código ejecutable para que la computadorá lo ejecute. Relativamente más lento que un intérprete, pero más seguro. Esto porque no solo se conforma con interpretar sino en verificar el tipo de datos que se definen a la hora de escribir las instrucciones. C, C++ y Java usan compiladores que crean un ejecutable (ver la imagen de arriba).

Si te interesa crear un compilador podrías checar este sitio:

https://www.antlr.org/

Pepepepero ¿eso es todo?

No. Cualquier lenguaje de programación que se digne llamar así tendrá su propia sintaxis y semántica, así como paradigma (funcional, orientado a objetos, etc.). Como definir tipos de datos (en el caso de los lenguajes de tipado estático), estructuras de control (top-down, secuenciales e iterativas). Manejo de errores o excepciones. Aserciones. Estructuras de control (vectores, listas, nodos, mapas, árboles) . Manipulación de archivos. Acceso a bases de datos. Entre otras cosas más.

Enlaces:

https://www.antlr.org/

https://www.compilers.iecc.com/crenshaw/

OpenEdge: Progress ABL (Advanced Business Language)

Progress ABL es un lenguaje de programación vinculado al entorno Progress OpenEdge, su base de datos y las utilidades que lo rodean. 

Es similar al inglés fuertemente tipado, enlazado en tiempo de ejecución. Aunque inicialmente se diseñó como un lenguaje procedimental, a partir de la versión 10.1 se mejoró con elementos de gramática orientada a objetos, que se pueden mezclar con el estilo procedimental original. 

A diferencia de otros lenguajes, Advanced Business Language (ABL) permite a los desarrolladores administrar datos relacionales de la manera que mejor se adapte a sus necesidades comerciales, lo que aumenta significativamente la productividad. 

Un desarrollador de OpenEdge puede crear API para .NET, JavaScript, clientes Java, mensajería Java e incluso asignar esquemas de bases de datos a formatos XML, al mismo tiempo que aprovecha la eficiencia de ABL. 

ABL también ofrece herramientas esenciales para el desarrollo de aplicaciones, lo que le permite tener fácil acceso a todos los recursos de su aplicación.

¿Por qué %$@# debería importarme este lenguaje?

Porque en el mundo de la informática siempre hay que saber un poco de todo. Un día eres programador Java, mañana tendrás que usar PHP, C, etc. Pasar del Backend al Frontend y hasta a BD. Siempre hay que estar abiertos a todo. 

Imaginemos un escenario donde una empresa usa Progress y decide contratar a un nuevo desarrollador para trasladar los códigos de Progress a Java, o viceversa. El desarrollador con experiencia en Progress tendrá menos dificultad de trasladar ese código a Java pues conoce lo que hacen y no hacen esos programas.

Crear un programa en Progress es relativamente sencillo si tienes experiencia en lenguajes como Perl o Python. El programa para calcular el factorial de un número podría ser algo como esto:

factorial.p

function factorial returns integer (num as integer):
   if num = 0 then
      return 1.
   else
      return num * factorial(num - 1).
end.

DISPLAY "Factorial de 5: " factorial(5).

Un programa en Progress tiene la extensión *.p. Los tipos básicos son: integer, decimal, character y logical (boolean). Las estructuras de control son similares a las de Perl y/o Python. Además de que es de tipado estático. Tendrás que declarar el tipo y valor antes de usar una variable.

/* Puedes usar def o define, var o variable */
define var numero as integer no-undo. /*  int */
def variable valor as dec no-undo. /*  decimal */
def var verdadero as logical no-undo. /*  booleano */
def cadena valor as char no-undo. /*  character*/

Podemos hacer cualquier cosa como en otros lenguajes.

longitud.p

def var cadena as char no-undo.
def var longitud as int no-undo.

cadena = TRIM(" ABC "). /* quitar espacios */
longitud = LENGTH(cadena). /* Contar longitud de la cadena */

display "Cadena: " cadena " , Longitud: " longitud.

Aquí podemos observar que posee funciones propias para la manipulación de cadenas.

¿Y qué con las BD?

Crear programas para la manipulación o consulta de datos es tan fácil como esto:

for each empleados:
    display empleados.idEmp empleados.nomEmp empleados.idDepto
end.

Mientras que en código Java como mínimo tendrías que crear un proyecto. Hacer la conexión y la consulta SQL. Sin olvidar lo engorroso que es encontrar un driver para la BD.

Para probar Progress Online puedes entrar aquí: https://abldojo.services.progress.com/

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

Enlaces:

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