Katas de programación en C

En esta ocasión haremos un pequeño programa dividido en tres archivos:

1. Programa principal: main.c
2. Librería o macro: pulsaciones.h
3. Implementación de librería: pulsaciones.c

pulsaciones.h

#ifndef PULSACIONES_H
#define PULSACIONES_H


#endif

En este archivo definiremos las cabeceras de la función que calculará el número de pulsaciones. Para esto definiremos un tipo de datos tipo int el que denominaremos Entero y un tipo definido de tipo float llamado Flotante.

pulsaciones.h

#ifndef PULSACIONES_H
#define PULSACIONES_H

typedef int Entero;
typedef float Flotante;

#endif

Además agregaremos un encabezado para poder usar las funciones de E/S (print, puts, etc.) y una constante con valor 10

pulsaciones.h

#ifndef PULSACIONES_H
#define PULSACIONES_H
#define TAM 10
#include<stdio.h>

typedef int Entero;
typedef float Flotante;

Flotante getPulsaciones(Entero, Entero);

#endif

En el siguiente archivo definiremos la implementación de la función getPulsaciones, la cual recibe dos variables tipo Entero (int) y devolverá un tipo Flotante (float).

pulsaciones.c

#include "pulsaciones.h"

Flotante getPulsaciones(Entero edad, Entero sexo){
    Flotante resultado = 0.0f;
    switch(sexo){
        case 1:
        puts("Sexo: Femenino");
        resultado = (220-edad)/TAM;
        break;
        case 2:
        puts("Sexo: Masculino");
        resultado = (210-edad)/TAM;
        break;
        default: 
        puts("Sexo y edad: Undefined");
        resultado = 0.0f;
        break;
    }
    return resultado;
}

Como se puede observar es necesario importar el archivo "pulsaciones.h" para poder implementar la función "getPulsaciones". Los datos de entrada son: sexo y edad. Las fórmulas para obtener las pulsaciones de acuerdo al sexo son las siguientes:

"Sexo: Femenino"
(220-edad)/10
     
"Sexo: Masculino"
(210-edad)/10
        

main.c

#include "pulsaciones.c"

Entero edad = 0;
Entero sexo = 0;

int main(){
    puts("\t ====== [ Pulsaciones ] ======");
    puts("Introduce sexo [1. Femenino   2. Masculino] :");
    scanf("%d",&sexo);
    puts("Introduce edad:");
    scanf("%d",&edad);
    printf("%.3f\n",getPulsaciones(edad, sexo));
    return 0;
}
        

Compilamos y creamos ejecutable:

$ gcc main.c -o ejecutable.exe

Ejecutamos el programa:

$ ./ejecutable.exe
	 ====== [ Pulsaciones ] ======
Introduce sexo [1. Femenino   2. Masculino] :
2
Introduce edad:
45
Sexo: Masculino
16.000

Enlaces:

https://pseudocodigoejemplos.com/calcular-el-numero-de-pulsaciones-que-debe-tener-una-persona/

Erlang: construir aplicaciones Erlang con Rebar3

Rebar3 es una herramienta que permite crear aplicaciones Erlang. Para instalarlo puedes seguir este link: http://rebar3.org/docs/getting-started/

Abrimos una terminal y tecleamos:

$ rebar3 new app auditor
===> Writing auditor/src/auditor_app.erl
===> Writing auditor/src/auditor_sup.erl
===> Writing auditor/src/auditor.app.src
===> Writing auditor/rebar.config
===> Writing auditor/.gitignore
===> Writing auditor/LICENSE
===> Writing auditor/README.md

Nos ubicamos en el directorio:

$ cd auditor
$ tree
.
├── LICENSE
├── README.md
├── rebar.config
└── src
    ├── auditor.app.src
    ├── auditor_app.erl
    └── auditor_sup.erl

Con esto tendremos nuestra primera aplicación creada con Rebar3.

exit()->
   io:fwrite("Hasta la próxima!!!\n").

Enlaces:
https://medium.com/erlang-central/building-your-first-erlang-app-using-rebar3-25f40b109aad
https://rebar3.readme.io/
https://adoptingerlang.org/docs/development/otp_applications/

100 días de código javascript ... 9na parte

Ejemplo 1.Las expresiones regulares son un mecanismo para encontrar patrones en cadenas de texto. Recorrer un arreglo y mostrar solo la fecha que cumpla el patrón (regex).

let fechas = ["12-09-1990","24:05:2000","25-JUN-2001","08-AGO-1987"];

for(let c in fechas){
  if(/\d\d-\w\w\w-\d\d\d\d/.test(fechas[c])){
     console.log('Cumple:',fechas[c]);
  }
}

Ejemplo 2. Exportar e importar archivos JS.
titulo_export.js

const titulo = "El retrato de una odisea sin nombre.";

export {titulo};

titulo_import.js

"use strict";

// 1. Primer forma
import {titulo} from './titulo_export.js';

console.log(`Titulo: ${titulo}`);

// 2. Segunda forma
import * as libro from './titulo_export.js';

console.log(`Titulo: ${libro.titulo}`);

Tweets #100daysofcode :

💥Learned about creating an element in JavaScript.
Here is how you create an element in JavaScript.#100DaysOfCode #webdesign #javascript #webdevelopment #WomenWhoCode #Coding #CodeNewbie pic.twitter.com/y0AFRwOlz2

— Isna Yousuf (@IsnaYousuf) December 5, 2021

💛JavaScript Tip💛

💡Did you know how to get a random item from an array in JavaScript?

🎯Here it is👇#javascript #Nodejs #webdevelopment #Tips #100DaysOfCode pic.twitter.com/XUKJFRgRtP

— Lakira Minlaka✨ (@Lakira_md) December 5, 2021

#javascript can freeze the prototypes of built-in object types. Preventing anyone from overriding or modifying those types.

Add a little security to your source code. pic.twitter.com/nQzymhtuJO

— Nick Foscarini (@reactgular) December 5, 2021

Enlaces:
https://dmitripavlutin.com/javascript-string-trim/
https://vanshsharma.hashnode.dev/difference-bw-forin-and-forof

PHP: expresiones regulares y otras cosas

PHP es un lenguaje bastante vilipendiado. No lo neguemos, tú, yo, tus colegas han tenido debates sobre "lo malo" que es el lenguaje. Sin embargo, con la madurez reconocemos que hemos estado equivocados, bastante equivocados. PHP es un lenguaje que ha salido avante a pesar del advenimiento de otros lenguajes de programación modernos. Con este lenguaje puedes crear servicios web, aplicaciones web dinámicas, etc. Tiene centenares o/y miles de Frameworks que facilitan (o complican) la vida del programador. Node JS, Angular... son lo de hoy, pero siempre habrá desarrollos que requieran algún programador que sepa PHP.
Antes de comenzar... instalaremos PHP Cli.

$ sudo apt-get update
$ sudo apt-get install php-cli -y
$ php --version

Las expresiones regulares son mecanismos par hacer coincidir patrones y/o cadenas. Para trabajar con expresiones regulares debemos:

1. Definir qué patrón se quiere buscar
2. Cadena donde se quiere buscar ese patrón

Ejemplo. Programa que verifique si las cadenas cumplen un patrón definido.

regex.php

<?php

  // Si empieza con F o f
  $expr1 = "/^F|f/";
  $cadena = "Fernando";
  if(preg_match($expr1, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si son dígitos
  $expr2 ="/[0-9]/";
  $cadena = "123456";
  if(preg_match($expr2, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no son caracteres normales 
  $expr3 ="/\W/";
  $cadena = "%&@#!?{}[=";
  if(preg_match($expr3, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si tiene espacios
  $expr4 ="/\s/";
  $cadena = "a b c ";
  if(preg_match($expr4, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no tiene espacios vacíos
  $expr5 ="/\S/";
  $cadena = "abcdef";
  if(preg_match($expr5, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si es un dígito 
  $expr6 ="/\d/";
  $cadena = "12087";
  if(preg_match($expr6, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no es un dígito 
  $expr7 ="/\D/";
  $cadena = "TRES MIL UNO";
  if(preg_match($expr7, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si es un caracter 
  $expr7 ="/\w/";
  $cadena = "El gato tiene 3 patas.";
  if(preg_match($expr7, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no son dígitos 
  $expr8 ="/[^0-9]/";
  $cadena = "Whisky";
  if(preg_match($expr8, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

  // Si no son dígitos 
  $expr9 ="/[^a-z]/";
  $cadena = "anita lava la tina";
  if(preg_match($expr9, $cadena)){
  	echo "$cadena : concuerda con el patron\n";
  }

?>

Ejecutando:

$ php -S 127.0.0.1:8080 regex.php

¡Feliz código!
Enlaces:
https://symfony.es/
https://codeigniter.com/
https://cakephp.org/
https://laravel.com/
https://miguelgomezsa.com/blog/laravel-vs-codeigniter
https://carlos-herrera.com/laravel-vs-codeigniter/
https://codemonkeyjunior.wordpress.com/2020/09/06/docker-instalando-imagen-de-php/

100 días de código javascript ...8va parte

Algunos twitts sobre #100Daysofcode

Still the first guy 😜😜😜#100Daysofcode #javascript #programming #dev #linux #java #programming #CodeNewbie #python #reactjs #bugbounty #DataScience #infosec #gamedev #BigData @programmerjoke9 pic.twitter.com/dpXhVV2GaU

— programmerjokesofficial (@programmerjoke9) October 17, 2021

Day 10 of #100DaysOfCode with Flutter.
Hoy finalmente terminamos esta aplicación, usamos un servicio web para obtener las imágenes que se muetran.
Mientras nos carga la imagen, nos muestra un pequeño gif de carga. pic.twitter.com/MgfU0diFH8

— Yael Zamora (@YaelZamOficial) October 15, 2021

Esta parte llego ser algo, complicada #vscode #100DaysofCode #JavaScript #nodejs #Heroku pic.twitter.com/JqPBcPgKnM

— Giobanny 🚀⚛ (@_pegasus23) October 13, 2021

Tip Javascript:
Obtener el valor mayor de un arreglo#javascript #100DaysOfCode #CodeNewbie pic.twitter.com/dVBtg4YUyn

— Urm_At_Awil (@Urm_At_Awil) October 10, 2021

Tip Javascript:

Palíndromo: Palabra o expresión que es igual si se lee de izquierda a derecha que de derecha a izquierda.#javascript #100DaysOfCode #CodeNewbie pic.twitter.com/nSaMz3fiHE

— Urm_At_Awil (@Urm_At_Awil) October 10, 2021

Tip javascript:

El operador "in" devuelve true si la propiedad especificada está en el objeto especificado o su prototipo.#javascript #100DaysOfCode #CodeNewbie pic.twitter.com/wVa3rtHJoz

— Urm_At_Awil (@Urm_At_Awil) October 10, 2021

Tip Javascript:
Recorrer arreglo y obtener su indice y elemento con forEach#javascript #CodeNewbie #100DaysOfCode pic.twitter.com/QnMDscRRUY

— Urm_At_Awil (@Urm_At_Awil) October 9, 2021

Enlaces:
https://javascript.info/
https://jsisweird.com/

Gradle: creando un proyecto C++

Gradle ha evolucionado de ser una alternativa a Maven a ser algo más. Ahora se puede crear y administrar proyectos Kotlin, Swift y hasta C++. en este post veremos:

1. Crear una carpeta para un proyecto C++
2. Generar un proyecto C++ con Gradle
3. Editar archivo principal
4. Construir y ejecutar

1. Crear carpeta del proyecto:

$ mkdir pruebasCpp && cd pruebasCpp

2. Generar proyecto C++ con Gradle:

$ gradle init


Select type of project to generate:
  1: basic
  2: application
  3: library
  4: Gradle plugin
Enter selection (default: basic) [1..4] 2

Elegimos la opción 2, porque queremos crear una aplicación.

Select implementation language:
  1: C++
  2: Groovy
  3: Java
  4: Kotlin
  5: Scala
  6: Swift
Enter selection (default: Java) [1..6] 1

Elegimos la opción 1, porque queremos usar C++.

Select build script DSL:
  1: Groovy
  2: Kotlin
Enter selection (default: Groovy) [1..2] 1

Elegimos la opción 2, porque... solo para variar un poco.
Listemos el el contenido del directorio:

$ tree

.
├── app
│   ├── build
│   │   ├── exe
│   │   │   └── main
│   │   │       └── debug
│   │   │           └── app
│   │   ├── install
│   │   │   └── main
│   │   │       └── debug
│   │   │           ├── app
│   │   │           └── lib
│   │   │               └── app
│   │   ├── obj
│   │   │   ├── for-test
│   │   │   │   └── main
│   │   │   │       └── debug
│   │   │   │           └── app.o
│   │   │   └── main
│   │   │       └── debug
│   │   │           └── c0rn65lkroj8p4fvz0qgmzzjr
│   │   │               └── app.o
│   │   ├── test-results
│   │   │   └── test
│   │   └── tmp
│   │       ├── compileDebugCpp
│   │       │   ├── options.txt
│   │       │   └── output.txt
│   │       ├── compileTestCpp
│   │       │   ├── options.txt
│   │       │   └── output.txt
│   │       ├── linkDebug
│   │       │   ├── options.txt
│   │       │   └── output.txt
│   │       └── linkTest
│   │           ├── options.txt
│   │           └── output.txt
│   ├── build.gradle.kts
│   └── src
│       └── main
│           ├── cpp
│           │   └── app.cpp
│           └── headers
│               └── app.h
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── settings.gradle.kts

Observemos nuestro archivo "build" generado.
build.gradle.kts

/*
 * This file was generated by the Gradle 'init' task.
 *
 * This generated file contains a sample C++ project to get you started.
 * For more details take a look at the Building C++ applications and libraries chapter in the Gradle
 * User Manual available at https://docs.gradle.org/7.2/userguide/building_cpp_projects.html
 */

plugins {
    // Apply the cpp-application plugin to add support for building C++ executables
    `cpp-application`

    // Apply the cpp-unit-test plugin to add support for building and running C++ test executables
    `cpp-unit-test`
}

// Set the target operating system and architecture for this application
application {
    targetMachines.add(machines.linux.x86_64)
}

3. Vamos a la carpeta donde esta el archivo principal y lo editamos:
app.cpp

/*
 * This C++ source file was generated by the Gradle 'init' task.
 */

#include <iostream>
#include <stdlib.h>
#include "app.h"

std::string demo::Greeter::greeting() {
    return std::string("Hola mundo desde Codemonkey Junior!!");
}

int main () {
    demo::Greeter greeter;
    std::cout << greeter.greeting() << std::endl;
    return 0;
}

4. Contruimos y ejecutamos:

$ ./gradlew build

$ ./app/build/exe/main/debug/app

Hola mundo desde Codemonkey Junior!!

En próximos post veremos más ejemplos.

Enlaces:
https://gradle.org/

¿Vale la pena aprender C y o C++?

En lenguaje C tuvo su época de gloria en en los años 70's. Con el advenimiento de lenguajes de programación como Visual Basic, Java, PHP y otros más es bueno recordarlo. C es un lenguaje que aún vale la pena darle un vistazo.

En este post usaremos el compilador GCC:

$ gcc --version
gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

holamundo.c

#include<stdio.h>
#define FIN 0

int main(int argc, char *argv[]){
  puts("Hola, mundo en C");
  return FIN;
}

Compilar:

$ gcc holamundo.c -o ejecutable

Ejecutar:

$ ./ejecutable

La evolución directa del lenguaje no fue ni Java o C#, fue C++. Si con C la curva de aprendizaje era alta, con C++ aumento de manera considerable. Podíamos hacer exactamente los mismo pero ahora tenia otras cosas más por aplicar como lo es: la programación orientada a objetos. Objetos, clases, herencia, polimorfismo era conceptos difíciles de aprender a quienes solo conocían los paradigmas funcional o estruturado. La primera diferencia es: la extensión de un programa en C++. Ya que se añade dos "pp" a la extensión clásica, quedando ".cpp" en vez de solo ".c". Otra diferencia es que introduce el concepto de manejo de excepciones, plantillas y ,como se mencionó antes, la programación orientada a objetos.
holamundo.cpp

#include<iostream>
using namespace std;

int main(int argc, char *argv[]){
  cout << "Hola, mundo en C++"<<endl;
  return 0;
}

En este caso usaremos el compilador G++:

$ g++ --version
g++ (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Compilamos:

$ g++ holamundo.cpp -o ejecutable

Ejecutamos:

$ ./ejecutable

Con C comprenderemos algunos conceptos como:

• Punteros
• Asignación dinámica de memoria
• Tipos definidos y estructuras

Punteros y asignación dinámica de memoria

// Puntero, variable que almacena la memoria de otra variable
int entero = 33;
int *puntero_entero = NULL;

// Asignación dinámica de memoria
puntero_entero = (int *)malloc(1*sizeof(int));

*puntero_entero = &entero;
printf("entero:%d\n",entero);
printf("puntero:%p\n",puntero_entero);

Estructuras y tipos definidos

// Creamos un tipo definido
typedef struct Nodo Nodo;

// Creamos una estructura
struct Nodo{
  long item;
  int valor;
  Nodo *izq;
  Nodo *der;
};

Nodo *raiz = NULL;
// asignamos memoria
raiz = (Nodo *)malloc(sizeof(Nodo));

raiz->item=(long)(12000);
raiz->valor=123;
raiz->izq = raiz->der = NULL;
printf("%10ld : %10d\n", raiz->item, raiz->valor);

// ... 

Con C++ conoceremos:

• Clases y objetos
• Manejo de excepciones
• Plantilas

Clases y objetos

#include<iostream>
using namespace std;

class X{
   public:
    X();
    virtual ~X();
};

X::X(){
  cout << "Objeto X creado"<<endl;
}

X::~X(){
  cout << "Objeto X destruido"<<endl;
}

int main(){
  X myObj;
  return 0;
}

Un pequeño consejo:

Para quienes quieran aprender a programar sería bueno que le dieran un vistazo al lenguaje C (en lugar de Python o cualquier otro "más sencillo").

Muchos juran y perjuran que Python es el mejor lenguaje de programación para principiantes, pero creo que no es así. Existen aspectos de la programación que en el lenguaje C te enseñará para después pasar a otros lenguajes. Si sabes lo que es un puntero y para qué se usa, si sabes lo que es la asignación dinámica de memoria y para qué se usa y si sabes para qué y cómo usar las estructuras de datos entonces ya estarás listo para pasar a Java, Python o cualquier otro lenguaje compilado o interpretado. 

Entendemos que es más fácil y entendible escribir un hola mundo de esta forma:

print("Hola, mundo en Python")

que en la forma de arriba. Pero cuando enfrentes proyectos hechos en lenguajes como Java, C++ y/o C# será más difícil entender la lógica y la complejidad del código.

Enlaces:
http://conclase.net/c