DEV Community: Coding Bugs

Quick Tip: Cómo unir ficheros CSV en 30 líneas de código

Coding Bugs — Fri, 08 Apr 2022 09:57:41 +0000

Mi apodo en las redes es Coding Bugs y llevo desde el año 2004 trabajando como desarrollador y arquitecto de software. En mi dashboard encontrarás artículos con información sobre lenguajes de programación, técnicas de programación y otros conceptos que te ayudarán a mejorar.

Vuelvo con otro artículo de PowerShell en el que os muestro lo fácil y rápido en generar un único fichero CSV a partir de muchos. Os resultará útil desarrollando procesos cuyo resultado sea un informe en formato CSV y tengáis que unir los contenidos de varios fichero en uno sólo.

CSV es una sigla que denomina a los ficheros con valores separados por comas o, en inglés, _"Comma Separated Values". Es un formato estandar de facto que se utiliza a menudo para el intercambio de información. El objetivo es tener un fichero de texto plano en el que cada fila es un registro, cada valor en la fila está separado por el carácter coma. Todas las filas tienen el mismo número de valores, es decir, el mismo número de comas. Visita la RFC 4180 para información detallada._

Para que el código siguiente funcione sin errores, el requisito es que todos los ficheros CSV que queremos unir tengan la misma estructura, es decir, las mismas cabeceras y en el mismo orden.

Si queréis trabajar con ficheros CSV y utilizáis Node.js, he desarrollado una librería que simplifica la obtención de sus datos mediante objetos, arrays y filtros dinámicos. Descárgatelo con NPM y obtén más información clicando en este enlace y cuéntame cómo te ha ido.

Una vez hecha la introducción vamos a por el código para comentarlo.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location,

    [Parameter(Mandatory=$true)]
    [String] $NameFilter,

    [Parameter(Mandatory=$true)]
    [String] $OutputFile
)

If(Test-Path $OutputFile) {
    Remove-Item $OutputFile -Force
}

# Writing headers obtained from the first file found
Get-ChildItem -Path $Location -Filter "$NameFilter.csv"
 | Select -First 1
 | Get-Content
 | Select -First 1
 | Out-File $OutputFile -Append

# Writing content for each file
Get-ChildItem -Path $Location -Filter "$NameFilter.csv"
    | Foreach {
        $_
            | Get-Content
            | Select -Skip 1
            | Out-File $OutputFile -Append
    }

El script necesita 3 parámetros de entrada:

El primero indica el lugar donde se encuentran los ficheros CSV que queremos unir,
El segundo permite indicar un filtro a aplicar para recoger los ficheros CSV objetivo,
Por último, el tercer parámetro indica dónde y cuál será el fichero resultante de la unión.

Hasta aquí muy sencillo. Los parámetros son todos de tipo String simplificando aún más los valores de entrada.

El siguiente bloque elimina el fichero resultante en caso de que exista. He añadido el parámetro -Force para evitar que esté preguntando constantemente. Esto es una elección personal, si lo quieres cambiar, adelante.

Ahora viene lo interesante, la unión de los contenidos. Para mantener la misma estructura existente en cada uno de los ficheros CSV tomo las cabeceras del primer fichero usnado mediante el comando Get-ChildItem y seleccionando el primero de todos ellos con Select -First 1.

Get-ChildItem -Path $Location -Filter "$NameFilter.csv"
 | Select -First 1
 | Get-Content
 | Select -First 1
 | Out-File $OutputFile -Append

Obtener las cabeceras sigue el mismo patron con elementos diferentes. Leo el contenido del fichero, Get-Content, selecciono la primera fila, Select -First 1 y lo escribo en el fichero de salida pasado en el tercer parámetro, Out-File.

Como puedes apreciar, no estoy haciendo ningún tipo de tratamiento de los datos por ser CSV ni de otro tipo, es decir, usando el comando Import-Csv. Como he comentado al principio del artículo, los ficheros CSV son ficheros de tipo texto y puede tratarse así al leerlo y al escribirlo.

El último bloque de código itera sobre cada contenido de cada fichero para volcar todos los datos a excepción de la primera fila. Recordad que la primera fila serán las cabeceras y no necesitamos volver a escribirla.

Get-ChildItem -Path $Location -Filter "$NameFilter.csv"
    | Foreach {
        $_
            | Get-Content
            | Select -Skip 1
            | Out-File $OutputFile -Append
    }

Como habéis visto, con 30 líneas de código, incluyendo espacios en blanco, indentaciones, etc., tenemos la unión de varios ficheros en uno sólo. Tal vez no tengáis la necesidad de hacer esto mismo pero espero que os sirva de inspiración.

El código de este artículo lo tenéis en este gist.

Feedback

Si te ha gustado este artículo no olvides clicar en el corazón o el unicornio y compartirlo con tus amigos y compañeros. Déjame tus comentarios en la parte inferior sobre lo que te ha gustado o como mejorar y si quieres que escriba acerca de otros temas mándame un mensaje directo a mi cuenta de twitter.

Créditos

La imagen de cabecera procede de Unsplash y es cortesía de Mika Baumeister.

Quick Tip - How to merge CSV files in 30 lines of code

Coding Bugs — Fri, 08 Apr 2022 09:57:32 +0000

My nickname in the networks is Coding Bugs, and I have been working as a software architect and developer from 2004. In my dashboard, you will find articles about programming languages, programming techniques, and other concepts that will help you improve.

I am back with another PowerShell article in which I show you how easy and fast it is to generate a single CSV file from many. You will find it useful when developing processes that result in a report in CSV format and you have to merge the contents of several files into one.

CSV is an acronym for Comma Separated Values (CSV) files. It is a de facto standard format that is often used for information exchange. The goal is to have a plain text file in which each row is a record, each value in the row is separated by the comma character. All rows have the same number of values, i.e. the same number of commas. See RFC 4180 for detailed information.

For the following code to work without errors, the requirement is that all the CSV files that we want to join have the same structure, i.e. the same headers and in the same order.

If you want to work with CSV files and you use Node.js, I have developed a library that simplifies getting your data using objects, arrays and dynamic filters. Download with NPM and get more information clicking this link and let me know your thoughts about it.

Once the introduction is done, let's go to the code to comment it.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location,

    [Parameter(Mandatory=$true)]
    [String] $NameFilter,

    [Parameter(Mandatory=$true)]
    [String] $OutputFile
)

If(Test-Path $OutputFile) {
    Remove-Item $OutputFile -Force
}

# Writing headers obtained from the first file found
Get-ChildItem -Path $Location -Filter "$NameFilter.csv"
 | Select -First 1
 | Get-Content
 | Select -First 1
 | Out-File $OutputFile -Append

# Writing content for each file
Get-ChildItem -Path $Location -Filter "$NameFilter.csv"
    | Foreach {
        $_
            | Get-Content
            | Select -Skip 1
            | Out-File $OutputFile -Append
    }

The script needs 3 input parameters:

The first one indicates the location where the CSV files we want to join are located,
The second one allows to indicate a filter to apply to collect the targeted CSV files,
Finally, the third parameter indicates where and what will be the file resulting from the join.

So far so simple. The parameters are all of type String simplifying even more the input values.

The next block deletes the resulting file if it exists. I have added the -Force parameter to prevent it from constantly asking. This is a personal choice, if you want to change it, go ahead.

Now comes the interesting part, the union of the contents. To maintain the same existing structure in each of the CSV files I take the headers of the first file used with the Get-ChildItem command and selecting the first of them all with Select -First 1.

Get-ChildItem -Path $Location -Filter "$NameFilter.csv"
 | Select -First 1
 | Get-Content
 | Select -First 1
 | Out-File $OutputFile -Append

Getting the headers follows the same pattern with different elements. I read the contents of the file, Get-Content, select the first row, Select -First 1 and write it to the output file passed in the third parameter, Out-File.

As you can see, I am not doing any kind of treatment of the data as CSV or otherwise, i.e. using the Import-Csv command. As I mentioned at the beginning of the article, CSV files are text files and can be treated as such when reading and writing them.

The last block of code iterates over the contents of each file to dump all the data except for the first row. Remember that the first row will be the headers and we do not need to rewrite it.

Get-ChildItem -Path $Location -Filter "$NameFilter.csv"
    | Foreach {
        $_
            | Get-Content
            | Select -Skip 1
            | Out-File $OutputFile -Append
    }

As you have seen, with 30 lines of code, including whitespace, indentations, etc., we have the union of several files into one. Maybe you don't need to do this, but I hope it will inspire you.

The code for this article can be found in this gist.

Feedback

If you liked this article, do not forget to click on the heart or the unicorn and share it with your friends and colleagues. Leave me your comments at the bottom about what you liked or how to improve and if you want me to write about other topics send me a direct message to my Twitter account.

Credits

The header image comes from Unsplash and is courtesy of Mika Baumeister.

An easy way to provide parameters in PowerShell

Coding Bugs — Mon, 04 Apr 2022 07:10:13 +0000

My nickname in the networks is Coding Bugs, and I have been working as a software architect and developer from 2004. In my dashboard, you will find articles about programming languages, programming techniques, and other concepts that will help you improve.

You already know that PowerShell is the programming language that Microsoft makes available to us for "a cross-platform task automation solution composed of a command-line shell, a scripting language and a configuration management framework".

In this article I will show you a different way to provide parameters to scripts and commands. This is a simple and easy way of declaring parameters and assigning their values that will allow you to organize your scripts so that everything makes more sense.

Standard way

If you know PowerShell you already know how to provide parameters in your calls. If you don't, just type the name of the parameter preceded by a dash, then type its value.

$ Get-ChildItem -Path C:\ -Filter *.txt 
# Returns all existing text files in C:

As you can see, the standard way is very easy and for cases where you make immediate invocations it is the best way to provide parameters.

However, imagine that you have to count the number of files of a certain type located in a specific place on your machine. In this case, we would have to repeat as many times as necessary the invocation of the above command, Get-ChildItem, providing the Filter parameter based on the requested file type.

$ Get-ChildItem -Path C:\ -Filter *.html | Measure | Select Count 
# Returns all existing HTML files in C:

$ Get-ChildItem -Path C:\ -Filter *.css | Measure | Select Count 
# Returns all existing CSS files in C:

$ Get-ChildItem -Path C:\ -Filter *.js | Measure | Select Count 
# Returns all existing JS files in C:

To save us time each time we are asked for this information we are going to generate our own script in which we add these calls. In addition, we are going to incorporate a parameter in the script to specify the location where to count each one of the HTML, CSS and JS files.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location
)

Return @{
    Html = $(Get-ChildItem -Path $Location -Filter *.html | Measure).Count
    Css = $(Get-ChildItem -Path $Location -Filter *.css | Measure).Count
    Js = $(Get-ChildItem -Path $Location -Filter *.js | Measure).Count
}

What happens if we are now asked to include more and more file types with different extensions? The answer would be to include more and more lines to our script to fulfill the request. But what if there was another simpler and more versatile way, giving our script the ability to abstract from extension types?

A hashtable for passing parameters

We will start by adding a new parameter indicating the extensions of the files we have to count. Now we will only have to iterate over these values and pass the corresponding extension to the Get-ChildItem command.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location,

    [Parameter(Mandatory=$true)]
    [String[]] $Extensions
)

Return $Extensions 
    | Foreach {
        $CurrentExtension = $_.ToLower() 
        # Transform extension to lower case
        Return @{ $_ = $(Get-ChildItem -Path $Location -Filter $CurrentExtension | Measure).Count } 
        # Return an object with the extension as the key and the count obtained as the value
}

This would be enough for our purpose but, as a programmer, we want it to be even more abstract and allow us to keep the Get-ChildItem command call cleaner, avoiding having to modify it again with new parameters.

Being a somewhat complex command line, it is better to avoid modifying it as much as possible or to make it simpler by breaking it into simpler pieces. For the sake of this article, we choose the first option.

PowerShell allows the passing of a hashtable object to provide each of the parameters we need from the command to be executed. In our case, the command is Get-ChildItem and the parameters we are using are Path and Filter.

# The hashtable variable that we will create will look like the following one
$CmdParams = @{
    Path = "."
    Filter = "*.*"
}

# And the command call is like the following, important the use of "@" character
Get-ChildItem @CmdParams

As in the previous case, we have to update our hashtable variable with the corresponding extension in each iteration of the Foreach.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location,

    [Parameter(Mandatory=$true)]
    [String[]] $Extensions
)

$CmdParams = @{
    Path = $Location
    Filter = "*.*"
}

Return $Extensions 
    | Foreach {
        $CurrentExtension = $_.ToLower() 
        # Transform extension to lower case
        $CmdParams.Filter = "*.$CurrentExtension" 
        # Set the filter to the current extension
        Return @{ $_ = $(Get-ChildItem @CmdParams | Measure).Count } 
        # Return an object with the extension as the key and the count obtained as the value
}

We have achieved what we were looking for, we have abstracted the call to the Get-ChildItem command with respect to the parameters we need to pass to it. This way, we can modify the CmdParams variable by adding, changing or removing any key/value pair based on the functional needs we have.

We can see here the second principle of the SOLID paradigm, Open-Closed Principle, which states that the code should be closed to any modification but open to extend its functionality. We can say that the purpose of the iteration over each of the extensions is to return the number of existing files in the indicated location. The Get-ChildItem command can be invoked with other parameters that will modify the number of files returned but its result will remain the same (closed to modification), therefore, our CmdParams variable allows that the files to be returned can be different depending on the parameters received (open to extension).

Imagine that we are asked for another new functionality. Now we need to count the files in the location provided and the files in the folders immediately inside, i.e. the first level.

Let me explain that the Get-ChildItem command has parameters that allow us to implement this type of requirements without the need to do any advanced engineering, we will use the Recurse parameters to establish that the search is performed in the indicated location and in all the ones below and, Depth to establish the maximum number of recursion that we need, in our case, the value is 1.

Surely you have already visualized the change to be made to the previous code. From my point of view, something very simple that will not take us more than 5 minutes between the change and the tests to verify that it is correct.

In our code we have to include the above two parameters in the CmdParams variable for it to be applied. It is a clean change, just add new elements in our hashtable without having to modify the command line where the command is located which, as we have said, is certainly complex.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location,

    [Parameter(Mandatory=$true)]
    [String[]] $Extensions
)

$CmdParams = @{
    Path = $Location
    Filter = "*.*"
    Recurse = $true
    Depth = 1
}

Return $Extensions 
    | Foreach {
        $CurrentExtension = $_.ToLower() # Transform extension to lower case
        $CmdParams.Filter = "*.$CurrentExtension" # Set the filter to the current extension
        Return @{ $_ = $(Get-ChildItem @CmdParams | Measure).Count } # Return an object with the extension as the key and the count obtained as the value
}

Summarizing

Passing parameters to PowerShell commands and scripts is simple. We can use the standard way for command calls or simple scripts. And, also, we can use more advanced techniques that allow us to have a cleaner code and implement modifications in a simpler way.

Using hashtables is an easy way to visualize the parameter values of the commands we invoke. In addition, it structures our code making it more readable for others or even for ourselves after a while.

The code for this article can be found in this gist.

Feedback

Credits

The header image comes from Unsplash and is courtesy of Markus Spiske.

Una forma fácil de pasar parámetros en tus scripts de PowerShell

Coding Bugs — Mon, 04 Apr 2022 07:10:05 +0000

Mi apodo en las redes es Coding Bugs y llevo desde el año 2004 trabajando como desarrollador y arquitecto de software. En mi dashboard encontrarás artículos con información sobre lenguajes de programación, técnicas de programación y otros conceptos que te ayudarán a mejorar.

Ya sabéis que PowerShell es el lenguaje de programación que Microsoft pone a nuestra disposición para la "automatización de tareas multiplataforma compuesta por un shell de línea de comandos, un lenguaje de scripting y un marco de gestión de la configuración".

En este artículo mostraré una manera diferente de proporcionar valores a los parámetros de comandos y scripts. Esta es una forma sencilla y simple de declarar parámetros y asignar sus valores que os permitirá organizar vuestros scripts de forma que todo tenga más sentido.

Forma estándar

Si conoces PowerShell ya sabes como proporcionar parámetros en tus llamadas. Si no lo conoces, simplemente, indica el nombre del parámetro antecedido por un guion y, a continuación, escribe su valor.

$ Get-ChildItem -Path C:\ -Filter *.txt 
# Devuelve todos los ficheros de texto existentes en C:\

Como puedes observar, la forma estándar es muy fácil y para casos en los que hagas invocaciones inmediatas es la mejor manera de proporcionar parámetros.

Sin embargo, imagina que tienes que contar el número de ficheros de un determinado tipo ubicados en una localización específica de tu máquina. En este caso, tendríamos que repetir tantas veces como fuera necesario la invocación al comando anterior, Get-ChildItem, proporcionando el parámetro Filter en base al tipo de fichero solicitado.

$ Get-ChildItem -Path C:\ -Filter *.html | Measure | Select Count 
# Devuelve todos los ficheros HTML existentes en C:\

$ Get-ChildItem -Path C:\ -Filter *.css | Measure | Select Count 
# Devuelve todos los ficheros CSS existentes en C:\

$ Get-ChildItem -Path C:\ -Filter *.js | Measure | Select Count 
# Devuelve todos los ficheros JavaScript existentes en C:\

Para ahorrarnos tiempo cada vez que nos soliciten esa información vamos a generar un script propio en el que añadamos estas llamadas. Además, vamos a incorporar un parámetro en el script para especificar la ubicación concreta donde contar cada uno de los ficheros HTML, CSS y JS que hay.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location
)

Return @{
    Html = $(Get-ChildItem -Path $Location -Filter *.html | Measure).Count
    Css = $(Get-ChildItem -Path $Location -Filter *.css | Measure).Count
    Js = $(Get-ChildItem -Path $Location -Filter *.js | Measure).Count
}

¿Qué sucede si ahora nos piden incluir más y más tipos de fichero con diferentes extensiones? La respuesta sería incluir más y más líneas a nuestro script para cumplir con lo que nos solicitan. Pero, ¿y si hubiera otra forma más sencilla y más versatil dotando a nuestro script de la capacidad de abstraerse de los tipos de extensión?

Una hashtable para pasar parámetros

Empezaremos por añadir un nuevo parámetro donde se indiquen las extensiones de los ficheros que tenemos que contar. Ahora sólo tendremos que iterar sobre estos valores y pasar la extensión correspondiente al comando Get-ChildItem.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location,

    [Parameter(Mandatory=$true)]
    [String[]] $Extensions
)

Return $Extensions 
    | Foreach {
        $CurrentExtension = $_.ToLower() 
        # Transformar la extensión a minúsculas
        Return @{ $_ = $(Get-ChildItem -Path $Location -Filter $CurrentExtension | Measure).Count } 
        # Devuelve un objeto con la extensión como clave y el recuento obtenido como valor
}

Con esto sería suficiente para nuestro objetivo pero, como programador que somos, queremos que sea aún más abstracto y nos permita mantener la llamada al comando Get-ChildItem más limpia, evitando tener que volver a modificarla con nuevos parámetros.

Al ser una línea de comandos un poco compleja es mejor evitar su modificación al máximo posible o hacerla más simple diviéndola en trozos más simples. Por el bien de este artículo, elegimos la primera opción.

PowerShell permite el paso de un objeto hashtable para proporcionar cada uno de los parámetros que necesitamos del comando a ejecutar. En nuestro caso, el comando es Get-ChildItem y los parámetros que estamos utilizando son Path y Filter.

# La variable hashtable que crearemos será como la siguiente
$CmdParams = @{
    Path = "."
    Filter = "*.*"
}

# Y la llamada al comando es como la siguiente, importante el uso de "@" en el paso de nuestro hashtable
Get-ChildItem @CmdParams

Igual que en el caso anterior, tenemos que actualizar nuestra variable hashtable con la extensión correspondiente en cada iteración del Foreach.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location,

    [Parameter(Mandatory=$true)]
    [String[]] $Extensions
)

$CmdParams = @{
    Path = $Location
    Filter = "*.*"
}

Return $Extensions 
    | Foreach {
        $CurrentExtension = $_.ToLower() 
        # Transformar la extensión a minúsculas
        $CmdParams.Filter = "*.$CurrentExtension" 
        # Establecer el filtro en la extensión actual
        Return @{ $_ = $(Get-ChildItem @CmdParams | Measure).Count } 
        # Devuelve un objeto con la extensión como clave y el recuento obtenido como valor
}

Ya hemos conseguido lo que buscabamos, hemos abstraido la llamada al comando Get-ChildItem con respecto a los parámetros que necesitamos pasarle. De esta forma, podemos modificar la variable CmdParams añadiendo, cambiando o quitando cualquier par clave-valor en base a las necesidades funcionales que tengamos.

Podemos ver aquí el segundo principio del paradigma SOLID, Open Closed Principle, en el que se indica que el código debe ser cerrado a cualquier modificación pero abierto para extender su funcionalidad. Podemos decir que el propósito de la iteración sobre cada una de las extensiones es retornar el número de ficheros existentes en la ubicación indicada. El comando Get-ChildItem puede ser invocado con otros parámetros que modificará el número de ficheros que retorne pero su resultado seguirá siendo el mismo (cerrado a modificación), por tanto, nuestra variable CmdParams permite que los ficheros a devolver pueda ser diferente dependiendo de los parámetros que reciba (abierto a extensión).

Imagina que nos solicitan otra nueva funcionalidad. Ahora se necesita contabilizar los ficheros de la ubicación proporcionada y los ficheros de las carpetas que se encuentran inmediatamente dentro, es decir, el primer nivel.

Déjame explicarte que el comando Get-ChildItem dispone de parámetros que nos permiten implementar este tipo de requisitos sin necesidad de hacer ningún tipo de ingeniería avanzada, usaremos los parámetros Recurse para establecer que se realice la búsqueda en la localización indicada y en todas las que hay por debajo y, Depth para establecer el máximo número de recursividad que necesatimos, en nuestro caso, el valor es de 1.

Seguro que ya has visualizado el cambio que hay que realizar al código anterior. Desde mi punto de vista, algo muy sencillo que no nos llevará más de 5 minutos entre el cambio y las pruebas para verificar que es correcto.

En nuestro código tenemos que incluir los dos parámetros anteriores en la variable CmdParams para que se aplique. Es un cambio limpio, sólo añadir nuevos elementos en nuestro hashtable sin tener que modificar la línea de comandos donde se encuentra el comando que, como hemos dicho, es ciertamente compleja.

param(
    [Parameter(Mandatory=$true)]
    [String] $Location,

    [Parameter(Mandatory=$true)]
    [String[]] $Extensions
)

$CmdParams = @{
    Path = $Location
    Filter = "*.*"
    Recurse = $true
    Depth = 1
}

Return $Extensions 
    | Foreach {
        $CurrentExtension = $_.ToLower() 
        # Transformar la extensión a minúsculas
        $CmdParams.Filter = "*.$CurrentExtension" 
        # Establecer el filtro en la extensión actual
        Return @{ $_ = $(Get-ChildItem @CmdParams | Measure).Count } 
        # Devuelve un objeto con la extensión como clave y el recuento obtenido como valor
}

Resumiendo

El paso de parámetros en comandos y/o scripts en PowerShelles sencillo. Podemos utilizar la forma estándar para llamadas a comandos o en scripts sencillos. Y, también, podemos usar técnicas más avanzadas que nos permitan tener un código más limpio e implementar modificaciones de forma más sencilla.

El uso de hashtables es una forma fácil de visualizar los valores de los parámetros de los comandos que invocamos. Además, estructura nuestro código haciendo que sea más legible para los demás o, incluso, para nosotros mismos despues de pasado un tiempo.

El código de este artículo lo tenéis en este gist.

Feedback

Créditos

La imagen de cabecera procede de Unsplash y es cortesía de Markus Spiske

¿Sabías que Microsoft Forms tiene la funcionalidad de borrador?

Coding Bugs — Mon, 21 Mar 2022 09:48:43 +0000

Mi apodo en las redes es Coding Bugs y llevo más de 15 años trabajando como desarrollador y arquitecto de software. En mi dashboard encontrarás artículos con información sobre lenguajes de programación, técnicas de programación y otros conceptos que te ayudarán a mejorar.

Para los que no conozcáis Microsoft Forms, decir que es una herramienta online para la creación de formularios y/o encuestas ubicada dentro de Office 365.

Microsoft Forms tiene muchas y muy buenas funcionalidades pero, hay una que no está, y que los clientes suelen pedir, se trata de poder responder a las preguntas en diferentes momentos del día, es decir, poder tener un estado de borrador.

En el caso de las encuestas con muchas preguntas, muchas secciones y ramas, los usuarios pueden encontrarse perdidos después de responder a varias de ellas. Es en este punto donde poder guardar la encuesta actual para terminarla en otro momento es muy útil.

Sin embargo, he dicho que Microsoft Forms no tiene este tipo de funcionalidad o, tal vez, sí.

Sí lo hace y tiene un mecanismo que la mayoría de los desarrolladores web conocen. El funcionamiento de Microsoft Forms es muy sencillo, si un usuario abre la encuesta, rellena varias respuestas y luego cierra el navegador web, es normal que haya perdido las respuestas dadas. Sin embargo, si vuelve a abrir el navegador web y va a la encuesta, verá las preguntas con las respuestas dadas.

Podríamos pensar que Microsoft tiene un espacio en la nube donde almacena todas las respuestas de todos los usuarios que han dejado una media encuesta. No creo que sea el caso por las implicaciones en términos de dinero y energía a gastar.

Pero, ¿hay alguna otra forma de conseguirlo? Sí, la hay y se trata de utilizar el localStorage del navegador en uso. Tan simple como eso, si hay información para la encuesta actual en su navegador, lo utilizará para establecer las respuestas que ha dado.

Espero que esta información te sea útil.

Feedback

Improve how to provide parameters in your PowerShell scripts

Coding Bugs — Sun, 13 Feb 2022 09:23:59 +0000

My nickname in the networks is Coding Bugs, and I have been working as a software developer and architect for more than 15 years. In my dashboard, you will find articles about programming languages, programming techniques, and other concepts that will help you improve.

Microsoft describes PowerShell as "a cross-platform task automation solution composed of a command-line shell, a scripting language and a configuration management framework". In other words, it is a solution for creating scripts that perform repetitive tasks, for example, creating an account in the system when an employee joins the company, or deleting documents that are more than 5 years old in a folder. Therefore, it is one more tool that we have at our disposal to automate recurring tasks.

In this article I will show how to use general or global configurations for our scripts. From an ad hoc configuration in which to set fixed values, to the reading of an external configuration file with a specific format such as JSON, XML or CSV. The goal is to make the call to the PowerShell scripts as simple as possible and avoid any type of error. Ultimately, the person that will finally execute the processes will have no knowledge of the script's own code and, most likely, will not remember the value of the parameters to pass after a few weeks. The easier it is, the better for everyone.

Ad hoc

Starting with an approach in which developing code based on parameters will allow us to have a set of scripts that can be used in other implementations simply by indicating one value or another. An example of a generic script could be the downloading of information from the Internet. It will comprise 2 parameters:

the first one will be the URL address where to obtain the information and,
the second one where we want to save it on disk.

# Download-Data.ps1

param(
    [Parameter(Mandatory=$true)]
    [String] $Url,
    [Parameter(Mandatory=$true)]
    [String] $FilePath
)

# Save data to the file path specified and returns the response
Invoke-WebRequest -Uri $Url -OutFile $FilePath

# For downloading my Github profile to your machine use the following line
# .\Download-Data.ps1 -Url https://github.com/codbugs -FilePath CodingBugs_Github_Profile.html

In this way, we will be able to invoke this process as many times as we want and save the information of the URL addresses that we pass to it. The next logical step is to develop code specific to the needs or requirements we have. In this case, we will say that we want to save a version of a web page every day. Following the above example, we need to create a new script in which we always use the same URL and generate a folder based on the current day. The script will save the web page of my GitHub profile in a folder named equal to the current year, month and day.

# Download-MyGithubProfile.ps1

# My GitHub profile page
$MyGitHubProfileUrl = "https://github.com/codbugs"

# Folder generation based on the current date
$FolderName = Get-Date -Format "yyyyMMdd"
$Folder = New-Item -Path $FolderName -ItemType Directory -Force

# File name
$FileName = "CodingBugsProfile.html"

# Invoking the script for downloading my GitHub profile
.\Download-Data.ps1 -Url $MyGitHubProfileUrl -FilePath "$FolderName\$FileName"

Therefore, the need has been covered by generating 2 scripts: the first one with a generic implementation and, the second one, with a specific implementation that does not require the operator to have knowledge of the parameters to be passed to the script.

In what situations can we use a scripting model like this? I find it very useful when I have several different environments and I have to deploy the same elements in each of them. In this case, I create a generic deployment script with the parameters I need. Then, I create a new script for each environment with the environment-specific parameters. When I have to deploy in one environment or another I just run the corresponding script and I am sure that the parameter information is correct.

Configuration file

Using configuration files is a simple way to abstract the code of those values necessary for its execution. Instead of passing all the parameters we can incorporate them in a text file and read them from the script itself.

In this case, we will take advantage of the existing commands in PowerShell to use the file format we are most comfortable with: JSON, CSV or XML. All of them have a quick way to read files and access their information.

We start from the following file JSON:

// coding_bugs_configuration.json
{
    "version": "1.0",
    "author": {
        "name": "Coding Bugs",
        "email": "coding.bugs@outlook.com",
        "github": "https://github.com/codbugs"
    },
    "gists": [
        { "name": "README.md", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/README.md" },
        { "name": "coding_bugs_configuration.csv", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.csv" },
        { "name": "coding_bugs_configuration.json", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.json" },
        { "name": "coding_bugs_configuration.xml", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.xml" },
        { "name": "Download-CsvGistFiles.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-CsvGistFiles.ps1" },
        { "name": "Download-Data.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-Data.ps1" },
        { "name": "Download-JsonGistFiles.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-JsonGistFiles.ps1" },
        { "name": "Download-MyGitHubProfile.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-MyGitHubProfile.ps1" },
        { "name": "Download-XmlGistFiles.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-XmlGistFiles.ps1" }
    ]
}

To get the existing information in the configuration file we have to use the ConvertFrom-Json command that transforms a JSON code into a native PowerShell object. The goal is to use a simple and intuitive notation to read the data. In the following script, we use the existing information to download each of the gist files in this article:

# Download-JsonGistFiles.ps1

param(
    [Parameter(Mandatory=$true)]
    [String]  $ConfigurationFilePath
)

# Reading the configuration file
$Configuration = Get-Content $ConfigurationFilePath | ConvertFrom-Json 

# Creating the folder to download de gists
$FolderName = $Configuration.author.name
$Folder = New-Item -Path $FolderName -Type Directory -Force

# Downloading the gists files
$Configuration.gists | Foreach { .\Download-Data.ps1 -Url $_.url -FilePath "$FolderName\$($_.name)" }

# .\Download-JsonGistFiles.ps1 -ConfigurationFilePath coding_bugs_configuration.json

If we want to have an XML file because it is easier for us, no problem. The resulting code is quite similar, we only have to modify how to read the configuration file and how to iterate through each of the gist nodes elements.

<!-- coding_bugs_configuration.xml -->
<xml>
    <version>1.0</version>
    <author>
        <name>Coding Bugs</name>
        <email>coding.bugs@outlook.com</email>
        <github>https://github.com/codbugs</github>
    </author>
    <gists>
        <gist>
            <name>README.md</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/README.md</url>
        </gist>
        <gist>
            <name>coding_bugs_configuration.csv</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.csv</url>
        </gist>
        <gist>
            <name>coding_bugs_configuration.json</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.json</url>
        </gist>
        <gist>
            <name>coding_bugs_configuration.xml</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.xml</url>
        </gist>
        <gist>
            <name>Download-CsvGistFiles.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-CsvGistFiles.ps1</url>
        </gist>
        <gist>
            <name>Download-Data.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-Data.ps1</url>
        </gist>
        <gist>
            <name>Download-JsonGistFiles.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-JsonGistFiles.ps1</url>
        </gist>
        <gist>
            <name>Download-MyGitHubProfile.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-MyGitHubProfile.ps1</url>
        </gist>
        <gist>
            <name>Download-XmlGistFiles.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-XmlGistFiles.ps1</url>
        </gist>
    </gists>
</xml>

param(
    [Parameter(Mandatory=$true)]
    [String] $ConfigurationFilePath
)

# Reading the configuration file
[XML]$Configuration = Get-Content $ConfigurationFilePath

# Creating the folder to download de gists
$FolderName = $Configuration.xml.author.name
$Folder = New-Item -Path $FolderName -Type Directory -Force

# Downloading the gists files
$Configuration.xml.gists.gist | Foreach { .\Download-Data.ps1 -Url $_.url -FilePath "$FolderName\$($_.name)" }

# .\Download-XmlGistFiles.ps1 -ConfigurationFilePath coding_bugs_configuration.xml

Finally, if we want to have a CSV file we have to modify how to read the configuration file and how to iterate through each of the rows.

"version";"author_name";"author_email";"author_github";"gist_name";"gist_url"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"README.md";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/README.md"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"coding_bugs_configuration.csv";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.csv"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"coding_bugs_configuration.json";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.json"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"coding_bugs_configuration.xml";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.xml"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-CsvGistFiles.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-CsvGistFiles.ps1"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-Data.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-Data.ps1"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-JsonGistFiles.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-JsonGistFiles.ps1"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-MyGitHubProfile.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-MyGitHubProfile.ps1"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-XmlGistFiles.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-XmlGistFiles.ps1"

param(
    [Parameter(Mandatory=$true)]
    [String] $ConfigurationFilePath
) 

# Reading the configuration file
$Configuration = Get-Content $ConfigurationFilePath
$Configuration = Import-Csv -Path $ConfigurationFilePath -Delimiter ';'

$Configuration | Foreach  {
    # Creating the folder to download de gists
    $FolderName = $_.author_name
    $Folder = New-Item -Path $FolderName -Type Directory -Force

    # Downloading the gists files
    .\Download-Data.ps1 -Url $_.gist_url -FilePath "$FolderName\$($_.gist_name)"
}

# .\Download-CsvGistFiles.ps1 -ConfigurationFilePath coding_bugs_configuration.csv

Summarizing

When providing the values to the parameters of our PowerShell scripts, we can follow 2 strategies to facilitate the work of its execution:

Generate a generic script that can be used in any situation we need and a set of scripts with the parameters set directly in code and invoking the first one,
Enter a configuration file with all the necessary parameters for the script.

You may be imagining a third possibility . Indeed, it is the combination of the two previous ones, that is to say, to have a generic script with an implementation that covers the execution of the process itself by means of a configuration file, and a set of scripts specifying the concrete configuration file to use. In this way, we facilitate much more the actions to be taken in the execution or modification of our scripts.

The code for this article can be found in this [gist].(https://gist.github.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0).

Feedback

Credits

The header image comes from Unsplash and is courtesy of Markus Spiske.

Mejora el paso de parámetros en tus scripts de PowerShell

Coding Bugs — Sun, 13 Feb 2022 09:23:48 +0000

Mi apodo en las redes es Coding Bugs y llevo más de 15 años trabajando como desarrollador y arquitecto de software. En mi dashboard encontrarás artículos con información sobre lenguajes de programación, técnicas de programación y otros conceptos que te ayudarán a mejorar.

El propio Microsoft describe PowerShell como "una solución de automatización de tareas multiplataforma compuesta por un shell de línea de comandos, un lenguaje de scripting y un marco de gestión de la configuración". En otras palabras, es una solución para la creación de scripts que realicen tareas repetitivas, por ejemplo, la creación de una cuenta en el sistema cuando un empleado se incorpora en la compañía, o el borrado de documentos que tienen más de 5 años de antigüedad en una carpeta. Por tanto, es una herramienta más que tenemos a nuestra disposición para automatizar tareas recurrentes.

En este artículo mostraré como utilizar configuraciones de ámbito general o global para nuestros scripts. Desde una configuración ad hoc en la que establecer de forma fija los valores, hasta la lectura de un fichero externo de configuración con un formato específico como JSON, XML o CSV. El objetivo es hacer la llamada a los scripts de PowerShell lo más sencilla posible y evitar cualquier tipo de error. En definitiva, la persona o automatismo que finalmente ejecutará los procesos no tendrá conocimiento del código propio del script y, seguramente, tampoco recordará el valor de los parámetros a pasar después de unas semanas. Cuanto más fácil sea, mejor para todos.

Ad hoc

Comenzando con un enfoque en el que desarrollar código basado en parámetros, nos va a permitir tener una batería de scripts que podrán ser utilizados en otras implementaciones simplemente indicando un valor u otro. Un ejemplo de un script genérico puede ser la descarga de información procedente de Internet. Este comprenderá 2 parámetros:

el primero será la dirección URL donde obtener la información y,
el segundo dónde queremos guardarla en disco.

# Download-Data.ps1

param(
    [Parameter(Mandatory=$true)]
    [String] $Url,
    [Parameter(Mandatory=$true)]
    [String] $FilePath
)

# Save data to the file path specified and returns the response
Invoke-WebRequest -Uri $Url -OutFile $FilePath

# For downloading my Github profile to your machine use the following line
# .\Download-Data.ps1 -Url https://github.com/codbugs -FilePath CodingBugs_Github_Profile.html

De esta forma, podremos invocar este proceso tantas veces como queramos y guardar la información de las direcciones URL que le pasemos. El siguiente paso lógico será desarrollar código específico para las necesidades o requisitos que tengamos. En este caso, diremos que queremos guardar una versión de una página web cada día. Siguiendo el ejemplo anterior, tenemos que crear un nuevo script en el que utilizar siempre la misma dirección URL y generar una carpeta en base al día actual. El script guardará la página web de mi perfil en GitHub en una carpeta con nombre igual al año, mes y día actual.

# Download-MyGithubProfile.ps1

# My GitHub profile page
$MyGitHubProfileUrl = "https://github.com/codbugs"

# Folder generation based on the current date
$FolderName = Get-Date -Format "yyyyMMdd"
$Folder = New-Item -Path $FolderName -ItemType Directory -Force

# File name
$FileName = "CodingBugsProfile.html"

# Invoking the script for downloading my GitHub profile
.\Download-Data.ps1 -Url $MyGitHubProfileUrl -FilePath "$FolderName\$FileName"

Por lo tanto, la necesidad se ha cubierto generando 2 scripts: el primero con una implementación genérica con la posibilidad de ser utilizado en el caso que haya otro requisito parecido y, el segundo, con una implementación específica que no requiere que el operador tenga conocimiento de los parámetros que debe pasar al script.

¿En qué situaciones podemos utilizar un modelo de scripts como este? A mí me resulta muy útil cuando tengo varios entornos diferentes y tengo que desplegar los mismos elementos en cada uno de ellos. En este caso, creo un script de despliegue genérico con los parámetros que necesito. Después, creo un nuevo script por cada entorno con los parámetros específicos de estos. Cuando tenga que desplegar en un entorno u otro sólo tengo que ejecutar el script correspondiente y estoy seguro que la información de los parámetros es la correcta.

Fichero de configuración

Usar ficheros de configuración es una forma sencilla de abstraer el código de aquellos valores necesarios para su ejecución. En vez de pasar todos los parámetros podemos incorporarlos en un fichero de texto y leerlos desde el propio script.

En este caso, aprovecharemos los comandos existentes en PowerShell para utilizar el formato de fichero con el que nos sintamos más a gusto: JSON, CSV o XML. Todos ellos tienen una forma rápida de leer ficheros y acceder a su información.

Partimos del siguiente fichero JSON:

// coding_bugs_configuration.json
{
    "version": "1.0",
    "author": {
        "name": "Coding Bugs",
        "email": "coding.bugs@outlook.com",
        "github": "https://github.com/codbugs"
    },
    "gists": [
        { "name": "README.md", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/README.md" },
        { "name": "coding_bugs_configuration.csv", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.csv" },
        { "name": "coding_bugs_configuration.json", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.json" },
        { "name": "coding_bugs_configuration.xml", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.xml" },
        { "name": "Download-CsvGistFiles.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-CsvGistFiles.ps1" },
        { "name": "Download-Data.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-Data.ps1" },
        { "name": "Download-JsonGistFiles.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-JsonGistFiles.ps1" },
        { "name": "Download-MyGitHubProfile.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-MyGitHubProfile.ps1" },
        { "name": "Download-XmlGistFiles.ps1", "url": "https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-XmlGistFiles.ps1" }
    ]
}

Para obtener la información existente en él tenemos que usar el comando ConvertFrom-Json que transforma un código JSON en un objeto nativo de PowerShell. El objetivo es utilizar una notación sencilla e intuitiva para leer los datos. En el siguiente script, utilizamos la información existente para descargarnos cada uno de los gists de este artículo:

# Download-JsonGistFiles.ps1

param(
    [Parameter(Mandatory=$true)]
    [String]  $ConfigurationFilePath
)

# Reading the configuration file
$Configuration = Get-Content $ConfigurationFilePath | ConvertFrom-Json 

# Creating the folder to download de gists
$FolderName = $Configuration.author.name
$Folder = New-Item -Path $FolderName -Type Directory -Force

# Downloading the gists files
$Configuration.gists | Foreach { .\Download-Data.ps1 -Url $_.url -FilePath "$FolderName\$($_.name)" }

# .\Download-JsonGistFiles.ps1 -ConfigurationFilePath coding_bugs_configuration.json

Si queremos tener un fichero XML porque nos resulta más sencillo, no hay problema. El código resultante es bastante similar, sólo tenemos que modificar cómo leer el fichero de configuración y cómo iterar por cada uno de los elementos gists.

<!-- coding_bugs_configuration.xml -->
<xml>
    <version>1.0</version>
    <author>
        <name>Coding Bugs</name>
        <email>coding.bugs@outlook.com</email>
        <github>https://github.com/codbugs</github>
    </author>
    <gists>
        <gist>
            <name>README.md</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/README.md</url>
        </gist>
        <gist>
            <name>coding_bugs_configuration.csv</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.csv</url>
        </gist>
        <gist>
            <name>coding_bugs_configuration.json</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.json</url>
        </gist>
        <gist>
            <name>coding_bugs_configuration.xml</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.xml</url>
        </gist>
        <gist>
            <name>Download-CsvGistFiles.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-CsvGistFiles.ps1</url>
        </gist>
        <gist>
            <name>Download-Data.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-Data.ps1</url>
        </gist>
        <gist>
            <name>Download-JsonGistFiles.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-JsonGistFiles.ps1</url>
        </gist>
        <gist>
            <name>Download-MyGitHubProfile.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-MyGitHubProfile.ps1</url>
        </gist>
        <gist>
            <name>Download-XmlGistFiles.ps1</name>
            <url>https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-XmlGistFiles.ps1</url>
        </gist>
    </gists>
</xml>

param(
    [Parameter(Mandatory=$true)]
    [String] $ConfigurationFilePath
)

# Reading the configuration file
[XML]$Configuration = Get-Content  $ConfigurationFilePath

# Creating the folder to download de gists
$FolderName = $Configuration.xml.author.name
$Folder = New-Item -Path $FolderName -Type Directory -Force

# Downloading the gists files
$Configuration.xml.gists.gist | Foreach { .\Download-Data.ps1 -Url $_.url -FilePath "$FolderName\$($_.name)" }

# .\Download-XmlGistFiles.ps1 -ConfigurationFilePath coding_bugs_configuration.xml

Por último, si queremos tener un fichero CSV tenemos que modificar cómo leer el fichero de configuración y cómo iterar por cada una de las filas.

"version";"author_name";"author_email";"author_github";"gist_name";"gist_url"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"README.md";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/README.md"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"coding_bugs_configuration.csv";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.csv"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"coding_bugs_configuration.json";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.json"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"coding_bugs_configuration.xml";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/coding_bugs_configuration.xml"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-CsvGistFiles.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-CsvGistFiles.ps1"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-Data.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-Data.ps1"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-JsonGistFiles.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-JsonGistFiles.ps1"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-MyGitHubProfile.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-MyGitHubProfile.ps1"
"1.0";"Coding Bugs";"coding.bugs@outlook.com";"https://github.com/codbugs";"Download-XmlGistFiles.ps1";"https://gist.githubusercontent.com/codbugs/3e3abe4c7709e992c819327cb0b9c0c0/raw/67b1a5e520d0ebaac8c678a43b9dda5638a147e1/Download-XmlGistFiles.ps1"

param(
    [Parameter(Mandatory=$true)]
    [String] $ConfigurationFilePath
) 

# Reading the configuration file
$Configuration = Get-Content $ConfigurationFilePath
$Configuration = Import-Csv -Path $ConfigurationFilePath -Delimiter ';'

$Configuration | Foreach  {
    # Creating the folder to download de gists
    $FolderName = $_.author_name
    $Folder = New-Item -Path $FolderName -Type Directory -Force

    # Downloading the gists files
    .\Download-Data.ps1 -Url $_.gist_url -FilePath "$FolderName\$($_.gist_name)"
}

# .\Download-CsvGistFiles.ps1 -ConfigurationFilePath coding_bugs_configuration.csv

Resumiendo

A la hora de proporcionar los valores a los parámetros de nuestros scripts en PowerShell, podemos seguir 2 estrategias que nos faciliten la labor de su ejecución:

Generar un script genérico que nos sirva en cualquier situación que necesitemos y un conjunto de scripts con los parámetros establecidos directamente en código e invocando al primero,
Introducir un fichero de configuración con todos los parámetros necesarios para el script.

Os estaréis imaginando en una tercera posibilidad . Efectivamente, se trata de la combinación de las dos anteriores, es decir, tener un script genérico con una implementación que cubra la ejecución del propio proceso mediante un fichero de configuración, y un conjunto de scripts especificando el fichero de configuración concreto a utilizar. De esta forma, facilitamos mucho más las acciones que haya que tomar en la ejecución o modificación de nuestros scritps.

El código de este artículo lo tenéis en este gist.

Feedback

Créditos

La imagen de cabecera procede de Unsplash y es cortesía de Markus Spiske

A privacy-based collaboration model with Office 365

Coding Bugs — Wed, 26 Jan 2022 07:42:53 +0000

My nickname in the networks is Coding Bugs, and I have been working as a software developer and architect for more than 15 years. In my dashboard, you will find articles about programming languages, programming techniques, and other concepts that will help you improve.

Collaboration models allow people to perform different tasks to achieve a common goal. In the case of the tools available in Office 365, digital collaboration models establish how employees and workers should perform their tasks to achieve a certain business goal: selling a certain number of units of a product, training a specific department in the use of a tool, executing the presentation of the company's results, etc.

In this article I show a collaboration model based on the privacy of the content being worked on. From a private point of view, where a small and specific set of employees work together and the contents are not visible to the rest of the colleagues, to a way in which all workers can consume any kind of information and enrich it with more contents.

The sense of privacy is established on the basis of who can access information and documents and who cannot. For example, a company's financial results are worked on privately within the scope of, possibly, the finance department. The employees of this department are the only ones who can access the document and make changes. However, as soon as the head of the department determines that the document has been finalized, it is published to the company's employees. The privacy of the document has changed and its consumption is no longer as restrictive as it was previously. In the event that the document is exposed so that anyone can consult it, the privacy changes again and it has no privacy at all.

With this definition of privacy we determine 4 areas of privacy in the world of work:

Personal: the information to be managed belongs exclusively to the employee,
Team: the information to be managed belongs to the team members. Its consumption can only be done by the team members as well as the generation of new information or documentation. The rest of the company's employees will have no knowledge of the existence of the team or the information it handles,
Portal: the information to be handled belongs exclusively to the portal members. The consumption of the information is done by any employee of the company. However, the generation of new information is the responsibility of the portal members. Company employees will be able to search and consume existing information in any portal,
Company: the information to be managed belongs to all employees. The consumption of information and the generation of new information can be done by any employee.

Office 365 is the set of tools and cloud services that Microsoft makes available to companies to manage company tasks. Specifically, for document management and collaboration between employees we have Microsoft Teams, SharePoint Online, Yammer, and OneDrive for Business. The features of each of these tools make them ideal for covering the above privacy areas.

Personal security area

As mentioned above, this area of security is the most restrictive of all. Following its definition, we must provide each employee with a secure space in which they can manage the documents they work on and to which only they have access.

The most suitable tool is OneDrive for Business. Thanks to this, each employee has a private space in the cloud where to store and work with their own documentation. It can be considered as a local folder but with many more features to be discussed in another article.

Team security area

This area would be the next one with a lower restriction than the previous one. In terms of its definition, we can consider it an extension of Personal security area but for several employees, that is, to provide a secure space for a group of employees in which they can manage the documents they work on.

The most suitable tool is Microsoft Teams. When creating a team in Microsoft Teams, a shared space is created for the team members in which only they themselves can work. It can be seen as a shared network folder specifically for a group of employees. However, this space has many more features to help team members communicate. An example of this is the ability to have a persistent chat.

Some examples of spaces with Team security scope are: project spaces, work groups, departmental spaces, training spaces, etc.

Portal security area

This area is an extension of the previous one because it allows exposing team information to the rest of the company's employees. In other words, we divide the workspace into two parts: a private part where team members can work securely without anyone outside the team being aware of the information contained; a public part where any employee can consume the information that the team wishes to publish.

For this purpose, SharePoint Online is the most suitable tool. Due to its nature for document and web content management, it is ideal for publishing content and exposing it through existing web components configured on its pages. We consider these elements as the public part but, for the private part, we can also create and configure its elements so that team members are the only ones to access and collaborate.

Note that Microsoft Teams has a SharePoint Online site to manage its document content.

Some examples of spaces with Portal security scope are: departmental or area spaces, general training spaces, human resources spaces, business knowledge spaces, etc.

Enterprise security area

Finally, this security scope is the least restrictive. Existing content is created by any employee of the organization and can be expanded with further information such as comments, discussions, questions, etc.

Yammer is the tool whose features are appropriate to meet the above definition. In Yammer you can create open communities where any employee can subscribe and receive notifications of new published content. Or, you can simply search for any relevant content and find related communities, conversations, discussions or questions. If you want to add more information or ask a specific question, you can do so without belonging to that particular community.

Some examples of spaces with Enterprise security scope are: knowledge communities, training communities, FAQ communities, welcome communities, etc.

To wrap up

The exercise carried out in this article establishes some rules for the use of Office 365 tools based on the privacy of the information and who manages it. We can make other classifications based on other premises and even suggest other tools for the security areas defined here. However, in my view, this is a good classification and a starting point for more complex models.

Feedback

Credits

The header image comes from Unsplash and is courtesy of Kaleidico.

Un modelo de colaboración basado en la privacidad con Office 365

Coding Bugs — Wed, 26 Jan 2022 07:42:45 +0000

Mi apodo en las redes es Coding Bugs y llevo más de 15 años trabajando como desarrollador y arquitecto de software. En mi dashboard encontrarás artículos con nformación sobre lenguajes de programación, técnicas de programación y otros conceptos que te ayudarán a mejorar.

Los modelos de colaboración permiten que las personas realicen tareas diferentes para conseguir un objetivo común. En el caso de las herramientas disponibles en Office 365, los modelos de colaboración digitales establecen cómo los empleados y trabajadores deberán realizar sus tareas para un conseguir un determinado objetivo empresarial: conseguir vender un número determinado de unidades de un producto, la formación de un departamento concreto en el uso de una herramienta, la ejecución de la presentación de los resultados de la compañía, etc.

En este artículo muestro un modelo de colaboración basado en la privacidad de los contenidos que se trabajan. Desde un punto de vista privado, donde un conjunto pequeño y concreto de empleados trabajan de manera conjunta y los contenidos no son visible para el resto de compañeros, hasta una forma en la que todos los trabajadores pueden consumir cualquier tipo de información y enriquecerla con más contenidos.

El sentido de la privacidad se establece en base a quién puede acceder a la información y los documentos y quien no. Por ejemplo, los resultados económicos de una compañía se trabajan de manera privada dentro del ámbito, posiblemente, del departamento financiero. Los empleados de este departamento serán los únicos que podrán acceder al documento y realizar modificaciones. Sin embargo, en el momento que el responsable del departamento determina que ese documento está finalizado, se procede con su publicación a los empleados de la compañía. La privacidad del documento ha cambiado y su consumo deja de ser tan restrictivo como era anteriormente. En el caso que el documento se exponga para que cualquier persona pueda consultarlo, la privacidad vuelve a cambiar y pasa a no tener ningún tipo de privacidad.

Con esta definición de privacidad determinamos 4 ámbitos de privacidad en el mundo laboral:

Personal: la información a gestionar pertenece, de forma exclusiva, al empleado,
Equipo: la información a manejar pertenece a los miembros del equipo. Su consumo sólo puede realizarse por los miembros del equipo al igual que la generación de nueva información o documentación. El resto de empleados de la empresa no tendrá conocimiento alguno sobre la existencia del equipo ni la información que maneja,
Portal: la información a manejar pertenece, de forma exclusiva, a los miembros del portal. El consumo de la información es realizado por cualquier empleado de la compañía. Sin embargo, la generación de nueva información es competencia de los miembros del portal. Los empleados de la compañía podrá buscar y consumir información existente en cualquier portal,
Empresa: la información a manejar pertenece a todos los empleados. El consumo de la información y la generación de nueva información puede ser realizada por cualquier empleado.

Office 365 es el conjunto de herramientas y servicios en la nube que Microsoft pone a disposición de las empresas para gestionar las tareas de la compañía. En concreto, para la gestión documental y la colaboración entre empleados tenemos Microsoft Teams, SharePoint Online, Yammer, y OneDrive for Business. Las características de cada una de estas herramientas las hacen ideales para cubrir los aspectos relativos a los ámbitos de privacidad anteriores.

Ámbito de seguridad Personal

Tal y como hemos indicado anteriormente, este ámbito de seguridad es el más restrictivo de todos. Siguiendo su definición debemos dotar a cada uno de los empleados de un espacio seguro en el que poder gestionar los documentos en los que trabajan y que sólo tienen acceso ellos mismos.

La herramienta más adecuada es OneDrive for Business. Gracias a esta, cada empleado dispone de un espacio privado en la nube donde almacenar y trabajar con documentación propia. Puede considerarse como una carpeta local aunque con muchas más funcionalidades para abordar en otro artículo.

Ámbito de seguridad Equipo

Este ámbito sería el siguiente con una restricción inferior al anterior. En cuanto a su definición, podemos considerar que es una ampliación del Personal pero para varios empleados, es decir, dotar de un espacio seguro a un conjunto de empleados en el que poder gestionar los documentos en los que trabajan.

La herramienta más adecuada es Microsoft Teams. En la creación de un equipo en Microsoft Teams se genera un espacio compartido por los miembros del equipo en el que sólo podrán trabajar ellos mismos. Puede considerarse como una carpeta de red compartida específicamente para un grupo de empleados. Sin embargo, este espacio tiene muchas más funcionalidades para ayudar a los miembros del equipo a comunicarse. Un ejemplo de ello es la capacidad de tener un chat persistente en el que poder transmitir información entre los miembros.

Algunos ejemplos de espacios con ámbito de seguridad de Equipo son: espacios para proyectos, grupos de trabajo, espacios departamentales, espacios para formación, etc.

Ámbito de seguridad Portal

Este ámbito es una ampliación del anterior porque permite exponer información del equipo para el resto de empleados de la compañía. Es decir, dividimos el espacio de trabajo en dos partes: una privada en la que los miembros del equipo trabajarán de forma segura sin que nadie externo al equipo sea consciente de la información contenida; una parte pública donde cualquier empleado podrá consumir la información que el equipo desee publicar.

Para este cometido, SharePoint Online es la herramienta más adecuada. Debido a su naturaleza para la gestión de contenidos documentales y contenidos web, es ideal para publicar contenidos y exponerlos mediante componentes web existentes configurados en sus páginas. Estos elementos los consideramos como la parte pública pero, para la parte privada, también podemos crear y configurar sus elementos para que los miembros del equipo sean los únicos en acceder y colaborar.

Destacar que Microsoft Teams tiene un sitio de SharePoint Online para gestionar su contenido documental.

Algunos ejemplos de espacios con ámbito de seguridad de Portal son: espacios departamentales o de áreas, espacios para formación general, espacios de recursos humanos, espacios de conocimiento empresarial, etc.

Ámbito de seguridad Empresa

Por último, este ámbito de seguridad es el menos restrictivo. Los contenidos existentes están creados por cualquier empleado de la organización y permite ser ampliado con mayor información como pueden ser comentarios, discusiones, preguntas, etc.

Yammer es la herramienta cuyas características son las apropiadas para cumplir con la definición anterior. En Yammer pueden crearse comunidades abiertas donde cualquier empleado podrá suscribirse y recibir notificaciones de contenidos nuevos publicados. O, simplemente, puede buscar por cualquier contenido relevante y encontrar comunidades, conversaciones, discusiones o preguntas relacionadas. En el caso de querer añadir más información o preguntar por algo en concreto, podrá hacerlo sin necesidad de pertenecer a la comunidad en cuestión.

Algunos ejemplos de espacios con ámbito de seguridad de Empresa son: comunidades de conocimiento, comunidades de formación, comunidades de preguntas frecuentes, comunidades de bienvenida, etc.

Para finalizar

El ejercicio realizado en este artículo establece unas reglas de uso de las herramientas de Office 365 basadas en la privacidad de la información y quién la gestiona. Podemos realizar otro tipo de clasificaciones basadas en otras premisas e, incluso, sugerir otras herramientas para los ámbitos de seguridad aquí definidos. Sin embargo, bajo mi punto de vista, esta es una buena clasificación y un punto de partida para modelos más complejos.

Feedback

Créditos

La imagen de cabecera procede de Unsplash y es cortesía de Kaleidico

You must attend the following online conferences this year 2022

Coding Bugs — Thu, 20 Jan 2022 08:39:29 +0000

My nickname in the networks is Coding Bugs, and I have been working as a software developer and architect for more than 15 years. In my dashboard, you will find articles about programming languages, programming techniques, and other concepts that will help you improve.

Conferences allow people with common interests on a specific topic to exchange opinions, points of view, and debate on specific issues. They also serve to establish new friendships, build relationships with other people with the same interests and share experiences among peers.

Nowadays, many conferences are held all over the world throughout the year. In the world of software development, there are conferences with specific topics: for each existing programming language (javascript, python, go, .net, etc.), generic aspects of software development (architectures and paradigms), also on the management of the developed source code itself (DevOps, Git, Mercurial, CI/CD, etc.), and even on tools, applications and services (Office 365, AWS, Google, etc.).

In this article I offer you the conferences that I consider the most interesting for the topics and the depth with which they deal with them. I have divided them into two different lists based on my professional interests: the Office 365 suite (SharePoint Online, OneDrive for Business, Power Platform, Microsoft Teams, etc.) and my personal interests: the world of web application development with JavaScript.

The conferences and their information about the sessions, topics and dates indicated have been obtained directly from the links indicated in each one of them and at the date of publication of this article. All these data are subject to change as the days progress during the year.

Office 365 Conferences

For those of you who do not know, Office 365 is a set of products, applications and services that Microsoft makes available to companies for the management and development of their employees' day-to-day tasks. Among them we have SharePoint Online, OneDrive for Business, Power Platform, Microsoft Teams, etc., and Viva as the latest addition.

Microsoft Ignite

Microsoft is the organizer of one of the most important conferences of the year, the "Microsoft Ignite", in which Microsoft professionals along with others with a very close relationship expose new features of products and tools and others that will come in the near future or are included in the roadmap.

The last two years they have held the conference remotely and everyone, from anywhere on the planet, could attend with their web browser without any problem. In addition, all sessions are recorded and are available to the general public on the event's own website, "Microsoft Ignite" and on the official Microsoft documentation website, https://docs.microsoft.com/.

They have not yet released the date for this year's event but it will be around the first week of November. Check their website regularly for the timing of the release date.

European SharePoint Office 365 & Azure Conference

Another of the most important conferences on Office 365 is the "European SharePoint Office 365 & Azure Conference" in which professionals from around the world show experiences, best practices and other techniques to get the most out of the products offered by Microsoft.

The last two years it has been done remotely, but this year, they are also face-to-face. In addition, the sessions have been divided into 3 categories to guide the attendees in the contents they want to attend:

Learn @ESCP22 aims to showcase the latest practices, tips and techniques thanks to the best professionals on the planet,
Connect @ESCP22 aims to reconnect attendees through various events and activities. There is also an area where companies will exhibit their products and services,
Be Inspired @ESCP22 aims to inspire attendees through talks from industry leaders.

This year it will be held in Copenhagen (Denmark) from November 28 to December 1.

European Power Platform Conference

Finally, this year for the first time there will be a conference on Power Platform called "European Power Platform Conference". The organizers are the same as the "European SharePoint Conference" and with the same categorization in the existing sessions: Learn, Connect and Be Inspired. This conference will be face-to-face only, a real shame for those of us who will not be attending.

This year it will be held in Berlin (Germany) from April 6 to 8.

JavaScript Conferences

The JavaScript programming language is, according to the "Developers Survey 2021", the language most used by developers at the moment, together with other web technologies (HTML and CSS). It is continuously evolving and incorporating new functionalities year after year.

Jamstack Conf

Jamstack is a web space where the benefits of the application architecture with the same name based on the development of web applications hosted in CDN with calls to different API services to work the information of the application itself are shown. Experts from different parts of the world have contributed and continue to contribute to the development of this architecture with best practices, use cases, scenarios where it can be useful, and other things.

Last year there was only one conference, however, in previous years they held several at different times of the year and this year they already have 2 planned: the first one at the end of January, and the second one at the end of February. Stay tuned to their website for more events as the year progresses.

TheJam.dev

"TheJam.dev" collects expert sessions on Jamstack and makes them available to the general public. As we said in the previous talk, Jamstack is a web-based architecture that focuses on the web application itself and relies on API services to work with the information.

This year the conference is free of charge and takes place over 2 days, January 26 and 27.

Other conferences

There are many other conferences dedicated to JavaScript but I wanted to highlight these two because of the content they offer and because they are free. The rest of the conferences offer very interesting sessions but they return to the face-to-face model and, consequently, you have to pay to attend or under a mixed model in which they offer a series of sessions and contents online and free and the rest of the sessions under a payment model.

Summarizing

Conferences and sessions are a way to meet people with similar tastes and experiences to yours. It also allows you to expand your network and learn new things that you may not have known before or, on the contrary, to realize the knowledge you treasure and share it in future sessions.

In this article I have listed those conferences and events that I consider most appropriate to follow, firstly, the Office 365 world and, secondly, to be updated about best practices, architectures, and techniques about JavaScript within web application development.

Feedback

Credits

The header image comes from Unsplash and is courtesy of Samuel Pereira.

Debes asistir a las siguientes conferencias online de este año 2022

Coding Bugs — Thu, 20 Jan 2022 08:39:21 +0000

Mi apodo en las redes es Coding Bugs y llevo más de 15 años trabajando como desarrollador y arquitecto de software. En mi dashboard encontrarás artículos con información sobre lenguajes de programación, técnicas de programación y otros conceptos que te ayudarán a mejorar.

Las conferencias permiten que la gente con intereses comunes sobre alguna temática específica puedan intercambiar opiniones, puntos de vista, y realizar debates sobre aspectos específicos. También sirven para entablar nuevas amistades, relaciones con otras personas con los mismos intereses y compartir experiencias entre iguales.

En la actualidad, se realizan muchas conferencias a lo largo y ancho del planeta durante todo el año. En el mundo del desarrollo del software existen conferencias con temáticas específicas: por cada lenguaje de programación existente (javascript, python, go, .net, etc.), aspectos genéricos del desarrollo del software (arquitecturas y paradigmas), también sobre la propia gestión del código fuente desarrollado (DevOps, Git, Mercurial, CI/CD, etc.), e, incluso, sobre herramientas, aplicaciones y servicios (Office 365, AWS, Google, etc.).

En este artículo os ofrezco las conferencias, que considero, más interesantes por las temáticas y la profundidad con la que las tratan. Las he dividido en dos listados diferentes basados en mis intereses profesionales: la suite de Office 365 (SharePoint Online, OneDrive for Business, Power Platform, Microsoft Teams, etc.) y en mis intereses personales: el mundo del desarrollo de aplicaciones web con JavaScript.

Las conferencias y su información acerca de las sesiones, temáticas y fechas indicadas ha sido obtenida directamente de los enlaces indicados en cada una de ellas y a la fecha de la publicación de este artículo. Todos estos datos son susceptibles de cambiar a medida que avancen los días durante el año.

Conferencias de Office 365

Para aquellos que no lo sepáis, Office 365 es un conjunto de productos, aplicaciones y servicios que Microsoft pone a disposición de las empresas para la gestión y desarrollo de las tareas propias del día a día de los empleados. Entre ellas tenemos SharePoint Online, OneDrive for Business, Power Platform, Microsoft Teams, etc., y Viva como la última incorporación.

Microsoft Ignite

Microsoft es el organizador de una de las conferencias más importantes del año, el "Microsoft Ignite", en la que profesionales de Microsoft junto a otros con una relación muy cercana exponen nuevas funcionalidades de los productos y herramientas y otras que vendrán en el futuro más cercano o están incluidas en el roadmap.

Los dos últimos años han realizado la conferencia de manera remota y a la que todo el mundo, desde cualquier lugar del planeta, podía asistir con su explorador web sin problema. Además, todas las sesiones son grabadas y están disponibles para el público general en la propia página del evento, "Microsoft Ignite" y en la página web con la documentación oficial de Microsoft, https://docs.microsoft.com/.

Todavía no han publicado la fecha para el evento de este año pero será alrededor de la primera semana de Noviembre. Visita regularmente su página web para ver el momento de la fecha de su publicación.

European SharePoint Office 365 & Azure Conference

Otra de las conferencias más importantes sobre Office 365 es la "European SharePoint Office 365 & Azure Conference" en la que profesionales de todo el mundo muestran experiencias, buenas prácticas y otras técnicas para sacar el máximo rendimiento a los productos que ofrece Microsoft.

Los dos últimos años se ha realizado de forma remota, pero, este año, también son presenciales. Además, las sesiones se han dividido en 3 categorías para guiar a los asistentes en los contenidos a los que quieren asistir:

Learn @ESCP22 tiene el objetivo de mostrar las últimas prácticas, consejos y técnicas gracias a los mejores profesionales existentes en el planeta,
Connect @ESCP22 tiene el objetivo de volver a conectar a los asistentes a través de varios eventos y actividades. También, existe un área donde las compañías expondrán sus productos y servicios,
Be Inspired @ESCP22 tiene el objetivo de inspirar a los asistentes mediante charlas procedentes de los líderes de la industria.

Este año se celebrará en Copenague (Dinamarca) desde el 28 de Noviembre al 1 de Diciembre.

European Power Platform Conference

Por último, este año se celebrará por primera vez la conferencia sobre Power Platform llamada "European Power Platform Conference". Los organizadores son los mismos que la "European SharePoint Conference" y con la misma categorización en las sesiones existentes: Learn, Connect y Be Inspired. Esta conferencia será sólo presencial, una auténtica pena para los que no asistiremos.

Este año se celebrará en Berlín (Alemania) desde el 6 al 8 de Abril.

Las conferencias de JavaScript

El lenguaje de programación de JavaScript es, según la "Developers Survey 2021", el lenguaje más usado por los desarrolladores, en estos momentos, junto al resto de tecnologías web (HTML y CSS). Está en continua evolución e incorporando nuevas funcionalidades año tras año.

Jamstack Conf

Jamstack es un espacio en la web donde se muestran los beneficios de la arquitectura de aplicaciones con el mismo nombre basada en el desarrollo de aplicaciones web alojadas en CDN con llamadas a diferentes servicios API para trabajar la información de la propia aplicación. Expertos de diferentes partes del mundo han contribuido y continúan contribuyendo en el desarrollo de esta arquitectura con buenas prácticas, casos de uso, escenarios donde puede ser útil, y otro tipo de cosas.

El año pasado hubo una única conferencia, sin embargo, en anteriores años hicieron varias en diferentes momentos del año y este año tienen ya planificadas 2: la primera a finales de Enero, y la segunda a finales de Febrero. Sigue atento a su página para ver más eventos a medida que avanza el año.

TheJam.dev

"TheJam.dev" recoge sesiones de expertos en Jamstack y las pone a disposición del público en general. Como hemos dicho en la anterior conferencia, Jamstack es una arquitectura basada en web que se centra en la propia aplicación web y se apoya en servicios API para trabajar con la información.

Este año la conferencia es gratuita y se realiza durante 2 días, 26 y 27 de Enero.

Otras conferencias

Hay otras muchas más conferencias dedicadas a JavaScript pero he querido resaltar estas dos por los contenidos que ofrecen y porque son gratuitas. El resto de conferencias ofrecen sesiones muy interesantes pero vuelven al modelo presencial y, en consecuencia, hay que pagar para acudir o bajo un modelo mixto en el que ofrecen una serie de sesiones y contenidos de manera online y gratuita y el resto de sesiones bajo modelo de pago.

Resumiendo

Las conferencias y sesiones son una forma de conocer gente con gustos y experiencias similares a las tuyas. Además, te permite ampliar tu red de contactos y aprender cosas nuevas que, quizás, no conocieras o, al contrario, te des cuenta del conocimiento que atesoras y puedas compartirlo en próximas sesiones.

En este artículo he listado aquellas conferencias y eventos que considero más apropiadas para seguir, en primer lugar, el mundo Office 365 y, en segundo lugar, para estar al día acerca de buenas prácticas, arquitecturas, y técnicas acerca de JavaScript dentro del desarrollo de aplicaciones web.

Feedback

Créditos

La imagen de cabecera procede de Unsplash y es cortesía de Samuel Pereira

Find out what a "Timestamp" is for

Coding Bugs — Mon, 10 Jan 2022 09:20:03 +0000

My nickname in the networks is Coding Bugs, and I have been working as a software developer and architect for more than 15 years. In my dashboard, you will find articles about programming languages, programming techniques, and other concepts that will help you improve.

The "timestamp" is a way of setting the current date and time to a set of values. The simplest example corresponds to each record in a database saving the date when of creation. So, checking when they have been added, ordering them by the creation time, or grouping them by months, weeks, or days can help their tracking.

The timestamp is a way of registering additional temporary information to any element we are handling. For example, photography cameras allow you to add the date and time when you press the shutter button and take the photo, Post offices also mark letters and packages upon receipt and delivery.

In our digital world, many and varied activities include timestamping. When you create a file on your computer, the operating system adds the created date and time as a property of your file. And, in addition, if you or a computer process modify the file content, you can check the latest modification date value of the file in a different property. Both values are timestamps because they record two events related to the document, its creation, and the latest modification.

The value of the timestamp must be consistent in its format because of comparisons between its values. In some cases, the date will be the only thing worth saving while, in more specific scenarios, we might need the date and time and, even, milliseconds. But this depends on the design of our application and the stated requirements.

Timestamps are used in log systems to save helpful information to trace applications, data, or processes. Databases also use them to set the creation or modification of a record, and even the date on which it is no longer helpful or logically deleted. Source code management systems like Git also used timestamps: each "commit" records its date and time. Finally, "blockchain" technology is used to establish the generation moment of each block.

Incorporate a timestamp into your application

Now let's go with an example and apply timestamps in an imaginary application. Imagine that we need to record the date and time when we receive a request to any method of our API. The data that we will have to save will be the following:

let log_data = {
    endpoint: '', // API method URL
    verb: '', // ['GET', 'POST', 'PUT', 'HEAD', 'DELETE', ...]
    created: new Date().toISOString(), // timestamp
    // more helpful information
};

In the following code, we create an object to store several values helpful to track the API methods invocations. The "created" property keeps the date and time, and its value is the current date after creating the object. We can follow the timeline and see the methods that have been invoked over time dumping this information to a human-readable format in a local file.

For more information about the format of timestamps in the digital world, I recommend reading how to represent dates and times set in ISO 8601.

Summarizing

Timestamps allow you to set a date and time based on the events of data: creation, modification, deletion, etc. They are a simple way to follow up on the data and to be able to analyze their history.

Feedback

Credits

The header image comes from Unsplash and is courtesy of Jonathan Cosens Photography.