Download IT Guides!
|
|
domingo, 30 de mayo de 2021
Libros Gratuitos de Java Code Geeks
lunes, 24 de mayo de 2021
Go in Action Gratis hasta el 30 de Mayo!!
Manning nos regala Go in Action hasta el 30 de mayo, miren:
Don't miss out! Offer ends May 30, 2021.
Only available to new email subscribers.
Get your free eBook!
Go in Action introduces the Go language,
guiding you from inquisitive
developer to Go guru. The book begins
by introducing the unique features
and concepts of Go. Then,
you’ll get hands-on experience
writing real-world applications
including websites and network servers.
- Full-length 264 page book
- Language features and implementation
- Go's type system
- Internals of Go's data structures
Dejo link:
domingo, 23 de mayo de 2021
Libro gratuitos de Web code Geeks
|
sábado, 22 de mayo de 2021
Strings y Arrays de Bytes en Go
Los strings y los arrays de bytes están muy relacionados. Podemos convertir de uno a otro fácilmente:
stra := "the spice must flow"
byts := []byte(stra)
strb := string(byts)
De hecho, este tipo de conversión es común también entre otros tipos. Algunas funciones esperan explícitamente un int32 o un int64 o sus homólogos sin signo. Puede que te descubras a ti mismo haciendo cosas como esta:
int64(count)
Es algo que probablemente acabes haciendo con frecuencia cuando utilices bytes y strings. Observa que cuando utilizas []byte(X) o string(X) estás haciendo una copia de los datos. Esto es imprescindible ya que los strings son inmutables.
Los strings están hechos de runas, que son letras unicode. Si recuperas la longitud de un string es probable que no obtengas el valor que esperas. El código siguiente muestra 3:
fmt.Println(len("")) // quizá no lo veas, aquí debería aparecer un carácter chino
Si iteras sobre un string utilizando range obtendrás las runas, no los bytes, aunque cuando conviertes un string en un []byte obtienes los datos correctos.
jueves, 20 de mayo de 2021
Propiedades en C#
Una propiedad es un miembro que proporciona un mecanismo flexible para leer, escribir o calcular el valor de un campo privado. Las propiedades se pueden usar como si fueran miembros de datos públicos, pero en realidad son métodos especiales llamados descriptores de acceso. Esto permite acceder fácilmente a los datos y aún así ayuda a promover la seguridad y flexibilidad de los métodos.
Las propiedades permiten que una clase exponga una forma pública los get y set, mientras oculta el código de implementación o verificación.
Se usa un descriptor de acceso de propiedad para devolver el valor de la propiedad, y se usa un descriptor de acceso de propiedad establecido para asignar un nuevo valor. Por ejemplo si queremos un atributo solo lectura y otro que se pueda acceder y asignar :
class Persona {
public long Dni { get; }
public string Nombre { get; set; }
public string Apellido { get; set; }
...
La palabra clave value se utiliza para definir el valor asignado por el descriptor de acceso set o init.
Las propiedades pueden ser de lectura y escritura (tienen un descriptor de acceso get y set), de solo lectura (tienen un descriptor de acceso get pero no un descriptor de acceso establecido) o de solo escritura (tienen un descriptor de acceso set, pero no un descriptor de acceso get). Las propiedades de solo escritura son raras y se utilizan con mayor frecuencia para restringir el acceso a datos confidenciales.
Las propiedades simples que no requieren un código de acceso personalizado se pueden implementar como definiciones de cuerpo de expresión o como propiedades implementadas automáticamente.
Un patrón básico para implementar una propiedad implica el uso de un campo de respaldo privado para establecer y recuperar el valor de la propiedad. El descriptor de acceso get devuelve el valor del campo privado, y el descriptor de acceso establecido puede realizar alguna validación de datos antes de asignar un valor al campo privado. Ambos accesadores también pueden realizar alguna conversión o cálculo en los datos antes de que se almacenen o devuelvan.
Veamos un ejemplo :
using System;
class TimePeriod
{
private double _seconds;
public double Hours
{
get { return _seconds / 3600; }
set {
if (value < 0 || value > 24)
throw new ArgumentOutOfRangeException(
$"{nameof(value)} must be between 0 and 24.");
_seconds = value * 3600;
}
}
}
class Program
{
static void Main()
{
TimePeriod t = new TimePeriod();
// The property assignment causes the 'set' accessor to be called.
t.Hours = 24;
// Retrieving the property causes the 'get' accessor to be called.
Console.WriteLine($"Time in hours: {t.Hours}");
}
}
// The example displays the following output:
// Time in hours: 24
Los descriptores de acceso a las propiedades a menudo consisten en declaraciones de una sola línea que simplemente asignan o devuelven el resultado de una expresión. Puede implementar estas propiedades como miembros con cuerpo de expresión. Las definiciones del cuerpo de la expresión consisten en el símbolo => seguido de la expresión para asignar o recuperar de la propiedad.
A partir de C # 6, las propiedades de solo lectura pueden implementar el descriptor de acceso get como un miembro con cuerpo de expresión. En este caso, no se utiliza ni la palabra clave get accessor ni la palabra clave return. El siguiente ejemplo implementa la propiedad Name de solo lectura como un miembro con cuerpo de expresión.
using System;
public class Person
{
private string _firstName;
private string _lastName;
public Person(string first, string last)
{
_firstName = first;
_lastName = last;
}
public string Name => $"{_firstName} {_lastName}";
}
public class Example
{
public static void Main()
{
var person = new Person("Magnus", "Hedlund");
Console.WriteLine(person.Name);
}
}
// The example displays the following output:
// Magnus Hedlund
A partir de C # 7.0, tanto el descriptor de acceso get como el set se pueden implementar como miembros con cuerpo de expresión. En este caso, las palabras clave get y set deben estar presentes. El siguiente ejemplo ilustra el uso de definiciones de cuerpo de expresión para ambos descriptores de acceso. Tenga en cuenta que la palabra clave return no se usa con el descriptor de acceso get.
using System;
public class SaleItem
{
string _name;
decimal _cost;
public SaleItem(string name, decimal cost)
{
_name = name;
_cost = cost;
}
public string Name
{
get => _name;
set => _name = value;
}
public decimal Price
{
get => _cost;
set => _cost = value;
}
}
class Program
{
static void Main(string[] args)
{
var item = new SaleItem("Shoes", 19.95m);
Console.WriteLine($"{item.Name}: sells for {item.Price:C2}");
}
}
// The example displays output like the following:
// Shoes: sells for $19.95
En algunos casos, los descriptores de acceso de propiedad get y set simplemente asignan un valor o recuperan un valor de un campo de respaldo sin incluir ninguna lógica adicional. Al usar propiedades implementadas automáticamente, puede simplificar su código mientras el compilador de C# le proporciona de manera transparente el campo de respaldo.
Si una propiedad tiene tanto un descriptor de acceso get como un set (o un get y un init), ambos deben implementarse automáticamente. Usted define una propiedad implementada automáticamente usando las palabras clave get y set sin proporcionar ninguna implementación. El siguiente ejemplo repite el anterior, excepto que Nombre y Precio son propiedades implementadas automáticamente. El ejemplo también elimina el constructor parametrizado, por lo que los objetos SaleItem ahora se inicializan con una llamada al constructor sin parámetros y un inicializador de objeto.
using System;
public class SaleItem
{
public string Name
{ get; set; }
public decimal Price
{ get; set; }
}
class Program
{
static void Main(string[] args)
{
var item = new SaleItem{ Name = "Shoes", Price = 19.95m };
Console.WriteLine($"{item.Name}: sells for {item.Price:C2}");
}
}
// The example displays output like the following:
// Shoes: sells for $19.95
Dejo link: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties
lunes, 17 de mayo de 2021
Delegate en C# parte 3
Los Generic Delegate no requieren la definición de una instancia de un delegado para invocar a los métodos.
Existen tres tipos de Generic delegate:
Generic Delegate: Func
El delegado Func define un método que puede ser llamado con argumentos y devolver un valor. Existen varias sobrecargas de este delegado.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Test
{
public static void Main()
{
// Definir el delegado Func con parámetro de entrada de tipo int y devuelve un string
Func<int, string> showIntToString = delegate(int i)
{
return i.ToString();
};
// Definir el delegado Func con parámetro de entrada de tipo string y devuelve un int
Func<string, int> showStringToInt = s =>
{
return int.Parse(s);
};
// Llamar a los delegados
Console.WriteLine(showIntToString(16));
Console.WriteLine(showStringToInt("55"));
}
}
El delegado Action define un método que puede ser llamado con argumentos pero NO devuelve un valor. Existen varias sobrecargas de este delegado.
Un ejemplo básico de este delegado podría ser:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Test
{
public static void Main()
{
// Definir el delegado Action con parámetro de entrada de tipo int
Action<int> showIntToString = delegate(int i)
{
Console.WriteLine("El valor pasado al delegado como parámetro es: {0}", i);
};
// Definir el delegado Action con parámetro de entrada de tipo string
Action<string> showStringToInt = s =>
{
Console.WriteLine("El valor pasado al delegado como parámetro es: {0}", s);
};
// Llamar a los delegados
showIntToString(16);
showStringToInt("55");
}
}
El delegado Predicate define un método que puede ser llamado con argumentos pero SIEMPRE devuelve un valor de tipo bool. Existen varias sobrecargas de este delegado.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
public class Test
{
public static void Main()
{
string validNumber = "28";
string invalidNumber = "28z";
// Definir el delegado Predicate con parámetro de entrada de string
Predicate<string> isValidNumber = d => IsNumber(d);
if (isValidNumber(validNumber))
{
Console.WriteLine("El número {0} es válido", validNumber);
}
else
{
Console.WriteLine("El número {0] NO es válido", validNumber);
}
if (isValidNumber(invalidNumber))
{
Console.WriteLine("El número {0} es válido", invalidNumber);
}
else
{
Console.WriteLine("El número {0} NO es válido", invalidNumber);
}
}
private static bool IsNumber(string number)
{
Decimal d;
return Decimal.TryParse(number, out d);
}
}
Interfaces Vacías y Conversiones en Go
En la mayoría de los lenguajes orientados a objetos hay una clase base predefinida, a menudo llamada object, que actúa como superclase de todas las clases. Esto es lo que ocurre con una interfaz vacía sin métodos: interface{} en go. Puesto que las interfaces se implementan implícitamente, todos los tipos encajan con el contrato de una interfaz vacía.
Si quisiéramos podríamos crear una función llamada add con la siguiente firma:
func add(a interface{}, b interface{}) interface{} {
...
}
Por lo que podriamos utilizar esta función con cualquier tipo. Pero si nosotros necesitamos hacer diferentes acciones por tipo podemos convertir los tipos.
Para convertir una variable a un tipo específico debes usar .(TIPO):
return a.(int) + b.(int)
También puedes crear switchs de tipos:
switch a.(type) {
case int:
fmt.Printf("a es un entero y vale %d\n", a)
case bool, string:
// ...
default:
// ...
}
Sé que no es una solución elegante pero muchas veces viene bien.
sábado, 15 de mayo de 2021
Curso de .net del laboratorio gugler
Quiero invitarlos al curso de programación en .net del laboratorio Gugler.
jueves, 13 de mayo de 2021
Common Language Runtime
.NET proporciona runtime, denominado Common Language Runtime, que ejecuta el código y proporciona servicios que facilitan el proceso de desarrollo.
Los compiladores y las herramientas exponen la funcionalidad de Common Language Runtime y le permiten escribir código que se beneficie de este entorno de ejecución administrado. El código compilado por un compilador .net se llama código administrado. El código administrado se beneficia de características como la integración entre lenguajes, el manejo de excepciones entre lenguajes, la seguridad mejorada, el control de versiones y la implementación, un modelo simplificado para la interacción de componentes y servicios de depuración y creación de perfiles.
Los compiladores y las herramientas pueden producir resultados que el Common Language Runtime puede consumir porque el sistema de tipos, el formato de los metadatos y el entorno de tiempo de ejecución (el sistema de ejecución virtual) están definidos por un estándar público, la ECMA Common Language Infrastructure. especificación.
Para permitir que el tiempo de ejecución proporcione servicios al código administrado, los compiladores de lenguaje deben emitir metadatos que describan los tipos, miembros y referencias en su código. Los metadatos se almacenan con el código; Todos los archivos ejecutables portátiles (PE) cargables de Common Language Runtime contienen metadatos. El tiempo de ejecución utiliza metadatos para localizar y cargar clases, diseñar instancias en la memoria, resolver invocaciones de métodos, generar código nativo, reforzar la seguridad y establecer límites de contexto en tiempo de ejecución.
El Runtime maneja automáticamente el diseño de los objetos y administra las referencias a los objetos, liberándolos cuando ya no se utilizan. Los objetos cuya vida útil se gestiona de esta forma se denominan datos gestionados. El recolector de basura elimina las pérdidas de memoria, así como algunos otros errores de programación comunes. Debido a que los compiladores de lenguaje proporcionan sus propios tipos, como los tipos primitivos, es posible que no siempre sepa (o necesite saber) si sus datos están siendo administrados.
Common Language Runtime facilita el diseño de componentes y aplicaciones cuyos objetos interactúan entre lenguajes. Los objetos escritos en diferentes lenguajes pueden comunicarse entre sí y sus comportamientos pueden integrarse estrechamente. Por ejemplo, puede definir una clase y luego usar un lenguaje diferente para derivar una clase de su clase original o llamar a un método en la clase original. También puede pasar una instancia de una clase a un método de una clase escrito en un lenguaje diferente. Esta integración entre lenguajes es posible porque los compiladores de lenguajes y las herramientas que tienen como objetivo el tiempo de ejecución utilizan un sistema de tipo común definido por el tiempo de ejecución, y siguen las reglas del tiempo de ejecución para definir nuevos tipos, así como para crear, usar, persistir y vincularse a tipos.
Como parte de sus metadatos, todos los componentes administrados contienen información sobre los componentes y recursos con los que se crearon. El tiempo de ejecución utiliza esta información para garantizar que su componente o aplicación tenga las versiones especificadas de todo lo que necesita, lo que hace que sea menos probable que su código se rompa debido a alguna dependencia no satisfecha. La información de registro y los datos ya no se almacenan en el registro, donde puede ser difícil establecerlos y mantenerlos. En cambio, la información sobre los tipos que define (y sus dependencias) se almacena con el código como metadatos, lo que hace que las tareas de replicación y eliminación de componentes sean mucho menos complicadas.
Los compiladores de lenguaje y las herramientas exponen la funcionalidad del tiempo de ejecución de formas que están destinadas a ser útiles e intuitivas para los desarrolladores. Esto significa que algunas características del tiempo de ejecución pueden ser más notables en un entorno que en otro. La forma en que experimente el tiempo de ejecución depende de qué compiladores de lenguaje o herramientas utilice. Por ejemplo, si es un desarrollador de Visual Basic, es posible que observe que con Common Language Runtime, el lenguaje Visual Basic tiene más características orientadas a objetos que antes. El Runtime proporciona los siguientes beneficios:
• Mejoras de rendimiento.
• La capacidad de utilizar fácilmente componentes desarrollados en otros lenguajes.
• Tipos extensibles proporcionados por una biblioteca de clases.
• Características del lenguaje como herencia, interfaces y sobrecarga para la programación orientada a objetos.
• Soporte para subprocesos libres explícitos que permiten la creación de aplicaciones escalables y multiproceso.
• Soporte para manejo estructurado de excepciones.
• Soporte para atributos personalizados.
• Recolección de basura.
• Uso de delegados en lugar de punteros de función para una mayor seguridad y protección de tipos. Para obtener más información sobre los delegados, consulte Sistema de tipos comunes.
lunes, 10 de mayo de 2021
Delegate en C# parte 2
Un Multicast delegate es un delegado pero mantiene referencias a más de un método. Este tipo de delegado debe contener únicamente métodos que devuelvan un void, de otro modo se lanzará una excepción en tiempo de ejecución. Al invocar al delegado, se ejecutarán todos los métodos asociados en el mismo orden en el cual fueron agregados al delegado.
Para agregar métodos al delegado se emplea el operador ‘+=’ y para eliminar métodos del delegado se emplea el operador ‘-=’. Un mismo método se puede añadir a un objeto delegado más de una vez. Veamos un ejemplo:
using System;
public delegate void MiDelegadoMultiCast(int i);
public class Test
{
public static void Main()
{
MiClase miClase = new MiClase();
// instanciamos un delegado. Observa que el método MiMetodo1 de la clase
// MiClase cumple con la firma definida en el delegado
MiDelegadoMultiCast delegado = miClase.MiMetodo1;
delegado(83); // Se hace la llamada al delegado
// agregamos ahora el Metodo2
delegado += miClase.MiMetodo2;
// Se hace la llamada al delegado y se ejecutarán en orden secuencial ambos métodos
delegado(55);
// eliminamos ahora el Metodo1
delegado -= miClase.MiMetodo1;
// Se hace la llamada al delegado y se ejecutará únicamente el Método2
delegado(14);
}
}
public class MiClase
{
public void MiMetodo1(int i)
{
Console.WriteLine("El valor pasado al METODO1 como parámetro es: {0}", i);
}
public void MiMetodo2(int i)
{
Console.WriteLine("El valor pasado al METODO2 como parámetro es: {0}", i);
}
}
Dejo link: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/using-delegates
domingo, 9 de mayo de 2021
Pyston un python más rápido
Pyston es una implementación del JIT para Python 3.8.8 que promete ser más rápida que Python. Además han puesto el proyecto en código abierto.
Pyston v2.2 es un 30% más rápido que el Python de serie en los benchmarks de servidores web, de acuerdo con un anuncio realizado por Kevin Modzelewski, creador de Pyston. Modzelewski afirma que Pyston elimina "muchas de las características de depuración poco utilizadas que admite Python" en cuanto a la velocidad, para reducir la carga que la depuración de Python crea para los ordenadores.
A la vez es muy fácil cambiar de Pyston a python. Esto la da muchas posibilidades a esta nueva implementación.
Dejo link: https://github.com/pyston/pyston
viernes, 7 de mayo de 2021
Curso intensivo de aprendizaje automático
Google nos regala un curso sobre aprendizaje automático totalmente gratuito y en español. Como es habitual en google, el curso esta muy bien hecho y cuenta con una parte práctica utilizando tensorflow.
Dejo el link: https://developers.google.com/machine-learning/crash-course
miércoles, 5 de mayo de 2021
Primera Aplicación en .net 5 en VB
Y luego creamos una carpeta y hacemos una aplicación de consola:
mkdir miPrimerApp
cd miPrimerApp
dotnet new console -lang VB
code .
Como verán le puse miPrimerApp a la carpeta y luego ejecute visual code con el comando "code ."
En visual code podemos ver la clase Program.vb que se va a ejecutar :
Imports System
Module Program
Sub Main(args As String())
Console.WriteLine("Hello World!")
End Sub
End Module
Buenisimo, ya casi estamos, ahora podemos ejecutarlo desde la consola con :
$ dotnet run
Hello World!
o con visual code desde "run -> start debugging"
Libros Gratuitos de Python
Este repositorio de github se encuentra un proyecto que trata de reunir la mayor cantidad de libros gratuitos online de Python.
Por ahora la lista de temas es la siguiente :
- Introductory
- Intermediate
- Advanced
- AI and Machine Learning
- Computer Science
- Software Engineering and best practices
- GUI
- Tools
- Web development
- Data science
- Science
- Jupiter Notebook
- Engineering
- Cryptography
- Games
Dejo link : https://github.com/pamoroso/free-python-books
lunes, 3 de mayo de 2021
Primera Aplicación en .net 5 en F#
Vamos rapidito, antes que nada tenemos que tener .net instalado y visual code (con el plugin de F#)
Y luego creamos una carpeta y hacemos una aplicación de consola:
mkdir miPrimerApp
cd miPrimerApp
dotnet new console -lang "F#"
code .
Como verán le puse miPrimerApp a la carpeta y luego ejecute visual code con el comando "code ."
En visual code podemos ver la clase Program.fs que se va a ejecutar :
// Learn more about F# at http://docs.microsoft.com/dotnet/fsharp
open System
// Define a function to construct a message to print
let from whom =
sprintf "from %s" whom
[<EntryPoint>]
let main argv =
let message = from "F#" // Call the function
printfn "Hello world %s" message
0 // return an integer exit code
Buenisimo, ya casi estamos, ahora podemos ejecutarlo desde la consola con :
$ dotnet run
Hello world from F#
o con visual code desde "run -> start debugging"
Como correr los test proyecto clojure?
Si vieron este post : https://emanuelpeg.blogspot.com/2021/04/como-crear-un-proyecto-clojure.html
Deben haber pensado: y los test, donde están los test?
Bueno, vamos a hacer una pequeña función cuadrado por ejemplo :
(defn cuadrado [n] (* n n))
(ns recfun.core-test
(:require [clojure.test :refer :all]
[recfun.core :refer :all]))
(deftest a-test-of-cuadrado
(testing "2 * 2 = 4 "
(is (= (cuadrado 2) 4))))
Y corremos los test con :
$ lein test
lein test recfun.core-test
Ran 1 tests containing 1 assertions.
0 failures, 0 errors.
Y listo, voy a hacer un test que termine mal, así se ve :
(deftest other-test-of-cuadrado
(testing "2 * 2 = 5 (solo para que termine mal) "
(is (= (cuadrado 2) 5))))
$ lein test
lein test recfun.core-test
lein test :only recfun.core-test/other-test-of-cuadrado
FAIL in (other-test-of-cuadrado) (core_test.clj:11)
2 * 2 = 5 (solo para que termine mal)
expected: (= (cuadrado 2) 5)
actual: (not (= 4 5))
Ran 2 tests containing 2 assertions.
1 failures, 0 errors.
Tests failed.
sábado, 1 de mayo de 2021
Primera Aplicación en .net 5 en C#
Vamos rapidito, antes que nada tenemos que tener .net instalado y visual code (con el plugin de C#)
Y luego creamos una carpeta y hacemos una aplicación de consola:
mkdir miPrimerApp
cd miPrimerApp
dotnet new console
code .
Como verán le puse miPrimerApp a la carpeta y luego ejecute visual code con el comando "code ."
En visual code podemos ver la clase Program.cs que se va a ejecutar :
using System;
namespace prueba
{
class Program
{
/**
Mi Primer App
*/
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
$ dotnet run
Hello World!
o con visual code desde "run -> start debugging"
Suscribirse a:
Entradas (Atom)
