Mostrando entradas con la etiqueta python. Mostrar todas las entradas
Mostrando entradas con la etiqueta python. Mostrar todas las entradas

sábado, 28 de junio de 2025

El Engranaje Relativista: ¿Qué Ocurre Cuando un Objeto Gira a la Velocidad de la Luz?


La relatividad especial de Albert Einstein revolucionó nuestra comprensión del espacio y el tiempo, demostrando que ambos no son absolutos, sino que se distorsionan a velocidades cercanas a la de la luz (). ¿Pero qué ocurre cuando aplicamos estos principios a algo tan cotidiano como un engranaje en rotación extrema?

Imaginemos un escenario hipotético: un engranaje se desplaza horizontalmente a una velocidad lineal de 0.499999c sobre una superficie. Lo más intrigante es que su punto de contacto con la superficie (la parte inferior) se mantiene a una velocidad cero (relativa a la superficie), mientras que la parte superior del engranaje se precipita a una velocidad asombrosa de 0.999999c. Este es un caso extremo de movimiento de rodadura, donde el centro de masa del engranaje se mueve a aproximadamente la mitad de la velocidad de la luz, y su rotación añade un componente de velocidad considerable a la parte superior.

En un mundo relativista, este escenario nos obliga a considerar efectos que son imperceptibles en nuestra vida diaria, pero dominantes a velocidades cósmicas: la dilatación del tiempo y la contracción de Lorentz.


La Contracción de Lorentz: Una Métrica Distorsionada

El efecto más visual que experimentaríamos al observar este engranaje es la contracción de Lorentz. Un objeto que se mueve a una velocidad relativa a un observador, se contrae en la dirección de su movimiento. La longitud observada será menor que su longitud propia $L_0$ (la longitud medida en su propio marco de referencia en reposo), según la siguiente ecuación:

Donde el término $\sqrt{1 - \frac{c^2}{v^2}}$ es el factor de Lorentz, $\gamma^{-1}$. A velocidades cercanas a , $\gamma^{-1}$ se acerca a cero, lo que implica una contracción significativa.

En nuestro engranaje, la clave es que cada punto de su circunferencia se mueve a una velocidad diferente en relación con el observador estacionario.

  • Parte Inferior (punto de contacto): Velocidad . Aquí, el factor de Lorentz es $\gamma^{-1} = 1$. No hay contracción.
  • Centro del Engranaje: Velocidad . Aquí, el factor de Lorentz sería $\sqrt{1-0.49999^2}$. El centro del engranaje y los puntos que se mueven con su velocidad lineal experimentarán una contracción de aproximadamente el 13.4% en la dirección horizontal.
  • Parte Superior: Velocidad . ¡Este es el punto más extremo! El factor de Lorentz es $\sqrt{1-0.999999^2}$ aprox. $\sqrt{1-0.999998}$ aprox. $\sqrt{0.000002}$ aprox. $0.0014$. Esto significa que la parte superior del engranaje se contraería a menos del 0.15% de su longitud original en la dirección del movimiento. ¡Sería extremadamente aplanada!
  • Puntos Intermedios: Cualquier punto en el engranaje que no esté en la parte superior o inferior tendrá una componente de velocidad horizontal que varía entre 0 y 0.999999c. La velocidad horizontal de un punto en la circunferencia dependerá tanto de la velocidad de traslación del centro como de la velocidad tangencial de rotación en ese punto.

¿Qué Aspecto Tendría el Engranaje?

El resultado visual sería asombroso y contraintuitivo:

  1. Aplanamiento Extremo: La parte superior del engranaje se vería extremadamente aplanada en la dirección del movimiento, casi como una línea.
  2. Forma Distorsionada: El engranaje no se vería como un círculo plano. En su lugar, adquiriría una forma ovalada o elíptica muy pronunciada, con el eje menor en la dirección del movimiento y el eje mayor perpendicular a él. La parte delantera y trasera se comprimirían drásticamente, mientras que la parte inferior conservaría su longitud.
  3. Gradiente de Contracción: Habría un gradiente continuo de contracción desde la parte inferior (sin contracción) hasta la parte superior (contracción máxima), creando una forma aerodinámica pero muy distorsionada.

Un Estudio con Diferencias Finitas (Conceptual)

Para estudiar esto con precisión, podríamos usar un modelo numérico basado en diferencias finitas. Conceptualicemos cómo se abordaría:

  1. Definición de Puntos: Dividimos el engranaje en una malla de puntos discretos ( puntos en la circunferencia).

  2. Velocidad de Cada Punto: Para cada punto $(x_i,y_i)$ en el marco de referencia del centro del engranaje (que se mueve a ), calculamos su velocidad local $V_{local,i}$ en el marco del observador estacionario. Esto implica sumar vectorialmente la velocidad de traslación $(v_c)$ y la velocidad tangencial de rotación del punto.

    • Si el engranaje tiene radio y velocidad angular $\omega$, la velocidad tangencial de un punto es .
    • Para una rodadura sin deslizamiento, $v_c = \omega \cdot R$.
    • La velocidad total de un punto en el borde será $v_{total} = \sqrt{(v_c + v_{tangencial,x})^2 + v_{tangencial,y}^2}$.
  3. Aplicación de Contracción de Lorentz: Para cada punto, calculamos el factor de Lorentz $\gamma^{-1}_i = \sqrt{1-\frac{v_{local,i}^2}{c^2}}$.

  4. Transformación de Coordenadas: Aplicamos la contracción a las coordenadas horizontales $(x_i)$ de cada punto: $x'_i = x_i \cdot \gamma^{-1}_i$. Las coordenadas verticales $(y_i)$ no se contraen.

  5. Visualización: Graficamos los nuevos puntos $(x'_i,y_i)$ para ver la forma distorsionada del engranaje.

Esquema de un posible código Python (muy simplificado y conceptual):

Python
import numpy as np
import matplotlib.pyplot as plt

# Constantes
c = 1.0  # Velocidad de la luz (unidades arbitrarias para simplificar)
R = 1.0  # Radio del engranaje

# Velocidad del centro del engranaje
v_centro = 0.499999 * c

# Puntos en la circunferencia del engranaje (en su marco de reposo, antes de moverlo)
# Usaremos 360 puntos para una buena resolución
theta = np.linspace(0, 2 * np.pi, 360, endpoint=False)
x_original = R * np.cos(theta)
y_original = R * np.sin(theta)

# Calcular la velocidad horizontal de cada punto en el engranaje rodando
# Asumimos rodadura perfecta: v_tangencial_max = v_centro
# El punto superior se mueve a v_centro + v_tangencial_max_horizontal = 2 * v_centro
# El punto inferior se mueve a v_centro - v_tangencial_max_horizontal = 0 (si v_centro = v_tangencial_max)
# En nuestro caso, la velocidad tangencial en el extremo superior es v_centro,
# pero para que el extremo superior llegue a 0.999999c y el inferior a 0,
# la velocidad de traslación del centro debe ser v_centro y la velocidad tangencial debe ser v_centro.
# Sin embargo, el problema especifica v_superior = 0.999999c y v_inferior = 0.
# Esto implica que la velocidad de traslación del centro es v_centro = (0.999999c + 0c) / 2 = 0.4999995c
# Y la velocidad tangencial máxima es v_tangencial_max = 0.4999995c.

v_translacion = (0.999999 * c + 0 * c) / 2
v_rotacion_max = (0.999999 * c - 0 * c) / 2

# Velocidad horizontal local de cada punto en el marco del observador
# Un punto en el ángulo theta tiene una componente horizontal de la velocidad rotacional
# de -v_rotacion_max * sin(theta) (si theta=0 es la derecha, theta=pi/2 es arriba)
# O mejor, si theta es el ángulo desde la vertical, theta=0 es arriba, theta=pi es abajo
# v_horizontal_local = v_translacion + v_rotacion_max * np.sin(theta)
# (Si theta=pi/2 es derecha, 3pi/2 es izquierda, entonces v_rot_horizontal = -v_rot_max * sin(theta))
# Para que theta=0 sea el punto superior y theta=pi el inferior:
# x_coords = R * np.sin(theta) (horizontal)
# y_coords = R * np.cos(theta) (vertical)
# v_horizontal_local = v_translacion + v_rotacion_max * np.sin(theta)

# Re-evaluando la velocidad para cada punto en la circunferencia
# Consideramos theta = 0 en el punto más a la derecha, creciendo en sentido antihorario.
# Velocidad tangencial en x = -R*omega*sin(theta)
# Velocidad tangencial en y = R*omega*cos(theta)
# Si v_centro es la velocidad de traslación y R*omega es la velocidad tangencial máxima.
# Para v_inferior = 0 y v_superior = 0.999999c:
# v_traslacion = (v_sup + v_inf) / 2 = 0.999999c / 2 = 0.4999995c
# v_rotacion_magnitud = v_traslacion = 0.4999995c

# Coordenadas y velocidades en el marco del observador
x_obs = np.zeros_like(x_original)
y_obs = np.zeros_like(y_original)

for i in range(len(theta)):
    # Posición del punto en el marco de reposo del engranaje
    # Asumimos que (0,0) es el centro del engranaje
    # y que la rotación se produce alrededor de ese centro.
    # El punto inferior está en (0, -R), el superior en (0, R)
    # Convertimos theta para que 0 sea el punto superior
    angle_from_top = theta[i] # Esto sería si theta empieza en la parte superior

    # x e y en el marco del centro del engranaje (antes de aplicar rotación y traslación)
    px = R * np.sin(angle_from_top)
    py = R * np.cos(angle_from_top)

    # Velocidad del punto en el marco del centro del engranaje (velocidad tangencial)
    vx_tangencial = -v_rotacion_magnitud * np.sin(angle_from_top) # Componente horizontal de rotación
    vy_tangencial = v_rotacion_magnitud * np.cos(angle_from_top)  # Componente vertical de rotación

    # Velocidad total del punto en el marco del observador
    vx_total = v_translacion + vx_tangencial # Traslación + componente X de rotación
    vy_total = vy_tangencial # Componente Y de rotación (solo rotación)

    v_total_magnitud = np.sqrt(vx_total**2 + vy_total**2)

    # Aplicar contracción de Lorentz solo a la coordenada X
    # La contracción se aplica a la longitud del objeto en el marco de reposo en la dirección del movimiento.
    # Esto es más complejo que solo aplicar a la coordenada x del punto.
    # Cada "elemento diferencial" del engranaje se contrae según su velocidad local.

    # Una forma más conceptual:
    # Considera la velocidad horizontal de cada punto del borde
    # (asumiendo que y' = y, y solo x' = x / gamma).
    # v_local = v_traslacion + v_rotacion_magnitud * np.cos(theta_rotacion_desde_abajo)
    # (Donde theta_rotacion_desde_abajo es 0 en el punto inferior, pi en el superior)

    # Simplified approach for illustration:
    # For each point (x_original, y_original) on the circumference, its horizontal velocity
    # relative to the ground is v_center + R*omega*sin(angle).
    # Here, angle is measured from the horizontal axis.
    # Let's say theta=0 is right, theta=pi/2 is top, theta=pi is left, theta=3pi/2 is bottom.
    # v_horizontal = v_translacion + v_rotacion_magnitud * np.cos(theta[i]) # This is if rot is along y-axis component for x-velocity. No.
    # The linear velocity of a point on the circumference:
    # vx_linear = v_translacion + v_rotacion_magnitud * np.cos(theta[i] + np.pi/2) # X component of rotation
    # vy_linear = v_rotacion_magnitud * np.sin(theta[i] + np.pi/2) # Y component of rotation

    # Let's use the problem statement directly for v_horizontal_local for simplicity.
    # The speed varies linearly from 0 at bottom to 0.999999c at top.
    # Let y_norm be the y-coordinate normalized from -R to R, so (y_original[i] + R) / (2*R) is between 0 (bottom) and 1 (top).
    # v_effective = 0 + (0.999999 * c - 0) * (y_original[i] + R) / (2*R)
    # This is a simplification, as actual velocity depends on vector sum.
    # A more accurate way is to define rotation and translation separately:
    # v_translation = 0.499999 * c
    # v_rotation_speed = 0.499999 * c # Speed of points on circumference relative to center

    # Each point (x_i, y_i) on the original circle.
    # Its velocity in the lab frame (vx, vy):
    # vx_i = v_translation - v_rotation_speed * (y_original[i] / R)
    # vy_i = v_rotation_speed * (x_original[i] / R)

    # Let's use the simple linear speed distribution for demo as in the problem text:
    # v_local_x_at_y = v_translacion + (y_original[i] / R) * v_rotacion_magnitud
    # The problem implies that v_x_at_y=R is 0.999999c and v_x_at_y=-R is 0c.
    # v_local_at_point = v_translacion + v_rotacion_magnitud * (y_original[i] / R)

    # Re-simulating based on problem statement:
    # v_bottom = 0
    # v_top = 0.999999 * c
    # v_center_of_mass = (v_bottom + v_top) / 2.0 = v_top / 2.0
    # v_tangential_at_top_bottom = v_top / 2.0

    # The velocity of any point on the wheel circumference, only considering its horizontal component:
    # The actual magnitude of velocity is sqrt(vx^2 + vy^2)
    # For a point at angle 'phi' (0 at top, pi at bottom), its x-coordinate is R*sin(phi) and y-coordinate is R*cos(phi)
    # Its horizontal velocity component: v_translation + v_tangential_speed * sin(phi)
    # Its vertical velocity component: v_tangential_speed * cos(phi)

    # Let's simplify and assume the problem meant the total speed magnitude is simplified along x-axis for contraction.
    # This is the tricky part of the interpretation.
    # If we assume only the horizontal velocity component determines contraction:
    # Let's use the provided extreme values:
    # v_at_y = (0.499999*c) + (0.499999*c) * np.sin(theta[i] + np.pi/2) # from -1 to 1 for sin, so 0 to 0.999998c
    # This means theta = pi/2 is the top, theta = 3pi/2 is the bottom.
    # v_point_magnitude = np.abs(v_at_y)
    # Let's use the y-coordinate to linearly interpolate the speed magnitude as stated.
    # v_local = (y_original[i] + R) / (2 * R) * (0.999999 * c) # Ranges from 0 at y=-R to 0.999999*c at y=R

    # A more physically robust approach for a rotating wheel:
    # x_i, y_i are coords in a frame moving with the center of mass.
    # Let the velocity of center of mass be V_CM.
    # Let the angular velocity be omega.
    # The velocity of a point (x_i, y_i) in the lab frame:
    # Vx_lab = V_CM - omega * y_i
    # Vy_lab = omega * x_i
    # V_mag_lab = sqrt(Vx_lab^2 + Vy_lab^2)

    V_CM = 0.499999 * c
    omega = V_CM / R # For rolling without slipping on average
    # The problem statement says top speed is 0.999999c, bottom is 0.
    # This means V_CM + R*omega = 0.999999c
    # And V_CM - R*omega = 0
    # Adding these: 2*V_CM = 0.999999c => V_CM = 0.4999995c
    # R*omega = 0.4999995c

    x_transformed = np.zeros_like(x_original)
    y_transformed = np.zeros_like(y_original)

    for i in range(len(x_original)):
        # Velocity components in the lab frame for the point (x_original[i], y_original[i])
        vx_lab = V_CM - omega * y_original[i]
        vy_lab = omega * x_original[i]

        # Magnitude of the velocity vector
        v_magnitude = np.sqrt(vx_lab**2 + vy_lab**2)

        # Factor de Lorentz
        if v_magnitude >= c: # Avoid division by zero or imaginary numbers if calculation error
            gamma_inv = 0.0001 # Approaching 0 for illustration
        else:
            gamma_inv = np.sqrt(1 - (v_magnitude**2 / c**2))

        # Apply Lorentz contraction. Only the component of the length parallel to velocity vector contracts.
        # This is not a simple x' = x * gamma_inv. It's a transformation of the whole space.
        # However, for visualization of the *shape* as seen by the observer,
        # often a simplified projection onto the direction of overall motion is used for illustration.
        # A common simplified visualization for a rapidly moving object: scale X by gamma_inv
        # We will apply contraction to x_original *based on the horizontal component of the velocity*
        # This is still a simplification but good for illustration.

        # Let's apply it to the x coordinate as it's the direction of main motion.
        # The contraction is of the entire object, not just local points.
        # But if we consider local parts of the object moving at different speeds,
        # and visualize them based on their *local effective speed in x direction*,
        # then we could do something like this for conceptual drawing.

        # The actual contraction is on the proper length of segments.
        # For a 2D wheel, the contraction occurs only in the x-direction of the lab frame.
        # All parts of the wheel are moving horizontally with velocity V_CM (center of mass).
        # Plus, they have a rotational component.
        # The *length* of an infinitesimal segment dx contracts.
        # So, the x-coordinate of each point (relative to the center) will be scaled by its
        # local gamma factor *based on its total velocity magnitude*.
        # x_transformed[i] = x_original[i] * gamma_inv # This is the common simplification for visualization
        # y_transformed[i] = y_original[i]

        # More correct approach for relativistic rotating disk:
        # Each point (x,y) on the wheel has a specific velocity. The object itself is transformed.
        # The equation for the shape is complex (e.g. from a photon reaching the eye).
        # A simple approach for *visualizing Lorentz contraction*:
        # The coordinates x,y get transformed into x', y'
        # x' = (x - v_rel*t) / gamma_v_rel
        # But this is not about the *shape* of the wheel.
        # For visualization of Lorentz contraction, one takes the original object and scales its x-dimensions by gamma.
        # In our case, different parts have different speeds.

        # Let's assume the simplified approach: each local horizontal segment contracts based on its local horizontal velocity.
        # This is a conceptual *visualization* for pedagogical purposes, not a rigorous relativistic calculation of the observed shape from light.
        # The velocity that determines contraction is the velocity of the *part of the object* relative to the observer.
        # Here, let's use the total speed magnitude for simplicity of the "local contraction".
        x_transformed[i] = x_original[i] * gamma_inv
        y_transformed[i] = y_original[i]

# Plotting
plt.figure(figsize=(10, 6))

# Original circle
plt.plot(x_original, y_original, 'k--', label='Engranaje Original (reposo)')

# Transformed shape
plt.plot(x_transformed, y_transformed, 'r-', label='Engranaje Relativista (vista lateral)')

plt.xlabel('Eje X (dirección de movimiento)')
plt.ylabel('Eje Y')
plt.title('Contracción de Lorentz de un Engranaje a Velocidades Relativistas')
plt.axvline(0, color='gray', linestyle=':', linewidth=0.8)
plt.axhline(0, color='gray', linestyle=':', linewidth=0.8)
plt.gca().set_aspect('equal', adjustable='box')
plt.grid(True, linestyle=':', alpha=0.7)
plt.legend()
plt.show()

print("Este código es una conceptualización simplificada para la visualización de la contracción de Lorentz.")
print("La deformación real de un objeto giratorio a velocidades relativistas es un problema complejo que involucra no solo la contracción, sino también la forma en que la luz de diferentes partes llega al observador (aberración, efecto Doppler).")
print(f"Velocidad del centro de masa: {V_CM/c:.6f}c")
print(f"Factor de Lorentz para el centro: {np.sqrt(1 - (V_CM/c)**2):.4f}")
print(f"Factor de Lorentz para la parte superior (V={0.999999*c:.6f}c): {np.sqrt(1 - (0.999999)**2):.4f}")
print(f"Factor de Lorentz para la parte inferior (V=0c): {np.sqrt(1 - 0**2):.4f}")

Nota sobre el código: Este es un modelo conceptual y simplificado para ilustrar la contracción. El cálculo de la forma aparente de un objeto giratorio a velocidades relativistas es un problema mucho más complejo que involucra la aberración de la luz y el hecho de que los fotones de diferentes partes del objeto tardan diferente tiempo en llegar al observador. Lo que he modelado aquí es una simplificación común para visualizar la contracción de la longitud basada en la velocidad local, no la imagen real formada por la luz.


Efectos Adicionales y la Paradoja del "Engranaje Rígido"

Este ejercicio mental revela algunas complejidades profundas:

  1. Dilatación del Tiempo: Cada punto del engranaje que se mueve a una velocidad experimentaría el tiempo más lentamente que el observador estacionario. El tiempo en la parte superior del engranaje correría más lento que en la parte inferior (a velocidad cero), lo que llevaría a desafíos en la coherencia de la rotación y la "rigidez" del material.
  2. Relatividad de la Simultaniedad: Eventos que son simultáneos en el marco de reposo del engranaje no lo serían para el observador estacionario, complicando la noción de una "forma" única del engranaje en un instante dado.
  3. El Engranaje Rígido Relativista: En la relatividad especial, el concepto de un "cuerpo rígido" es problemático. Si una rueda fuera perfectamente rígida, su borde debería poder moverse a velocidades tangenciales arbitrariamente altas, lo que violaría el límite de la velocidad de la luz. En realidad, ningún material puede ser perfectamente rígido; a velocidades relativistas, los materiales se deformarían y no podrían mantener la coherencia de un engranaje tradicional.

Este engranaje hipotético es un experimento mental extremo. Nos ayuda a empujar los límites de nuestra intuición newtoniana y a confrontar las sorprendentes realidades de la relatividad especial. Nos recuerda que, a velocidades cercanas a la de la luz, el mundo tal como lo conocemos se deforma, se contrae y el tiempo se estira, revelando un universo mucho más dinámico y fluido de lo que nuestros sentidos perciben.

martes, 18 de julio de 2017

Juego de carreras de código abierto Yorg ha lanzado la versión 0.6

Yorg (Yorg’s an Open Racing Game) es un juego gratuito de código abierto desarrollado por Ya2 con Panda3D para Windows, OSX y Linux.

Elementos de diseño:


  1. Perspectiva visual en tercera persona;
  2. Estilo arcade;
  3. 8 pilotos diferentes;
  4. 6 coches diferentes (más por venir);
  5. 3 pistas diferentes (más por venir);
  6. AI;
  7. Power-ups (previsto para la versión 0.7);
  8. Armas (previsto para la liberación 0.7);
  9. Campeonato (previsto para la liberación 0.8);
  10. Multijugador (previsto para la versión 0.9)

Yorg es FLOSS: el código del juego es liberado bajo GPLv3. Los activos artísticos de Ya2 se publican bajo CC BY-SA. La fuente del proyecto está aquí.

Aplicamos Integración Continua en nuestro desarrollo. Esto significa que puedes jugar una nueva versión del juego tan pronto como hagamos algo. Mira aquí para recoger una compilación (por ahora solo hay compilaciones "de origen").

Yorg se desarrolla utilizando varias herramientas: Panda 3D, Blender, The Gimp, Python y Bullet.

viernes, 7 de julio de 2017

GENERACIÓN SIMPLE DE ONDAS EN PYTHON (Y SCIPY)

Fuente: hackaday.com

[153Armstrong] hizo un breve post sobre lo fácil que es generar formas de onda utilizando Python. Estamos de acuerdo en que es simple, pero en realidad, no es tanto Python per se, es algunas bibliotecas muy guay (SciPy, en particular) que hacen todo el trabajo duro. Que puede ser la división de pelos, pero no vale la pena nada que SciPy (pronunciado "Sigh Pie") también hace otros trucos útiles como Fourier transforma, también. Usted puede ver un video de sus resultados, a continuación.

El código es simple y uno de los comentaristas señaló una manera aún más eficiente de escribir los datos en un archivo WAV. La idea básica es crear una matriz de muestras en un búfer utilizando algunas funciones del componente NumPy de SciPy.


La mayoría de las formas de onda regulares son fáciles de crear usando un algoritmo. Por ejemplo, las ondas senoidales se pueden describir generalmente como: y=amplitude * sine(radian_frequency*t+phase_shift)

Donde "y" es el valor de la onda en el tiempo "t". La amplitud es el valor de pico (de modo que 5 le dará +/- 5 V) y la frecuencia de radian es el doble del valor de pi veces la frecuencia en Hertz. [153Armstrong] muestra fórmulas simples para ondas senoidales, ondas cuadradas simétricas y asimétricas, y una onda de diente de sierra, utilizando generadores proporcionados por el paquete SciPy. El código está en GitHub y también enlaza con los generadores disponibles en SciPy.

Hemos visto SciPy en algunas entradas del concurso Hackaday anteriores. Se puede pensar en él como Matlab para Python. Sólo tenga en cuenta, no es una parte inherente de Python. Si utiliza otro idioma, podría utilizar una biblioteca similar para obtener el mismo efecto. Y si lo estás haciendo en hardware, probablemente querrás usar tablas de búsqueda, para mantener las cosas rápidas y sencillas.

jueves, 8 de junio de 2017

Fail2Ban: Bloquea host que tienen múltiples errores de autentificación.

Fail2Ban es un programa escrito en Python que escanea los ficheros de log (ejemplo: /var/log/auth.log) y bloquea las direcciones IP que han realizado demasiados intentos de conexión fallidas. El proceso se realiza mediante una acualización del firewall que rechaze todos los nuevos intentos de conexión desde esa dirección IP durante un periodo de tiempo configurable. Fail2Ban viene por defecto preparado para su uso con diversas aplicaciones como por ejemplo sshd y Apache, y es configurable a otras aplicaciones.

martes, 2 de octubre de 2012

Full Circle 65 «Cómo utilizar el cifrado»

Fuente: Elubuntu
Full Circle 65 se ha hecho disponible para descargar con el tema principal “Cómo utilizar el cifrado”, donde ofrece las formas de cifrar la home y la partición swap, si es que en el primer momento no se eligió esta opción.
Portada Full Circle 65
Portada Full Circle 65
Fulll Circle 65 es publicado de manera temprano como el número que corresponde a este mes. En la portada destaca el tema “Cómo utilizar el cifrado” que en resumen pretende ayudar a cifrar la partición home y la swap, si es que cuando se creo un usuario no se eligió está opción.Así también, otro de los temas destacados en Full Circle 65, es la revisión del libro “Ubuntu Made Easy” (Ubuntu Hecho Fácil), y es complementado con una serie de revisiones hacia manuales, orientados a principiantes en está distribución.
Esta edición le da seguimiento a los manuales/howtos, sobre diferentes temas que se han ido publicando de manera parcial.
Algunos de los títulos que encontramos en Full Circle 65:
  • Programando en Python – Parte 37.
  • LibreOffice – Parte 18.
  • Añadir cifrado.
  • Edición de video con Kdenlive – Parte 2.
  • Inskcape – Parte 5.
  • Web Dev – CRUD.
  • Asignar una unidad de red.
  • Revisión de libro: “Ubuntu Hecho Fácil”.
  • Revisión: “Mano de obra” (Manuales Ubuntu).
  • Juego: Humble Indie Bundle V.
  • Y otros más.
Full Circle 65 está disponible para descargar en formato PDF, en inglés, para leer en pantalla y en poco tiempo más para leer en ebook:
pdf.gifDescargar Full Circle 65 «Cómo utilizar el cifrado»
Archivo en formato PDF, en inglés.
16,2 MiB
Este número también se encuentra disponible para visualizar en línea a través de Issuu.
Full Circle Magazine, es la revista electrónica para la comunidad Ubuntu, que se publica de manera independiente. Su ciclo de lanzamientos es de un número cada mes, generalmente en los últimos días.
Se edita en varios formatos, pero solo en inglés, y a veces en otros idiomas, en donde el español hasta ahora no ha sido una constante.

Enlaces de interés:
Página oficial de la revista | fullcirclemagazine.org

viernes, 1 de junio de 2012

Libros gratis para programadores.

Una interesante colección de literatura para programadores completamente gratuita (pero en inglés). El origen de la lista es este.

Programming Language basics

Android – free Ebooks

C / C++ - free Ebooks

ColdFusion - free Ebooks

Delphi / Pascal - free Ebooks

Django - free Ebooks

F# - free Ebooks

HTML / CSS - free Ebooks

Java - free Ebooks

JavaScript - free Ebooks

JavaScript (Node.js specific) - free Ebooks

Latex - free Ebooks

Lisp - free Ebooks

.NET (C# / VB / Nemerle / Visual Studio) - free Ebooks

Objective-C - free Ebooks

Oracle PL/SQL - free Ebooks

Perl - free Ebooks

PHP - free Ebooks

PostgreSQL - free Ebooks

Python - free Ebooks

Ruby - free Ebooks

Ruby on Rails - free Ebooks

SQL (implementation agnostic) - free Ebooks