Arquitectura hexagonal (HA): integrando principios SOLID desde 2008

La Arquitectura Hexagonal, también conocida como Puertos y Adaptadores, del Dr. Alistair Cockburn 2006, es un enfoque y propuesta de diseño de software basado en el #solidprinciples. Estos principios #SOLID son un conjunto de cinco principios de diseño que promueven la creación de código limpio, flexible y mantenible. La H.A. expone que podríamos dividir nuestro Proyecto de Arquitectura. Exploremos cómo HA. se alinea con los principios SOLID en varios puntos clave.

Es importante recalcar que HA no es reciente y ha estado en proceso desde antes de 2008, cuando comencé a aplicarlo. Si bien es posible que no se haya referido a él como HA en ese momento, los principios subyacentes ya se estaban aplicando en nuestra comunidad antes de 2006. La idea central de separar la lógica empresarial de las preocupaciones técnicas y de infraestructura ha sido un tema de interés durante más de dos décadas. Con el paso de los años, ha ido evolucionando y perfeccionándose, adquiriendo diversos nombres como "Puertos y Adaptadores" y "Arquitectura Hexagonal". Esto es efectivo en aplicaciones donde la flexibilidad es esencial (spoiler: #messagebroker, #workflow o #microservices).

 

1. Principio de Responsabilidad Única | Single Responsibility Principle SRP:

HA tiene como objetivo separar las responsabilidades de la lógica empresarial de las preocupaciones técnicas, como la persistencia de los datos o la interfaz de usuario. Esto se logra mediante la creación de adaptadores responsables de interactuar con estas preocupaciones técnicas, permitiendo que los puertos se concentren únicamente en sus cosas.

2. Principio Abierto/Cerrado | Open/Closed Principle OCP:

HA promueve la extensibilidad y la flexibilidad. Los puertos definen interfaces que pueden implementarse y deben implementarse mediante múltiples adaptadores (clases que hacen que suceda la magia). Cuando se requiere nueva funcionalidad, se pueden crear nuevos adaptadores para implementar estas interfaces sin modificar el código existente en los puertos. Esto cumple con el OCP, lo que permite la extensión sin alterar el código existente.

3. Principio de sustitución de Liskov | Liskov Substitution Principle LSP:

Al definir interfaces en los puertos, los adaptadores deben cumplir con estas interfaces. Esto garantiza que los adaptadores sean intercambiables sin afectar el comportamiento del sistema. El cumplimiento del LSP permite la sustitución de adaptadores sin cambios en la lógica de la aplicación principal.

4. Principio de segregación de interfaces | Interface Segregation Principle ISP:

En HA las interfaces en los puertos se mantienen específicas para las necesidades de los clientes. Esto evita que los clientes se vean obligados a implementar métodos no utilizados. Al dividir las interfaces en puertos según las necesidades de los clientes, se logra el cumplimiento del ISP.

5. Principio de inversión de dependencia | Dependency Inversion Principle DIP:

HA. invierte las dependencias al permitir que los puertos definan las interfaces que implementan los adaptadores. Esto significa que los puertos no dependen de implementaciones concretas sino de abstracciones (las interfaces). Aplicar el DIP facilita la sustituibilidad de los componentes mejorando la mantenibilidad, la flexibilidad, facilitando la solidez de la solución y ahorrando dinero en tiempo.

Fuentes:

 Para conocer más sobre esta arquitectura consulta el creador del termino Alistair Cockburn en archive.org , ya que, el su web está en actualización alistair.cockburn.us.

 Robert C. Martin (Uncle Bob)

 

Libros relacionados con la gnosis

La gnosis.

Un conjunto de corrientes espirituales y filosóficas que buscan la comprensión directa y trascendental de la realidad, generalmente a través de la experiencia mística o la revelación interior. Los textos más importantes de la gnosis provienen de una variedad de tradiciones, principalmente del cristianismo primitivo, el hermetismo, el maniqueísmo y el gnosticismo helenístico. Aquí menciono algunos de los libros y textos más relevantes relacionados con la gnosis:

1. Evangelios gnósticos.

   Muchos textos gnósticos fueron descubiertos en el siglo XX, especialmente con el hallazgo de los Manuscritos de Nag Hammadi (1945) en Egipto. Estos evangelios ofrecen una visión alternativa y más esotérica de las enseñanzas de Jesús, en contraste con los textos canónicos del Nuevo Testamento.
   
   El Evangelio de Tomás: Un conjunto de 114 dichos de Jesús, muchos de los cuales enfatizan el conocimiento interior y la autotransformación.
   El Evangelio de Felipe: Un texto que aborda temas de la naturaleza del alma, la relación entre lo divino y lo humano, y los sacramentos.
   El Evangelio de la Verdad: Un texto atribuido a Valentín, que presenta una visión mística de la verdad, el conocimiento y la creación.
   El Evangelio de María Magdalena: Aunque fragmentario, este evangelio destaca el papel de María Magdalena como una figura clave en la transmisión del conocimiento secreto de Jesús.
   
   
   

2. La "Apocalipsis" de Juan.

   En los primeros tiempos del cristianismo, este texto fue considerado un apocalipsis de corte gnóstico, ya que sus visiones del mundo están impregnadas de simbolismo esotérico y conocimiento oculto. Aunque en gran parte se incluyó en el canon cristiano, es relevante para estudios gnósticos por sus descripciones de la lucha espiritual y el conocimiento superior.
   
   

3. El "Corpus Hermeticum

   Una serie de textos que exploran la filosofía hermética, el conocimiento divino y la transformación del alma. Aunque no es estrictamente un texto gnóstico, comparte muchas ideas fundamentales, como la búsqueda de la sabiduría esotérica y la salvación a través del conocimiento. Se le atribuye a Hermes Trismegisto, una figura mítica que combina elementos de Hermes (dios griego) y Thoth (dios egipcio).
    

4. El "Libro de los Secretos de Enoch

   
   También conocido como el "Segundo Libro de Enoc", este texto apócrifo judío (no parte del canon bíblico) describe una ascensión mística al cielo de Enoc, un personaje bíblico. En él se exponen conocimientos esotéricos sobre la naturaleza del universo, los ángeles y las jerarquías divinas, características comunes de la gnosis.
   
   

5. Los textos de Nag Hammadi

   Estos textos son una compilación clave de la literatura gnóstica descubierta en 1945, y son fundamentales para entender el pensamiento gnóstico. Algunos de los más importantes incluyen:
   
   • El Tratado Tripartito
   • El Apócrifo de Juan
   • La Carta de Pedro a Felipe
    

6. La Pistis Sophia

   Es un texto gnóstico cristiano muy influyente que describe la historia de la caída de Sophia (sabiduría) y su búsqueda de redención a través del conocimiento. La obra trata sobre la relación entre la humanidad, el mundo material, y las entidades espirituales, y cómo el alma puede ser redimida por medio del conocimiento.
    

7. El Zohar" (La Esplendidez)

   Aunque es un texto central en la **Cábala judía** y no se clasifica estrictamente como gnóstico, contiene ideas que se superponen con la gnosis, especialmente en lo que respecta a la naturaleza oculta de Dios, el alma y el conocimiento divino. Es fundamental para aquellos que exploran el esoterismo y las tradiciones místicas.
    

8. Las enseñanzas de Plotino.

   Plotino, el filósofo neoplatónico, influyó profundamente en el desarrollo de la gnosis. Su obra más importante es las **Enéadas**, que explora la naturaleza de la realidad, el alma, la divinidad, y la búsqueda del conocimiento trascendental.
    

9. La doctrina secreta" de Helena Blavatsky.

   Aunque no es un texto antiguo, **Helena Petrovna Blavatsky**, cofundadora de la Sociedad Teosófica, es una figura clave en el renacer moderno del esoterismo y la gnosis. Su obra **La doctrina secreta** explora conocimientos ocultos sobre la creación, la humanidad y el cosmos desde una perspectiva mística y gnóstica.
   
   

10. El libro tibetano de los muertos.

    Aunque es un texto budista tibetano, muchas de sus enseñanzas, que tratan sobre el despertar espiritual y el conocimiento de la muerte y el más allá, resuenan con la tradición gnóstica en su énfasis en la iluminación personal y el conocimiento de la realidad última.

¿Qué caracteriza a estos textos

Los textos gnósticos generalmente comparten temas comunes, tales como:

• El dualismo: La lucha entre el bien y el mal, la luz y la oscuridad, lo espiritual y lo material.
• El conocimiento esotérico: La idea de que solo unos pocos iniciados pueden alcanzar el conocimiento verdadero.
• El desprecio por lo material: La visión de que el mundo material es imperfecto, corrupto o incluso ilusorio.
• La salvación a través del conocimiento: La liberación del alma solo se alcanza mediante el conocimiento directo y trascendental.

Estos libros han tenido una influencia duradera en la filosofía occidental, las religiones místicas, y las tradiciones esotéricas que siguen hasta nuestros días.

 

Abstract Factory design pattern with both interfaces and enumerations approaches. Examples in some popular languages.

The Abstract Factory design pattern is a creational pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes. Below is a Java implementation of the Abstract Factory design pattern.

Implementation of Abstract Factory Pattern

1. Abstract Factory Interface: Defines methods for creating abstract products.
2. Concrete Factories: Implement the creation of specific families of products.
3. Abstract Product Interfaces: Define the types of products.
4. Concrete Products: Implement the abstract product interfaces.
5. Client Code: Uses the factory and products through their interfaces.

 

---

Example 1: Abstract Factory with Interfaces in Java

Below is an example implementation of the Abstract Factory pattern using interfaces in a banking context for creating different types of loans.

// Abstract Factory
interface LoanFactory {
    Loan createLoan();
}

// Abstract Product
interface Loan {
    void getDetails();
}

// Concrete Products
class MortgageLoan implements Loan {
    @Override
    public void getDetails() {
        System.out.println("This is a Mortgage Loan.");
    }
}

class PersonalLoan implements Loan {
    @Override
    public void getDetails() {
        System.out.println("This is a Personal Loan.");
    }
}

class AutoLoan implements Loan {
    @Override
    public void getDetails() {
        System.out.println("This is an Auto Loan.");
    }
}

// Concrete Factories
class MortgageLoanFactory implements LoanFactory {
    @Override
    public Loan createLoan() {
        return new MortgageLoan();
    }
}

class PersonalLoanFactory implements LoanFactory {
    @Override
    public Loan createLoan() {
        return new PersonalLoan();
    }
}

class AutoLoanFactory implements LoanFactory {
    @Override
    public Loan createLoan() {
        return new AutoLoan();
    }
}

// Client
public class BankingApplication {
    public static void main(String[] args) {
        LoanFactory mortgageFactory = new MortgageLoanFactory();
        Loan mortgageLoan = mortgageFactory.createLoan();
        mortgageLoan.getDetails();

        LoanFactory personalFactory = new PersonalLoanFactory();
        Loan personalLoan = personalFactory.createLoan();
        personalLoan.getDetails();

        LoanFactory autoFactory = new AutoLoanFactory();
        Loan autoLoan = autoFactory.createLoan();
        autoLoan.getDetails();
    }
}

---

Example 2: Abstract Factory with Enumerations in Java

This example uses enums to manage the loan creation logic. Each enum instance acts as a factory.

// Abstract Product
abstract class Loan {
    abstract void getDetails();
}

// Concrete Products
class MortgageLoan extends Loan {
    @Override
    void getDetails() {
        System.out.println("This is a Mortgage Loan.");
    }
}

class PersonalLoan extends Loan {
    @Override
    void getDetails() {
        System.out.println("This is a Personal Loan.");
    }
}

class AutoLoan extends Loan {
    @Override
    void getDetails() {
        System.out.println("This is an Auto Loan.");
    }
}

// Abstract Factory using Enum
enum LoanFactory {
    MORTGAGE {
        @Override
        public Loan createLoan() {
            return new MortgageLoan();
        }
    },
    PERSONAL {
        @Override
        public Loan createLoan() {
            return new PersonalLoan();
        }
    },
    AUTO {
        @Override
        public Loan createLoan() {
            return new AutoLoan();
        }
    };

    public abstract Loan createLoan();
}

// Client
public class BankingApplicationWithEnum {
    public static void main(String[] args) {
        Loan mortgageLoan = LoanFactory.MORTGAGE.createLoan();
        mortgageLoan.getDetails();

        Loan personalLoan = LoanFactory.PERSONAL.createLoan();
        personalLoan.getDetails();

        Loan autoLoan = LoanFactory.AUTO.createLoan();
        autoLoan.getDetails();
    }
}

---

Key Points:

1. Using Interfaces:

   • Provides flexibility and extensibility by allowing additional types of loans and factories without modifying existing code.
   • Clear separation of concerns with individual factory classes for each loan type.

2. Using Enumerations:

   • Simplifies factory management as enum constants inherently represent different factories.
   • Reduces the overhead of creating multiple factory classes but is less flexible for large-scale systems.

  

Advantages and disadvantages of using

---

Advantages

1. Encapsulation of Object Creation:

   • Hides the details of how objects are created and assembled, making code cleaner and easier to manage.

2. Consistency:

   • Ensures that products created by the factory are compatible with each other (e.g., objects from the same family).

3. Scalability:

   • Adding new product families is straightforward. You can add a new factory and corresponding products without altering existing code.

4. Flexibility:

   • Decouples client code from concrete implementations, allowing easy swapping of product families by simply changing the factory instance.

5. Promotes Dependency Inversion Principle:

   • Clients depend on abstractions (interfaces or abstract classes) rather than concrete classes, enhancing testability and maintainability.

6. Centralized Creation Logic:

   • All object creation is handled in one place, making it easier to update or modify.

---

Disadvantages

1. Complexity:

   • Introduces additional layers of abstraction and requires more classes and interfaces, which can make the system more complex.

2. Difficult to Extend Individual Products:

   • Modifying or adding a single product in a family may require changes in all the factories or creating a new product family.

3. Overhead for Small Systems:

   • In systems with limited object types or families, the pattern can be overkill and unnecessarily increase codebase size.

4. Coupling Between Factories and Products:

   • Factories are tightly coupled to the specific product hierarchies they create, which can limit flexibility in some cases.

5. Rigid Structure:

   • While adding a new family is straightforward, adding support for a new product across existing families can be cumbersome as it may require changes to all factories.

---

When to Use Abstract Factory

• Use the Abstract Factory pattern when:

  • The system needs to work with multiple families of related objects.
  • You want to isolate the creation process of objects from their usage.
  • Ensuring compatibility among objects is a priority.
  • There’s a need to change the product family dynamically at runtime.

• Avoid using the pattern when:

  • The system has simple requirements with few types of objects.
  • The overhead of creating factories and products outweighs the benefits.

 

---

Example 1: Abstract Factory with Interfaces in C#

Below is the implementation of the Abstract Factory pattern using interfaces in C#.

// Abstract Factory
public interface ILoanFactory
{
    ILoan CreateLoan();
}

// Abstract Product
public interface ILoan
{
    void GetDetails();
}

// Concrete Products
public class MortgageLoan : ILoan
{
    public void GetDetails()
    {
        Console.WriteLine("This is a Mortgage Loan.");
    }
}

public class PersonalLoan : ILoan
{
    public void GetDetails()
    {
        Console.WriteLine("This is a Personal Loan.");
    }
}

public class AutoLoan : ILoan
{
    public void GetDetails()
    {
        Console.WriteLine("This is an Auto Loan.");
    }
}

// Concrete Factories
public class MortgageLoanFactory : ILoanFactory
{
    public ILoan CreateLoan()
    {
        return new MortgageLoan();
    }
}

public class PersonalLoanFactory : ILoanFactory
{
    public ILoan CreateLoan()
    {
        return new PersonalLoan();
    }
}

public class AutoLoanFactory : ILoanFactory
{
    public ILoan CreateLoan()
    {
        return new AutoLoan();
    }
}

// Client
public class BankingApplication
{
    public static void Main(string[] args)
    {
        ILoanFactory mortgageFactory = new MortgageLoanFactory();
        ILoan mortgageLoan = mortgageFactory.CreateLoan();
        mortgageLoan.GetDetails();

        ILoanFactory personalFactory = new PersonalLoanFactory();
        ILoan personalLoan = personalFactory.CreateLoan();
        personalLoan.GetDetails();

        ILoanFactory autoFactory = new AutoLoanFactory();
        ILoan autoLoan = autoFactory.CreateLoan();
        autoLoan.GetDetails();
    }
}

---

Example 2: Abstract Factory with Enumerations in C#

This example uses enumerations to manage loan creation logic in C#.

// Abstract Product
public abstract class Loan
{
    public abstract void GetDetails();
}

// Concrete Products
public class MortgageLoan : Loan
{
    public override void GetDetails()
    {
        Console.WriteLine("This is a Mortgage Loan.");
    }
}

public class PersonalLoan : Loan
{
    public override void GetDetails()
    {
        Console.WriteLine("This is a Personal Loan.");
    }
}

public class AutoLoan : Loan
{
    public override void GetDetails()
    {
        Console.WriteLine("This is an Auto Loan.");
    }
}

// Abstract Factory using Enum
public enum LoanFactory
{
    MORTGAGE,
    PERSONAL,
    AUTO
}

public static class LoanFactoryExtensions
{
    public static Loan CreateLoan(this LoanFactory factory)
    {
        return factory switch
        {
            LoanFactory.MORTGAGE => new MortgageLoan(),
            LoanFactory.PERSONAL => new PersonalLoan(),
            LoanFactory.AUTO => new AutoLoan(),
            _ => throw new ArgumentException("Invalid Loan Type")
        };
    }
}

// Client
public class BankingApplicationWithEnum
{
    public static void Main(string[] args)
    {
        Loan mortgageLoan = LoanFactory.MORTGAGE.CreateLoan();
        mortgageLoan.GetDetails();

        Loan personalLoan = LoanFactory.PERSONAL.CreateLoan();
        personalLoan.GetDetails();

        Loan autoLoan = LoanFactory.AUTO.CreateLoan();
        autoLoan.GetDetails();
    }
}

---

Key Points for Both Examples:

1. Using Interfaces:

   • Provides a clean separation of concerns.
   • Adding new loan types requires creating new concrete product and factory classes.

2. Using Enumerations:

   • Simplifies the logic by using a single enum to encapsulate all factory behavior.
   • Extensions on the enum provide centralized logic for creating different loan types.
   • Less flexible if individual factories or additional customization is required.

Both examples effectively demonstrate the Abstract Factory pattern in a C# context!

 

 

 

Resilience Patterns common adv disadv

 

In software design, resilience patterns are strategies or techniques to ensure systems can recover gracefully and continue functioning despite failures, disruptions, or unexpected events. These patterns are especially relevant in distributed systems, cloud environments, and large-scale applications where failures are inevitable.

Here are common resilience patterns in software:

---

1. Retry Pattern

• Description: Automatically retry a failed operation with a delay or exponential backoff to account for transient failures.
• Use Case: Network timeouts, temporary unavailability of services.
• Example:
  • A payment service retries a transaction after a brief pause if the upstream payment gateway fails to respond.
• Tools: Libraries like Polly (C#), Resilience4j (Java).

---

2. Circuit Breaker Pattern

• Description: Prevent repeated attempts to perform an operation that is likely to fail. When failures cross a threshold, the circuit "opens," blocking further calls for a cooldown period.
• Use Case: Avoid cascading failures due to an unavailable or slow service.
• Example:
  • If a database connection fails consistently, the application stops retrying for a set period and quickly responds with fallback logic.
• Tools: Hystrix (Netflix), Resilience4j (Java), Polly (C#).

---

3. Fallback Pattern

• Description: Provide an alternative response or behavior when an operation fails.
• Use Case: Mitigating the impact of failure.
• Example:
  • If a recommendation service fails, return static or cached recommendations instead.
• Tools: Integrated into circuit breaker tools like Hystrix or Resilience4j.

---

4. Timeout Pattern

• Description: Set a maximum duration for an operation to complete; if it exceeds that duration, abort the operation.
• Use Case: Prevent a system from waiting indefinitely for a slow or unresponsive service.
• Example:
  • An API call to a third-party service times out after 5 seconds, returning an error or fallback response.

---

5. Bulkhead Pattern

• Description: Isolate critical components or resources into separate "pools" to prevent failure in one area from affecting others.
• Use Case: Protect a system from resource exhaustion caused by a single failure.
• Example:
  • If a particular service consumes too many threads or connections, it is isolated in its own thread pool to prevent affecting the entire application.
• Tools: Thread pools, containerization (e.g., Kubernetes).

---

6. Rate Limiting and Throttling

• Description: Limit the number of requests or operations that can occur in a given time period.
• Use Case: Protect against excessive load, abuse, or denial-of-service attacks.
• Example:
  • An API limits clients to 100 requests per minute to prevent server overload.
• Tools: API Gateways, Redis (rate limiting), cloud-based tools like AWS API Gateway.

---

7. Idempotency Pattern

• Description: Ensure that an operation can be performed multiple times without changing the result.
• Use Case: Retry logic where multiple attempts may occur.
• Example:
  • Retrying a payment request should not result in multiple charges.
• Tools: Use unique identifiers (e.g., idempotency keys) to track operations.

---

8. Failover Pattern

• Description: Switch to a backup system or component when the primary one fails.
• Use Case: Ensure high availability and continuity.
• Example:
  • If the primary database server fails, traffic is routed to a replica or standby database.
• Tools: Load balancers, cloud failover mechanisms.

---

9. Data Replication Pattern

• Description: Maintain copies of data across different nodes or regions to improve availability and resilience.
• Use Case: Recover from hardware failures or data loss.
• Example:
  • Data replication in distributed databases like Cassandra or PostgreSQL replicas.
• Tools: Cloud databases (e.g., AWS RDS Multi-AZ), distributed storage (e.g., HDFS).

---

10. Chaos Engineering

• Description: Introduce controlled failures to test and improve system resilience proactively.
• Use Case: Validate a system’s ability to handle failures before they occur in production.
• Example:
  • Simulating server failures or network latency using tools like Gremlin or Netflix Chaos Monkey.

---

11. Compensating Transaction Pattern

• Description: Perform a rollback or corrective operation if a transaction across services fails.
• Use Case: Ensuring consistency in distributed systems.
• Example:
  • If booking a hotel succeeds but booking a flight fails, cancel the hotel reservation.

---

12. Message Queue and Event-Driven Architecture

• Description: Use message queues to decouple services and ensure messages are retried or persisted during failures.
• Use Case: Decouple systems to avoid cascading failures.
• Example:
  • Using Kafka or RabbitMQ to persist messages during an outage and replay them later.

---

Why Use Resilience Patterns?

Resilience patterns are critical for:

• Ensuring high availability in distributed systems.
• Minimizing downtime caused by hardware, software, or network failures.
• Improving user experience by handling failures gracefully.
• Protecting system resources and preventing cascading failures.

By implementing these patterns, software systems can recover faster, adapt to transient issues, and continue delivering reliable performance even under adverse conditions.

 

---

Advantages and Disadvantages

Here’s a detailed explanation of the advantages and disadvantages of each resilience pattern:

 

1. Retry Pattern

• Description: Automatically retry a failed operation after a delay or with an exponential backoff.

Advantages:

• Simple to implement for transient failures like timeouts or temporary unavailability.
• Improves reliability by overcoming temporary issues without user intervention.
• Allows seamless recovery without manual intervention.

Disadvantages:

• May cause overload if retries are not controlled (e.g., excessive retries can overwhelm a failing service).
• Wastes resources when a failure is not transient (e.g., permanent failure cases).
• Can cause longer delays if retries are too aggressive.

Best Use Case:

• For transient failures (e.g., temporary network glitches, database deadlocks).

---

2. Circuit Breaker Pattern

• Description: Stops repeated attempts to perform a failing operation. After failures reach a threshold, the circuit "opens" to block further calls temporarily.

Advantages:

• Prevents cascading failures by quickly detecting and halting requests to faulty services.
• Improves system stability under failure conditions.
• Reduces unnecessary load on failing services.

Disadvantages:

• Circuit recovery (from open to closed) can cause temporary "thundering herd" issues when many requests retry simultaneously.
• Requires tuning thresholds and cooldown periods, which can be complex.
• False positives may occur, causing healthy services to be temporarily blocked.

Best Use Case:

• For dependent services that may fail or slow down, such as external APIs or databases.

---

3. Fallback Pattern

• Description: Provides an alternative response or behavior when an operation fails.

Advantages:

• Improves user experience by providing a degraded response instead of a failure.
• Prevents complete system breakdown in case of failures.
• Supports graceful degradation under partial failure scenarios.

Disadvantages:

• Fallback logic might not always meet functional requirements (e.g., stale or inaccurate data).
• Adds extra implementation effort to provide meaningful fallback mechanisms.
• May mask underlying issues if fallback is used excessively.

Best Use Case:

• When alternative data or cached responses can substitute for a failing service.

---

4. Timeout Pattern

• Description: Sets a maximum time for an operation to complete, aborting it if it exceeds the limit.

Advantages:

• Prevents the system from hanging indefinitely due to unresponsive components.
• Frees up resources by abandoning slow operations.
• Avoids cascading failures caused by blocked threads or connections.

Disadvantages:

• Requires careful timeout tuning; too short may trigger false timeouts, too long may delay recovery.
• May lead to incomplete operations or partial failures.
• Combined with retries, it can increase load if not managed properly.

Best Use Case:

• For network calls, database queries, or external service requests that might become unresponsive.

---

5. Bulkhead Pattern

• Description: Isolates resources into separate pools to prevent one failure from impacting the entire system.

Advantages:

• Limits the blast radius of a failure, ensuring other components remain unaffected.
• Protects system stability by isolating resource-hungry services.
• Useful for handling varying levels of load across services.

Disadvantages:

• Resource isolation adds complexity (e.g., configuring multiple thread pools or containers).
• May lead to underutilized resources if isolation is overprovisioned.
• Incorrect configuration can still cause bottlenecks or resource exhaustion.

Best Use Case:

• For resource-constrained systems with critical components that must remain unaffected by failures in others.

---

6. Rate Limiting and Throttling

• Description: Limits the number of requests processed within a given time to prevent system overload.

Advantages:

• Prevents overloading and potential denial of service.
• Ensures fair usage of system resources.
• Improves system stability during traffic spikes.

Disadvantages:

• May block legitimate requests if limits are too strict.
• Introduces additional latency for throttled requests.
• Requires monitoring and dynamic configuration to adjust for varying loads.

Best Use Case:

• For APIs or services with high load or risk of abuse.

---

7. Idempotency Pattern

• Description: Ensures that an operation can be executed multiple times without side effects.

Advantages:

• Safeguards against unintended duplicate operations caused by retries.
• Ensures consistency in distributed systems.
• Reduces the risk of data corruption or inconsistency.

Disadvantages:

• Requires tracking of request states (e.g., using unique identifiers like idempotency keys).
• Adds complexity to design and increases storage overhead.
• Not all operations are naturally idempotent (e.g., payment processing).

Best Use Case:

• For retry mechanisms where duplicates could cause issues (e.g., billing or payment APIs).

---

8. Failover Pattern

• Description: Switches to a backup component or system when the primary one fails.

Advantages:

• Ensures high availability and reduces downtime.
• Provides seamless failover with minimal user impact.
• Redundant systems improve fault tolerance.

Disadvantages:

• Requires additional infrastructure and redundancy (increased cost).
• Data synchronization between primary and backup can be challenging.
• Failover mechanisms can introduce latency during switching.

Best Use Case:

• For critical systems requiring high availability, such as databases or load-balanced services.

---

9. Data Replication Pattern

• Description: Maintains copies of data across multiple nodes or regions.

Advantages:

• Improves availability and resilience against hardware or node failures.
• Enhances read performance by serving data from multiple locations.
• Protects against data loss.

Disadvantages:

• Increases data storage and synchronization costs.
• May introduce eventual consistency issues in distributed systems.
• Complex to manage across multiple nodes or regions.

Best Use Case:

• For databases or distributed systems requiring fault tolerance and high availability.

---

10. Chaos Engineering

• Description: Intentionally injects failures to test system resilience.

Advantages:

• Proactively identifies weaknesses and improves fault tolerance.
• Helps teams prepare for real-world failure scenarios.
• Strengthens confidence in system resilience.

Disadvantages:

• Requires careful planning to avoid unintended system disruptions.
• Can cause real outages if experiments are not properly controlled.
• Adds operational overhead for conducting and monitoring tests.

Best Use Case:

• For large-scale systems where failures are inevitable, such as cloud-native applications.

---

11. Compensating Transaction Pattern

• Description: Rolls back or corrects changes made by failed transactions.

Advantages:

• Ensures data consistency across distributed systems.
• Mitigates the impact of failures in multi-step workflows.
• Supports "eventual consistency" in distributed systems.

Disadvantages:

• Increases implementation complexity.
• Requires careful design to handle rollback scenarios correctly.
• May introduce latency when handling failures.

Best Use Case:

• For distributed systems or microservices requiring transactional integrity.

---

12. Message Queue and Event-Driven Architecture

• Description: Decouples services using message queues to persist and retry failed messages.

Advantages:

• Increases system reliability by enabling asynchronous processing.
• Ensures messages are not lost during failures.
• Decouples systems to avoid cascading failures.

Disadvantages:

• Adds latency compared to synchronous communication.
• Requires infrastructure like message brokers (e.g., Kafka, RabbitMQ).
• Potential message duplication or reordering must be handled.

Best Use Case:

• For systems requiring asynchronous communication or retries, such as event-driven applications.

---

By carefully choosing the right resilience pattern for each failure scenario, systems can achieve high availability, stability, and reliability.

 

 

Some of the most used and most common design patterns.

 

Here’s a list of the most used and most common design patterns, categorized by their type and popularity in software development:

---

1. Creational Patterns

Focus on object creation mechanisms, providing flexibility and efficiency.

1. Singleton

   • Ensures a class has only one instance and provides a global point of access to it.

   • Commonly used for logging, configuration, and managing shared resources.

2. Factory Method

   • Defines an interface for creating objects but lets subclasses decide which class to instantiate.

   • Commonly used in frameworks for creating objects without specifying exact classes.

3. Abstract Factory

   • Provides an interface to create families of related or dependent objects without specifying their concrete classes.

   • Used in GUI libraries (e.g., different themes for UI components).

4. Builder

   • Constructs complex objects step-by-step, separating the construction from representation.

   • Useful for creating immutable objects like StringBuilder or for object hierarchies.

5. Prototype

   • Creates new objects by cloning an existing object (prototypes).

   • Used when object creation is costly, e.g., in game engines or document editors. 

     
     
      

---

2. Structural Patterns

Deal with composing classes or objects into larger structures while keeping them flexible and efficient.

1. Adapter

   • Allows incompatible interfaces to work together by translating one interface to another.

   • Commonly used in legacy system integrations.

2. Decorator

   • Adds functionality to an object dynamically without altering its structure.

   • Common in user interface components (e.g., adding scrollbars or borders).

3. Facade

   • Provides a simplified interface to a complex subsystem.

   • Often used in APIs and libraries to hide implementation details.

4. Composite

   • Composes objects into tree structures to represent part-whole hierarchies.

   • Frequently used in GUIs and file system representations.

5. Proxy

   • Provides a surrogate or placeholder for another object to control access to it.

   • Used for lazy initialization, access control, and logging.

6. Bridge

   • Decouples an abstraction from its implementation so that both can vary independently.

   • Common in graphical rendering libraries.

7. Flyweight

   • Reduces memory usage by sharing as much data as possible with similar objects.

   • Used in caching mechanisms or text editors for character storage.

---

3. Behavioral Patterns

Concerned with the communication and interaction between objects.

1. Strategy

   • Encapsulates algorithms and allows them to be interchangeable at runtime.

   • Common in payment processing systems and sorting algorithms.

2. Observer

   • Defines a dependency between objects so that when one changes state, its dependents are notified.

   • Commonly used in event-driven programming and GUIs.

3. Command

   • Encapsulates a request as an object, allowing parameterization and queuing of requests.

   • Used in undo/redo systems and job scheduling.

4. State

   • Allows an object to change its behavior when its state changes.

   • Frequently used in workflows or state machines.

5. Template Method

   • Defines the skeleton of an algorithm in a base class, allowing subclasses to override specific steps.

   • Common in frameworks and libraries.

6. Chain of Responsibility

   • Passes a request along a chain of handlers until it is handled.

   • Used in logging systems or middleware pipelines.

7. Mediator

   • Centralizes communication between objects to reduce dependencies.

   • Common in chat applications or GUIs.

8. Iterator

   • Provides a way to access elements of a collection sequentially without exposing its underlying structure.

   • Used in collections and data structures.

9. Visitor

   • Adds new operations to objects without modifying their classes.

   • Used in compilers or processing hierarchical structures.

10. Memento

    • Captures an object’s state to restore it later.

    • Commonly used in undo functionality.

---

Additional Modern Patterns

Beyond the classical Gang of Four patterns, these modern patterns are also widely used:

1. Dependency Injection (DI)

   • Provides dependencies to objects from an external source, improving modularity.

   • A cornerstone of frameworks like Spring or .NET Core.

2. Model-View-Controller (MVC)

   • Separates an application into three components: Model (data), View (UI), and Controller (logic).

   • Dominant in web development frameworks like Ruby on Rails and ASP.NET MVC.

3. Model-View-ViewModel (MVVM)

   • Variant of MVC, primarily used in UI frameworks like Angular or WPF.

4. Repository

   • Abstracts access to data sources, providing a clean separation between the application and data layer.

   • Common in DDD (Domain-Driven Design).

5. CQRS (Command Query Responsibility Segregation)

   • Separates read and write operations into different models.

   • Used in scalable architectures.

6. Event Sourcing

   • Represents the state of an object as a sequence of events.

   • Common in microservices and systems requiring strong audit trails.

---

Most Used Patterns in Practice

1. Singleton

2. Factory Method

3. Strategy

4. Observer

5. MVC/MVVM

6. Dependency Injection

7. Repository

8. Adapter

9. Decorator

10. Command

These patterns are versatile, widely applicable, and form the backbone of most modern software systems.

Los patrones de diseño más utilizados en el desarrollo de software

Están organizados en tres categorías principales según el libro "Design Patterns: Elements of Reusable Object-Oriented Software" (Gang of Four, GoF). A continuación, los patrones más usados dentro de cada categoría y algunos otros populares adicionales:

---

1. Creacionales

Estos patrones abordan la creación de objetos, asegurando que el sistema sea independiente de cómo se crean, componen y representan.

1. Singleton

   • Garantiza que una clase tenga una única instancia y proporciona un punto de acceso global a ella.

2. Factory Method

   • Define una interfaz para crear objetos, pero permite que las subclases decidan cuál clase instanciar.

3. Abstract Factory

   • Proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.

4. Builder

   • Separa la construcción de un objeto complejo de su representación, permitiendo que el mismo proceso de construcción cree diferentes representaciones.

5. Prototype

   • Permite clonar objetos existentes en lugar de crearlos desde cero, evitando el costo de inicialización compleja.

---

2. Estructurales

Estos patrones se ocupan de cómo componer clases y objetos para formar estructuras más grandes.

1. Adapter

   • Permite que clases con interfaces incompatibles trabajen juntas mediante un "adaptador".

2. Decorator

   • Añade funcionalidad adicional a un objeto de forma dinámica.

3. Proxy

   • Proporciona un sustituto o marcador de posición para controlar el acceso a un objeto.

4. Composite

   • Compone objetos en estructuras de árbol para representar jerarquías parte-todo, permitiendo que los clientes traten objetos individuales y compuestos de manera uniforme.

5. Bridge

   • Desacopla una abstracción de su implementación para que ambas puedan variar de manera independiente.

6. Facade

   • Proporciona una interfaz simplificada a un conjunto de interfaces en un subsistema.

7. Flyweight

   • Reduce el costo de creación de objetos, reutilizando instancias existentes cuando es posible.

---

3. Comportamentales

Estos patrones se centran en la interacción y la responsabilidad entre objetos.

1. Strategy

   • Define una familia de algoritmos, encapsula cada uno y los hace intercambiables.

2. Observer

   • Permite que un objeto notifique a múltiples objetos interesados cuando cambia su estado.

3. Command

   • Encapsula una solicitud como un objeto, permitiendo parametrizar clientes con diferentes solicitudes, hacer colas o registros de comandos, y soportar deshacer/rehacer.

4. State

   • Permite que un objeto cambie su comportamiento cuando cambia su estado interno.

5. Template Method

   • Define el esqueleto de un algoritmo en una operación, permitiendo que las subclases redefinan ciertos pasos sin cambiar la estructura general.

6. Mediator

   • Descentraliza la comunicación entre objetos mediante un mediador.

7. Chain of Responsibility

   • Permite que varios objetos manejen una solicitud, pasando la solicitud a lo largo de una cadena.

8. Iterator

   • Proporciona una manera de acceder a los elementos de un objeto compuesto de forma secuencial sin exponer su representación subyacente.

9. Visitor

   • Permite agregar nuevas operaciones a estructuras de objetos sin modificar sus clases.

10. Memento

    • Captura y externaliza el estado interno de un objeto para poder restaurarlo más tarde.

---

Patrones Adicionales y Modernos

Además de los patrones clásicos de GoF, algunos patrones más modernos son ampliamente usados en el desarrollo de software:

1. Dependency Injection (DI)

   • Permite inyectar dependencias en lugar de que un objeto las cree por sí mismo.

2. Model-View-Controller (MVC)

   • Desglosa una aplicación en tres componentes principales: modelo, vista y controlador.

3. Repository

   • Abstrae la lógica para acceder a datos de una base de datos o fuente externa.

4. Unit of Work

   • Mantiene un registro de los cambios realizados a los datos para coordinar actualizaciones atómicas.

5. Event Sourcing

   • Representa el estado de una entidad como una secuencia de eventos en lugar de un único estado.

6. CQRS (Command Query Responsibility Segregation)

   • Separa las operaciones de lectura (query) de las operaciones de escritura (command) en diferentes modelos.

---

Estos patrones forman la base de muchas soluciones de software modernas y se eligen según las necesidades del problema y el contexto de la aplicación.

CRUD con PHP5 OOP y Patron de Diseño MVC

Modelo-Vista-Controlador

MVC: es un patrón arquitectónico usado en ingeniería de software. Su uso exitoso aísla la lógica de negocio de las consideraciones de interfaz de usuario y la persistencia de la base de datos, lo que resulta en una aplicación donde es más fácil de modificar la apariencia visual de la aplicación o las reglas de negocio subyacentes sin afectar uno al otro. En MVC, el modelo representa la información (los datos por lo general pero no únicamente en RDBMS) de la solicitud; la vista se corresponde con los elementos de la interfaz de usuario (Preferiblemente independiente del dispositivo), tales como artículos de texto, casillas de verificación, y así sucesivamente; y el controlador gestiona la comunicación de los datos (o flujo del programa) y las reglas de negocio que se utilizan para manipular los datos hacia y desde el modelo. 

Modelo - representa el comportamiento de las aplicaciones y datos. También se conoce comúnmente como el dominio. El dominio representa el problema que está tratando de resolver. 

Vista - representa la presentación. Puede consultar el modelo de su estado y generar la presentación de los objetos del modelo. 

Controlador - representa aplicaciones de flujo de trabajo, que procesa los parámetros de la petición y decide qué hacer con base en ellos. Esto, por lo general, implica la manipulación del modelo y se presentan los datos en la vista seleccionada.

Ejemplo de una Aplicación CRUD

Para este taller de PHP en POO se ha creado un gestor de contactos simples que soporta las operaciones básicas CRUD. El usuario puede añadir un nuevo contacto, borrar, visualizar un detalle de contacto y visualización de la lista de todos los contactos. Me referiré a estas operaciones como las acciones. Por lo tanto, esta aplicación tiene cuatro acciones diferentes: Añadir un contacto, Eliminar un contacto, modificar un contacto y mostrar la lista de contactos. Adicionalmente y no forma parte explícitamente del CRUD, se puede ordenar los contactos. 

CRUD

Se conoce comúnmente por sus siglas en Ingles Create, Read, Update and Delete. Tiene varios acrónimos en Español.

Al pensar en el patrón MVC se puede ver un aspecto negativo y varios aspectos positivos. Lo negativo es que el patrón MVC introduce una complejidad en el proyecto que puede ser una carga para aplicaciones sencillas, pero a medida que crece su aplicación este aspecto negativo es más ponderado por los aspectos positivos. Voy a describir algunos aspectos positivos que se me ocurren.

MVC separa el modelo de la vista, es decir, los datos de su representación. La separación del modelo de la parte de presentación es una de las reglas básicas de un buen diseño de software. Cuando se separa un modelo de su presentación puede agregar fácilmente muchas presentaciones diferentes del mismo modelo. Por ejemplo, una aplicación web puede tener normalmente tiene presentación HTML, utilizado por los navegadores web, y la presentación JSON usado por los clientes JavaScript AJAX.

Un papel distintivo MVC nos permite distribuir mejor los recursos humanos en un proyecto grande. Por ejemplo, los expertos de dominio y los expertos de base de datos pueden trabajar en un modelo mientras que los diseñadores web trabajan en una vista. Debido a que cada parte es desarrollado por los desarrolladores especializados, una aplicación puede ser de mejor calidad. Esto también afecta el tiempo de desarrollo, los proyectos se pueden construir más rápida ya que los desarrolladores especializados pueden trabajar simultáneamente, cada uno en su área de especialización, sin afectar (mucho) a otros desarrolladores que estén trabajando también.

Mantenimiento y las actualizaciones de una aplicación compleja son más fáciles debido a que un desarrollador puede mirar a la aplicación como una serie de "módulos" que consiste cada uno de Modelo, Vista y Controlador de la parte. Un desarrollador puede modificar uno "módulo" y no tiene que preocuparse de que los cambios que introdujo afectará a otras partes del sistema (creo que esto se llama separación de intereses). Además, al añadir nuevas funcionalidades a la aplicación, un desarrollador puede simplemente crear un nuevo "módulo".

La implementación

La aplicación consiste en el archivo index.php y varios archivos colocados en el modelo, vista y controlador de directorios:Estructura de programación orientada a objetos PHP MVC CRUD CarpetaEl script index.php es el punto de acceso central, todas las solicitudes pasan a través de él.El controlador se define en el directorio controlador:

     ContactsController.phpLa vista de aplicación se definen en el directorio de vista:

    contacto-form.php se encarga de mostrar "Añadir nuevo contacto" formulario para el usuario
    contact.php se encarga de mostrar los datos de contacto a ser modificado.
    contacts.php se encarga de mostrar la lista de contactos.
    error.php es responsable de mostrar errores.

El modelo

Antes de explicar el código fuente, debe saber algo sobre el modelo. El modelo tiene una sola entidad - Contacto que se persistió en la tabla de contactos. El contacto no tiene un comportamiento por lo que utiliza la estructura de tablas SQL para definirlo:

CREATE TABLE `contacts` (

    `id` int(11) NOT NULL AUTO_INCREMENT,

    `name` varchar(128) NOT NULL,

    `phone` varchar(64) DEFAULT NULL,

    `email` varchar(255) DEFAULT NULL,

    `address` varchar(255) DEFAULT NULL,

    PRIMARY KEY (`id`)

)

No hay ninguna clase en el modelo que representa la entidad de contacto, en vez utilicé objetos PHP estándar creadas automáticamente de la base de datos de registro. no es totalmente OO pero da una idea inicial para dar ejemplo a aquellos que se inician en la programación orientada a objetos y vienen de un pensamiento estructurado.

¿Qué podemos hacer con ese increíble modelo? Esta es la interfaz pública de la clase ContactsService donde se pueden ver todas las características del modelo:


ContactsService.php
  
ContactsService objeto no funciona con la base de datos directamente; En su lugar, utiliza el objeto ContactsGateway que a su vez emite consultas a la base de datos. Esta técnica se denomina tabla de datos de puerta de enlace existen otras técnicas.

La fuente

index.php
 
Este script tiene papel simple, se crea una instancia del objeto de controlador y se lo da el control de la aplicación mediante el método handleRequest.

Todas las solicitudes deben pasar por el script index.php porque MVC requiere que todas las peticiones son manejadas por el controlador que se llama desde el script index.php. Las aplicaciones web MVC por lo general vuelven a redirigir todas las peticiones que pasan por el index.php que se puede hacer en la configuración del servidor.


ContactsController.php

El método handleRequest actúa como un Dispatcher de las acciones. El método decide qué acción debe tener que invocar basado en un valor del parámetro HTTP GET "op" e invoca el método que implementa la acción. Si alguna excepción desde los métodos de acción del método handleRequest los atrapa e imprime el mensaje de error. Por esto se le llama controlador base, por lo general eso lo hacen algunos frameworks y no tenemos que implementar esta función adicional al Controller, sino solo implementar en él la lógica de negocio.

En primer lugar, tenemos el método listContacts que tiene un flujo de trabajo sencillo, se lee un parámetro necesario para clasificar los contactos, los contactos se obtiene a partir del modelo ordenado, los almacena en la variable de contactos y, por último, incluye la vista.En segundo lugar, tenemos el método DeleteContact que se lee un identificador del contacto y le dice al modelo para eliminarlo. Por último, se redirige al usuario de vuelta al script index.php que a su vez invoca la acción de la lista de contactos. La acción de contactos de eliminación no puede funcionar sin el parámetro id, así, el método lanzará una excepción si el id de un contacto no está establecido.En tercer método es el método showContact que es similar al método DeleteContact usa un id para actualizar, así que no voy a perder el espacio explicarlo.Por último, el método saveContact muestra el formulario "Añadir nuevo contacto", o, procesa los datos que se transmiten de forma que si se presentó. Si cualquier ValidationException se produce en el modelo, los errores se recogen de la excepción y se pasan a la vista. Lo ideal sería que la vista debe mostrar (y de hecho lo hace).

contacts.php

La vista contacts.php, que es utilizado por la acción de la lista de contactos, requiere la variable de contactos para ser llenado con objetos de contacto. La variable se rellena con el método listContacts y se pasa a la vista con las normas de alcance PHP y entonces la vista utiliza los datos de él para mostrar los contactos como una tabla HTML.Scripts como el Scripts contacts.php se llaman plantillas o templates. Con un plantilla el desarrollador define una estructura fija que se llena con los valores de las variables de la aplicación (en tiempo de ejecución) y luego se presenta al usuario. Las plantillas contienen únicamente la lógica de presentación, debido a esto, estos Scripts son comprensibles por los no programadores (diseñadores, ...) lo que los hace muy útiles y se utiliza con frecuencia en aplicaciones web aplicando así una de las best practice, la segregación de tareas.
 

Github source code MCV CRUD

Se puede descargar el código en la siguiente dirección en Github.

https://github.com/ooleon/mvc-php-poo-crud-tutorial-001/blob/master/mvc_crud.zip


Gracias.

Pasos para migrar de SQL Server 2000 a SQL Server 2014

No todas las organizaciones son capaces de mantenerse al día con todas las nuevas versiones de SQL Server. De hecho, hay un montón de empresas que todavía están en versiones anteriores como SQL Server 2005 y versiones aún más antiguas, como SQL Server 2000. Entonces, ¿qué hacer si se tiene una versión anterior como SQL Server 2000 y desea actualizar a una nueva versión, como SQL Server 2012 o SQL Server 2014? No hay ninguna ruta de migración directa a SQL Server 2012 o SQL Server 2014 desde SQL Server 2000, pero se puede llegar mediante el uso de SQL Server 2008 como en el paso intermedio o provisional de migración. La migración de SQL Server 2000 a SQL Server 2012 o SQL Server 2014 requiere esencialmente una migración de datos debido a que el host está, probablemente, en ejecución sobre un sistema operativo antiguo, como Windows Server 2000 o Windows Server 2003 y es casi seguro que quieren pasar a una plataforma más moderna como Windows Server 2012. Estos son los pasos para migrar desde SQL Server 2000 a SQL Server 2014 (estos pasos son esencialmente los mismos que ir a SQL Server 2012)

1. Instale una copia separada de SQL Server 2014 - El primer paso es instalar una instancia independiente de SQL Server 2014. Este será típicamente en un sistema operativo más reciente como Windows Server 2012 o Windows Server 2012 R2. Esto puede ser ya sea en un sistema físico o puede ser una máquina virtual. Si en este caso se encuentra en la misma subred que el sistema original, se necesitará un nombre de sistema diferente, pero eso se puede cambiar más adelante.

2. Asegúrese de que su fuente de SQL Server 2000 está en el Service Pack 4 - Luego tenemos que estar seguros de que el sistema de origen está en el Service Pack 4 (SP4). Puede comprobar el nivel SP utilizando la siguiente consulta:

SERVERPROPERTY SELECT ('productversion'), SERVERPROPERTY ('ProductLevel'), SERVERPROPERTY ('edición')

Si el sistema es inferior a SP4, entonces necesita instalarlo antes de continuar.

3. Realice una copia de seguridad de todas las bases de datos que se migrarán - Después de haber actualizado el sistema de origen a SQL Server 2000 SP4, entonces usted puede seguir adelante y hacer una copia de seguridad completa de todas las bases de datos que se migrarán.

4. Instale una copia intermedia de SQL Server 2008 o SQL Server 2008 R2. Esta copia sólo será utilizada para convertir las copias de seguridad del formato anterior de SQL Server 2000 que no puede ser restaurado a SQL Server 2014 al formato 2008 / R2 más reciente de SQL Server que si puede ser restaurado al 2014. Puede instalar esta instancia  SQL Server 2008 / R2 en cualquier sistema operativo, pero probablemente sería más conveniente para instalar esta instancia temporal en el mismo sistema operativo donde se encuentra el SQL Server 2014 de destino.

5. Instale el Service Pack adecuado en el SQL Server 2008 provisional. Si está utilizando SQL Server 2008, entonces también tiene que colocar el SP2. Si está utilizando SQL Server 2008 R2, entonces usted necesita para este el SP1 adecuado.

6. Restaure la copia de seguridad de base de datos SQL Server 2000 en el sistema provisional SQL Server 2008 / R2 SP2 que ha sido instalado provisionalmente y siga adelante.

7. En este momento la base de datos SQL Server 2000 SP4 se habrá restaurado al 100% en el SQL Server 2008 / R2 y se habrá convertido en un formato más reciente. Ahora usted puede hacer una copia de seguridad de esta bases de datos provisional SQL Server 2008 / R2. Una vez completada esta copia de seguridad, ya no necesita el sistema provisional de SQL Server 2008 / R2 y puede eliminar esta instancia.

8. El siguiente paso es tomar la copia de seguridad de la bases de datos del SQL Server 2008 / R2 y  restaurarla al sistema de SQL Server destino 2012 o 2014 según sea su caso. Una vez que la restauración de las bases de datos ha terminado, se han migrado al nuevo formato de SQL Server 2014.

Oxitocina la hormona mas deseada. Importante para la salud, amor, inteligencia y calidad de vida.

Alquimia corporal: la oxitocina y sus efectos en la salud

Como si fuera una píldora mágica, esta hormona da placer, felicidad, quita malestares físicos y mentales, promueve la unión y la generosidad, ¿qué más puede hacer por ti? Checa la lista de abajo.

El cuerpo humano es un bio-radar que capta todas las señales de su entorno. Cuando siente alguna amenaza, el cerebro alerta a toda la estructura corporal por si hay que actuar o mantenerse en estado preventivo.
El complejo mecanismo con el que la mente funciona aún es indescifrable, y aun sabiendo el funcionamiento de las hormonas que excreta el cerebro,  la misteriosa conexión mente-cuerpo continuará asombrando a científicos.
Una nueva investigación sugiere que la oxitocina juega un papel crucial en la vida social de los humanos, no sólo forja y estrecha nuestras relaciones, sino que ayuda a evitar problemas psicológicos y fisiológicos. En años recientes se ha demostrado que esta hormona es una parte medular en nuestra faceta sentimental, y aquí hay 10 razones por las que la oxitocina es uno de los mejores recursos que posee nuestra mente para salvaguardar nuestra cordura.

• Es fácil de conseguir

Una de las cosas más interesantes de esta hormona es que puede hacer uso de ella en cualquier momento. Para ello, lo único que se necesita es abrazar o estrecharle la mano a una persona. El contacto corporal hará que tu cerebro libere bajas dosis de oxitocina, haciendo que ésta fortalezca los vínculos afectivos.

• Estimula el lado materno

Una vez que una mujer comienza a percatarse de que es madre, la hormona comienza a invadir su cerebro; incluso a la hora de parir, algunas mujeres son medicadas con oxitocina, ya que esta estimula las contracciones uterinas. Por si esto fuese poco, los bebés son alimentados con altas dosis de la hormona a través de la leche materna, haciendo que la relación madre-hijo sea inquebrantable y perpetua.
.

• Paradójicamente, inhibe la timidez

Dada sus capacidades de mejorar la autoestima, de fortalecer la autoconfianza y aumentar el optimismo, la oxcitocina ayuda a debilitar la timidez. Los psiquiatras medican la hormona a aquellas personas que sufren de ansiedad, estrés postraumático y trastornos de humor. Otro uso que la ciencia comienza darle a la hormona, es en el tratamiento de personas con autismo.

• Cura y alivia el dolor

Estudios han demostrado que el aumento en niveles de oxitocina puede aliviar dolores de cabeza, calambres y malestares en general. El secreto está justo en el momento en que se experimenta un dolor, pedirle a nuestra pareja un juego íntimo y sexual que ayude a eclipsar nuestras momentáneas afecciones.

• Previene la obesidad

Algunos médicos la utilizan como método para contrarrestar la obesidad mórbida. Estudios demuestran que la falta de oxitocina puede culminar en un severo aumento de peso, ya que la deficiencia de la hormona se refleja en transtornos metabólicos.

• Es un antidepresivo

Las madres que sufren depresión postparto, son medicadas con esta hormona. Diversos estudios han revelado que las personas que son afectadas por una severa depresión, sus niveles de oxcitocina son nulos o, en el mejor de los casos, mínimos.

• Minando el estrés

Posee propiedades tan potentes que combaten significativamente la depresión, entonces el estrés es una simple y vil tarea para la oxitocina. Gracias a sus compuestos, la hormona puede reducir los niveles de cortisol, la hormona del estrés.

• Promueve la generosidad

Los biólogos evolucionistas concuerdan con que los altos niveles de esta hormona se reflejan en una sociedad más justa y empática. En un estudio, las personas que compartieron su dinero con gente desconocida, aumentaron su nivel de oxitocina.

• Elíxir del amor

Los científicos la conocen como la “hormona del amor”, ya que es la encargada de químicamente establecer conexiones íntimas entre los amantes. Además, es aquella que provoca el deseo y la excitación sexual por la pareja. Para los hombres es  un motor químico para una erección duradera, y tanto en hombre como en mujeres, en un orgasmo, la oxitocina inunda el cerebro de los actantes.

• Es lo que nos humaniza

Está claro que si juntamos todos los beneficios que ofrece esta hormona, serían las principales características que nos hacen seres humanos. Sin ella la sociedad  y las familias serían sólo un grupo sin ganas de vivir y con pocos intereses en mantener relaciones personales.

Tomar oxitocina, ‘la hormona del amor’, acaba con timidez

Científicos comprueban que la oxitocina ayuda a las personas tímidas o hasta autistas a empatizar y mejorar sus hablidades sociales.

La oxitocina, llamada la ‘hormona del amor’, ha logrado superar la inhibición social en un reciente experimento científico. La oxitocina, según investigadores del Centro Seaver de investigación para el Autismo en Israel y de la Universidad de Columbia, ayuda a relacionarse y a empatizar a las personas tímidas. Para las personas que son naturalmente seguras no tiene efectos significativos.
En una prueba conducida con oxitocina vía nasal en forma de spray y un placebo con 27 sujetos experimentales, aquellos que recibieron la sustancia, y que de antemano eran menos competentes en cuestiones de socialización obtuvieron mejores resultados en una prueba de empatía y en otra de competitividad social.
Las personas que habían previamente tenido buenos resultados en estas pruebas no obtuvieron mejorías.
Esta sustancia se había promovido como una “droga del amor” que funciona para todo tipo de personas; los estudios refutan esta idea, aunque confirman que tiene un uso prometedor para personas muy tímidas o incluso autistas.
La oxitocina es una hormona mammalia que también actúa como neurotransmisor, es producida especialemente en el parto, y después del orgasmo, como una estela vinculante. En la mujeres se genera también al libar prolongadamente sus pezones; los hombres también reciben una descarga después del sexo, pero al parecer la testosterona baja un poco los efectos.

fuente: http://pijamasurf.com/2010/09/tomar-oxitocina-la-hormona-del-amor-acaba-con-timidez/

¿Porqué encontramos atractivas a determinados personas, cómo nuestros cuerpos ansían enamorarse, por qué al amor se le puede considerar casi como una droga, y por qué las parejas locamente enamoradas, bajo otras circunstancias, podría considerarse que sufren un desorden obsesivo compulsivo?

La química del amor es una expresión acertada. En la cascada de reacciones emocionales hay electricidad (descargas neuronales) y hay química (hormonas y otras sustancias que participan). Ellas son las que hacen que una pasión amorosa descontrole nuestra vida y ellas son las que explican buena parte de los signos del enamoramiento.
Aunque nos atraen las personas con rasgos similares a los nuestros tendemos a elegir el olor de aquellas que tienen un sistema inmunológico muy distinto. Y por un lado es una suerte porque evita que nos enamoremos de nuestros familiares. Nuestra biología nos guía para encontrar un compromiso entre la igualdad y la diferencia y siempre encontramos el equilibrio perfecto, no sólo cuando elegimos las caras y los olores. La llamada teoría de la correspondencia puede resumirse en la frase: "cada cual busca la pareja que cree merecer". Parece ser que antes de que una persona se fije en otra ya ha construido un mapa mental, un molde completo de circuitos cerebrales que determinan lo que le hará enamorarse de una persona y no de otra. Además, incluso INFLUYE el tipo sanguineo (A, B, AB, O), provoca atraccion con las personas del mismo tipo y no de las demas.

El acto y la actividad sexual liberan oxitocina, una hormona que, entre otras cosas, ayuda a las personas a congeniar. Esta necesidad de congeniar se ve bastante satisfecha con la oxitocina, por lo cual cualquier persona que incremente sus niveles no requerirá de mucha atención por parte de los otros. Estará bien y completa por sí misma.
Artículo completo en: http://pijamasurf.com/2014/05/cinco-maneras-de-saber-si-una-mujer-tuvo-sexo-recientemente/

¿La biología guía nuestra vida amorosa? Después del orgasmo el sistema límbico del cerebro libera una hormona especial llamada oxitocina. Esto sucede en una parte del cerebro en la que sentimos el placer emocional. La oxitocina hace que la pareja se sienta más vinculada y cercana emocionalmente, pero también existen algunas diferencias entre el cuerpo del hombre y el de la mujer. Algunos científicos creen que cuando la oxitocina se combina con una determinada hormona femenina, los estrógenos, la mujer se siente muy cariñosa y conversadora. Pero cuando la oxitocina se mezcla con una hormona masculina, la testosterona, puede provocarle al hombre una necesidad incontenible de dormir. Todos sabemos que podemos tener relaciones sexuales sin enamorarnos, pero si se tienen suficientes relaciones con la misma persona hay muchas posibilidades de que esta bomba de relojería de hormonas nos haga perder la cabeza por alguien. El cuerpo hace lo posible por unirnos a nuestra pareja, pero eso precisamente lo convierte en una gran adicción. Todo aquello que tiene que ver con el amor, desde el maternal hasta el curioso hecho de que algunos logren permanecer felices por décadas con la misma pareja, o que otros sean incapaces de jamás forjar una relación duradera, es culpa de una hormona. Al parecer, las cosas del amor no son tan caprichosas como aparentan. Según el experto en el cerebro de la Universidad de Edimburgo, Gareth Leng, la hormona oxitocina ayuda a forjar lazos permanentes entre amantes tras la primera oleada de emoción. La hormona actúa "cambiando las conexiones" de los miles de millones de circuitos cerebrales. Al explicar cómo se enamora el cerebro, Leng señala que la oxitocina ayuda a afianzar el vínculo entre una madre y su bebé, y se produce tanto durante un parto como un orgasmo. Mientras que el instinto de reproducirnos nos hace sentir la pasión del amor, en el caso contrario, cuando lo perdemos, podemos acabar sintiéndonos deprimidos. Cuando estamos enamorados o locos por alguien... el cóctel químico del organismo puede hacernos perder la razón, pero ¿por qué?. Es posible que tengan que ser los cientificos quienes respondan a las preguntas: cuánto dura la pasión, es el amor para toda la vida o es sólo un sistema de defensa que asegura la supervivencia de la especie humana. 

Produciendo nuestras propias drogas
Sabes que puedes producir tus propias drogas, sin tener que sembrar amapolas, marihuana o comprar cocaína?El cerebro, movido por las emociones, produce sustancias químicas que hacen que la persona eleve su autoestima, experimente sensación de euforia, se sienta animada, alegre y vigorosa, sin necesidad de tomar, inyectarse o fumar nada.Estas sustancias que produce el cerebro, denominadas hormonas endógenas (ya que se producen en la corteza cerebral) bien podrían llamarse "drogas de la felicidad". Algunas de ellas son:La oxitocina, que se produce cuando existe un amor pasional y se relaciona con la vida sexual.La dopamina, que es la droga del amor y la ternura.La finilananina, que genera entusiasmo y amor por la vida.La endorfina, que es un trasmisor de energía y equilibra las emociones, el sentimiento de plenitud y el de depresión.La epinefrina, que es un estímulo para el desafío de la realización de metas.Si hay abundancia de estas hormonas endógenas, hay inteligencia emocional e interpersonal; la persona se siente ubicada, sabe quién es, a dónde va; controla sus emociones, conoce sus habilidades y sus talentos y se siente dueña de sí misma.

¿Cuándo y cómo se crean estas drogas internas? 
Se han realizado descubrimientos como estos:Cuando una mujer va a dar a luz, se vuelve altamente dopamínica; es decir, genera una cantidad enorme de dopamina (la droga del amor y la ternura).Cuando estamos enamorados, la dopamina aumenta 7000 veces su cantidad, acompañada de la oxitocina, responsable de la pasión sexual y de las fenilananinas, responsables del entusiasmo, bloqueando el aspecto de la lógica y la razón.En los recién casados, se produce gran cantidad de oxitocina, que es responsable del amor pasional. Por eso ellos irradian felicidad, se sienten plenos, alegres y motivados.Como vemos, la felicidad no es algo vago e impreciso, ni una sensación nebulosa: es el efecto de un flujo correcto de sustancias químicas que proporcionan al ser humano su equilibrio físico y psíquico. Así, la felicidad se puede incrementar por medio de las siguientes actitudes o actividades, todas productoras de estas "drogas" internas:Amar y disfrutar apasionadamente lo que hacemos. Tener relaciones con personas que nos motivan y enriquecen nuestra fuerza vital.Tener una autoestima positiva y un sentido del valor personal. Trabajar y lograr pequeñas o grandes metas. Descansar y dormir profundamente. Manejar adecuadamente el estrés.Hacer ejercicios regularmente: "mente sana en cuerpo sano".Recordar los momentos felices de nuestra vida, ya que en esos momentos la mente no distingue entre lo real y lo imaginario.El secreto está dentro de nosotros. Sentirnos felices es, en parte, una cuestión de actitud hacia la vida: las drogas de la felicidad no se consiguen en el exterior, sino que son creadas mediante una vida llena de amor, entrega, optimismo, ejercicio,satisfacción personal ante el logro de metas y vocación y devoción por lo que se hace....

"Un estudio explica por qué el amor es ciego"
En un reciente trabajo de unos investigadores de la Universidad College de Londres, se dedicaron a captar imágenes de cerebros enamorados.Ya hace tiempo que la ciencia ha descubierto que ante la visión del ser amado se activan determinadas zonas del cerebro, entre ellas el córtex anterior cingulado, que también responde al estímulo de drogas sintéticas produciendo sensaciones de euforia; pero lo sorprendente del nuevo estudio es que además, las áreas encargadas de realizar juicios sociales y, por tanto, de someter al prójimo a valoración, se inactivaban. Ante nuestro amor, nos volvemos "ciegos" o, por lo menos, bajamos la guardia.Pero es que el ser humano, como todos los animales, ha tenido que encontrar los mecanismos evolutivos para perpetuar la especie. Y el enamoramiento está entre estos mecanismos, un proceso bioquímico que se inicia en el cerebro, y que tras la desbordante secreción de neurotransmisores, activa glándulas y respuestas fisiológicas a velocidad de vértigo, con la finalidad de que acabemos reproduciéndonos.Trabajos anteriores han explorado otras líneas de investigación y han aportado interesantes datos sobre las causas y los efectos del amor. Hasta ahora se sabe, por ejemplo, que la feniletilamina (FEA), una anfetamina que segrega el cuerpo humano, es una de las principales sustancias implicadas en el enamoramiento. Este compuesto activa la secreción de dopamina -un neurotransmisor implicado en las sensaciones de deseo y que nos hace repetir lo que nos proporciona placer- y de oxitocina -ésta implicada, entre otras funciones, en el deseo sexual-. Al inundarse el cerebro de esta sustancia, éste responde mediante la secreción de dopamina (neurotransmisor responsable de los mecanismos de refuerzo del cerebro, es decir, de la capacidad de desear algo y de repetir un comportamiento que proporciona placer), norepinefrina y oxiticina (además de estimular las contracciones uterinas para el parto y hacer brotar la leche, parece ser además un mensajero químico del deseo sexual), y comienza el trabajo de los neurotransmisores que dan lugar a los arrebatos sentimentales, en síntesis: se está enamorado. Estos compuestos combinados hacen que los enamorados puedan permanecer horas haciendo el amor y noches enteras conversando, sin sensación alguna de cansancio o sueño. En definitiva, nos sentimos bien con nuestro amor, estamos sumamente eufóricos y excitados, necesitamos a la persona con la que estamos, como si de una droga se tratara, porque nos proporciona placer, y nuestra capacidad para juzgarla se reduce hasta la nada.

Cuando termina la pasion...
Pero la síntesis de FEA no puede prolongarse durante mucho tiempo, entre otras cosas porque moriríamos de extenuación, y tras dos o tres años sus efectos desaparecen, sin apenas dejar rastro. Es entonces cuando nos enfrentamos a la tremenda realidad y, sobrevienen los defectos que otrora no vimos. Con el tiempo el organismo se va haciendo resistente a los efectos de estas sustancias y toda la locura de la pasión se desvanece gradualmente, la fase de atracción no dura para siempre y comienza entonces una segunda fase que podemos denominar de pertenencia dando paso a un amor más sosegado. Se trata de un sentimiento de seguridad, comodidad y paz. Dicho estado está asociado a otra DUCHA QUÍMICA. En este caso son las endorfinas -compuestos químicos naturales de estructura similar a la de la morfina y otros opiáceos- los que confieren la sensación común de seguridad comenzando una nueva etapa, la del apego. Por ello se sufre tanto al perder al ser querido, dejamos de recibir la dosis diaria de narcóticos. Los motivos que explican por qué nos enamoramos de una persona y no de otra no están bien establecidos, aunque deberemos confiar en que las leyes psicológicas que rigen la elección tengan también una buena base evolutiva y, si no es mucho pedir, que sean sensatas ante las posibilidades de ser correspondidos. Otra cosa es ya, si entre tanta precisión biológica, queda lugar para el romanticismo. Pero no os preocupeis, pronto descubrireis que el romanticismo seguirá existiendo en toda su plenitud, solo que ahora tendremos una explicacion cientifica a ciertas reacciones fisicas y emocionales, solo eso, pero creo que el amor va a continuar siendo ciego de momento. La oxitocina, conocida como hormona del cariño, genera lazos afectivos: Montemayor

Un solo abrazo desencadena las sustancias que mitigan el estréshttp://www.jornada.unam.mx/2011/02/14/index.php?section=sociedad&article=041n1socAcariciar a una mascota logra disminuir la tensión arterial, la ansiedad e incluso la depresiónPara los humanos, el contacto físico es una necesidad, una fuente de bienestar que los hace sentir protegidos, amados y reconocidos por el otro. Tan sólo un abrazo desencadena sustancias químicas que ayudan a reducir el estrés y a entablar lazos emocionales. La piel posee receptores sensitivos que envían señales a la corteza cerebral. Este mecanismo permite percibir frío, calor, caricias, cosquillas, pellizcos y si una superficie es suave o áspera. Georgina Montemayor, académica del departamento de anatomía de la Facultad de Medicina de la Universidad Nacional Autónoma de México, explica que al recibir un abrazo, un apretón de manos o una caricia, el cerebro libera oxitocina, también conocida como hormona del cariño, la cual permite el apego y que los seres humanos se busquen los unos a los otros. Cada zona del cuerpo está representada en la corteza cerebral: párpados, orejas, pies, órganos sexuales, piernas, nuca. Por eso donde nos toquen vamos a sentir, aunque hay partes, como manos y labios, que ocupan mayor espacio en la corteza cerebral, por tanto, son más sensibles al estímulo. Con ayuda de la resonancia magnética (que permite hacer imágenes del funcionamiento del cerebro), los científicos han observado que al recibir un abrazo, un apretón de manos o una caricia se libera oxitocina. Esa sensación de bienestar con un amigo, los padres o la pareja se logra gracias a la oxitocina y a la vasopresina, que se parecen mucho.

La segunda aparece más en hombres y la oxitocina la produce más el sexo femenino. Eso explica por qué las mujeres pasan gran parte del tiempo con amigas y por qué les gusta, entre otras cosas, ser abrazadas constantemente y reafirmar su confianza mutua. Para que un abrazo produzca oxitocina suficiente para una mujer debe durar cuando menos un minuto, y tiene que ser tranquilo, no como los que dan muchos hombres, con palmadas o golpecillos en la espalda. Las mujeres no abrazan así, incluso hasta nos mecemos al abrazar; a los varones esa cercanía los pone nerviosos. Estudios científicos internacionales han demostrado lo relevante que es para los mamíferos el contacto físico. Monos bebés fueron separados de sus madres y colocados en jaulas con dos sustitutas artificiales: una figura de alambre que les proveía leche y otra de felpa que no los alimentaba. La sorpresa de los investigadores fue grande al descubrir que las crías se acercaban con mayor frecuencia a esta última. El contacto con la felpa satisfacía su necesidad de consuelo. La especialista de la FM destaca que el ser humano no puede desconocer la principal herencia de los mamíferos: vivir en grupo. Para eso necesitamos lazos, que se logran gracias a la oxitocina. Durante la Segunda Guerra Mundial se crearon albergues para los pequeños, sobre todo recién nacidos, que habían perdido a sus padres. Las enfermeras los bañaban, vestían y alimentaban; sin embargo, muchos bebés morían pronto por la falta de contacto físico estrecho. Los niños necesitan abrazos, caricias, entre otras expresiones del amor materno para sobrevivir.

Otros estudios muestran que gran parte de la depresión de los ancianos se debe a la ausencia de contacto físico con otras personas y no a la falta de sexo. La oxitocina genera una sensación de bienestar y calidez. El cerebro del recién nacido establece el contacto visual con la madre por la oxitocina. Ésta tiene funciones fuera del cerebro: en las mujeres aparece en el momento previo al parto, es necesaria para contraer el útero y expulsar al producto; cuando nace el niño hay altos niveles de oxitocina en cuerpo y cerebro. Esto genera apego, pero también pérdida de la memoria; quizás por eso las mujeres se vuelven a embarazar y no recuerdan cuán doloroso fue el parto. Pero esta sustancia no sólo aparece durante el contacto físico con el ser amado, amigo o familia, sino también se produce en la interacción con mascotas. “Si durante una semana todos los días al llegar a casa acaricias la panza del perrito, te verá a los ojos en busca de apego. Y a ti, sólo por acariciarlo, se te baja la tensión arterial y la ansiedad, y si estás deprimido, disminuye un poco la depresión.. Sin embargo, esa sensación no se presenta cuando existe contacto con persona que acabamos de conocer, pues es necesario que se generen vínculos afectivos, concluye la investigadora.

Fuente: http://www.psikologia.com/bioquimica.htm

5 inesperadas formas en que la oxitocina afecta tus comportamientos sociales

La oxitocina es una hormona clave en nuestro comportamiento social; aquí 5 situaciones que explican, así sea parcialmente, la manera en que nos conducimos ante los otros.

La oxitocina es una hormona que nuestro cuerpo produce naturalmente y cuya reacción química está asociada sobre todo con actos sexuales y de maternidad o paternidad, aunque al parecer su presencia en asuntos amorosos es un tanto más amplia y detallada, incluso en conductas tan elementales como el contacto corporal.Así, ésta que también se conoce como la “hormona del amor”, es una sustancia indispensable en nuestras interacciones cotidianas. Como en otros casos, aquí la indisociable relación entre individuo y comunidad se expresa por medio de una serie de efectos químicos visibles a través de nuestras acciones. Conductas como la fidelidad, el apego o la manera en que recibimos un triunfo o un fracaso son, sí, resultado de nuestra educación y nuestro desarrollo en determinado medio, pero también, en algún punto, respuesta a las reacciones que suceden en el interior de nuestro cuerpo.
A continuación, vía Alternet, compartimos 5 situaciones en que la oxitocina es un elemento clave de la interacción social.
1. Lealtad
La relación entre un hombre y una mujer puede ser, por momentos, bastante primitiva. Al menos así lo mostró un experimento que investigadores alemanes realizaron en 2012, en el cual 57 hombres, solteros y con algún tipo de compromiso con una mujer, recibieron una rociada de oxitocina o de un placebo por debajo de su nariz; acto seguido fueron enviados a entrevistarse con una mujer joven y atractiva, quien les haría preguntas más bien triviales. El verdadero objetivo era observar qué tan cerca se colocaban los hombres de la mujer mientras hablaban.
De acuerdo con el estudio, los hombres en una relación y con oxitocina en su nariz, se mantuvieron cautamente alejados de la chica que tenían enfrente. Los hombres también comprometidos con el placebo se acercaban un poco más y, finalmente, los solteros parecían estar de lleno sobre la mujer.

2. Malos ganadores, peores perdedores
El gusto por la competencia y la rivalidad, no pocas veces desenfrenado en ciertas personas, así como la manera en que aceptamos una victoria o una derrota, están relacionados con los niveles de oxitocina de nuestro organismo. Varias investigaciones han encontrado que durante un juego como el poker, la glándula pituitaria posterior secreta oxitocina conforme la partida se desarrolla, con lo que afecta las reacciones de bienestar y de malestar según se gane o se pierda.
En particular una investigación de la Northwestern University juntó 3 grupos de ratones en una misma jaula, el primero con más receptores de oxitocina de lo normal, el segundo sin receptores y el tercero en condiciones normales. En una primera fase, el grupo con más receptores sometió al resto hasta que fueron separados de nuevo. Seis horas después los volvieron a reunir y, para sorpresa de los científicos, los ratones que carecían de receptores de oxitocina no recordaban que habían sido dañados por sus compañeros de jaula.
Una de las conclusiones fue que la oxitocina y su reacción en el septum lateral se relacionan también con nuestra memoria social y los recuerdos de las personas o las situaciones en las que nos lastimaron de alguna manera o, por el contrario, de aquellas en las que recibimos algún tipo de cuidado.
De ahí que, por ejemplo, mientras ganemos, sintamos que todos a nuestro alrededor son amigos, pero si perdemos, sospechemos de nuestros rivales y secretamente creamos que están haciendo trampa.

3. Cooperación
Si la cooperación es uno de los comportamientos que distinguen a la naturaleza humana y también la de otros animales, ella se debe a la oxitocina. Aunque, paradójicamente, por un efecto más bien egoísta. Un estudio realizado en marzo de este año con chimpancés encontró que el acto de rascar la espalda de otros monos en busca de insectos genera en quien lo realiza una descarga de oxitocina que, a su vez, se traduce en una descarga de tranquilidad, relajamiento e incluso placer. Así, las muestras de compañerismo reportan también una ganancia individual.
Sin embargo, la investigadora Mirre Stallen descubrió también que este efecto podría presentarse únicamente entre grupos que ya se relacionan entre sí. En el caso de personas que no se conocen y de pronto tienen que realizar una labor compartida, la oxitocina provoca que la persona prefiera realizarla a solas, y recele de elegir un líder que dirija el trabajo.

4. Preferencia del grupo al que se pertenece
En 2011, el investigador holandés Carsten De Dreu realizó un experimento en el que dosificó oxitocina a dos grupos de voluntarios para después preguntarles su opinión sobre asuntos nacionales como la prostitución, las políticas públicas sobre el uso de drogas e incluso los tulipanes que tanto caracterizan a los Países Bajos. El resultado fue que el grupo bajo los efectos de la oxitocina tendía a considerarlo todo bien y aun por encima del resto del mundo.
Esta reacción, sin embargo, fue acotada por un estudio del economista Paul Zak, de la Claremont Graduate University, quien reunió a algunos estudiantes enrolados también en grupos de cadetes y baile. Los voluntarios realizaban algunas marchas y danzas al tiempo que el equipo de Zak les extraía un poco de sangre, para después participar en juegos en los que podían ganar en promedio 65 dólares cada uno, que podían donar a distintos grupos de caridad. El objetivo era, por un lado, con la actividad física, aumentar los niveles de oxitocina en su cuerpo y, por otro, con el drenado de sangre, volver impredecible a qué caridad darían su dinero, lo cual finalmente se cumplió, pues de los 400 participantes no pudo extraerse un patrón que estuviera relacionado con el sentimiento de pertenencia al grupo del que provenían o la generosidad y el desapego. Si acaso, el estudio mostró una tendencia a relacionar marginalidad y sectarismo: mientras más marginado se sentía un grupo dentro del campus, más se cerraba sobre sí mismo, e incluso podía mostrar ciertas actitudes agresivas hacia otros.

5. La oxitocina nos hace confiar en otros, pero no nos ciega
El complejo sistema químico involucrado en nuestro comportamiento nos explica, pero es solo una de las piezas de nuestra conducta cotidiana. En el caso de la oxitocina, ésta nos vuelve más liberales con los demás, nos hace confiar en los otros, aunque tampoco hasta el exceso. El placer de sentirse parte de un grupo puede terminar si la conciencia advierte que se vulneran principios en los que creemos (éticos, empáticos, entre otros).
“Tenemos que estar en el entorno adecuado para ser virtuosos”, concluye Paul Zak.

Fuente: http://pijamasurf.com/2013/11/5-inesperadas-formas-en-que-la-oxitocina-afecta-tus-comportamientos-sociales/

La importancia de la oxitocina (en el deporte como en el amor)

¿Será la “hormona del amor“ el nuevo doping legal del futuro de los deportes? Investigaciones muestran que la oxitocina puede mejorar el desempeño de un deportista

A primera vista quizás no resulte evidente la importancia que tiene la oxitocina en cualquier tipo de competencia o desempeño físico. ¿Qué tiene que ver un grupo de hombres dando patadas para intentar llevar una pelota a una red con una madre amamantando dulcemente a su hijo?… Más evidente es la importancia de la testosterona en una competencia –hormona que no solo aumenta la confianza y agresividad, aumenta la velocidad de reacción. Pero al parecer la oxitocina, conocida como la hormona del amor (hormona de la socialización, quizás sería un mejor término), también juega un papel importante en el desempeño de los atletas, especialmente cuando se encuentran en el marco de un equipo.
La oxitocina promueve las relaciones intersociales, hace que las personas se gusten: las madres que acaban de tener un hijo están llenas de la hormona –o las parejas recientemente formadas–; la oxitocina sirve para vincular y consolidar una relación. Hasta hace poco no se pensaba que esta neuropéptido jugara también un papel de los deportes de competencia. Pero tiene una clara lógica. Como dice Gert Jan Pepping, autor de un nuevu estudio científico sobre la oxitocina y la competencia, “Ser parte de un equipo involucra emociones, como cuando un equipo anota, y esas emociones están asociadas con químicos  cerebrales”.

Para el estudio en cuestión se revisaron múltiples partidos definidos vía tandas de penalties en diferentes torneos internacionales de futbol. Los investigadores hallaron que cuando los tiradores celebraron sus goles con gestos como levantar los brazos, el tirador siguiente tuvo mayor efectividad en su disparo que cuando no hubo un gesto conspicuo en la celebración. Esto, explica Pepping, podría tener que ver con una “transferencia emocional”: la exitación de una persona genera una serie de reacciones bioquímicas entre la gente que lo rodea (¿quizás a través de las neuronas espejo?). Un tirador con una descarga de oxitocina en el cerebro debería de tirar mejor un penalty.
Aunque es difícil de cuantificar esto, en el 2008 un estudio descubrió que corredores de larga distancia tenían mayores niveles de oxitocina después de completar un maratón que antes. Y, como reporta el New York Times, un estudio reciente muestra que roedores de la pradera que se ejercitaron por seis semanas aumentaron su producción de oxitocina y rápidamente se aparearon con hembras disponibles, mientras que los machos que no hicieron ejercicio no mostraron interés en una pareja.
Otro de los aspectos por los cuales la oxitocina podría mejorar el desempeño de un deportista, es que, como en cualquier otro aspecto de interacción con otras personas, en los deportes es importante poder leer el lenguaje corporal de compañeros y oponentes para poder reaccionar anticipadamente o tomar alguna decisión. La oxitocina facilita la capacidad de leer las emociones de los demás, a la vez que aumenta la sensación de pertenencia dentro de un grupo y el rechazo para aquellos que amenazan ese grupo.

En los últimos años hemos visto la proliferación de la celebración como parte importante de los espectáculo deportivos. Esto más allá de la atención televisiva que se le da a estos festejos, podría tener que ver con que aumentan los niveles de oxitocina de un equipo. Algo que incluso podría aprovecharse sistemáticamente para mejorar el desempeño de un conjunto. El contacto físico –abrazos, besos, caricias– también aumenta los niveles de oxitocina, por lo que, aunque quizás no sea bien visto por algunos fanáticos homofóbicos, un equipo que constantemente esté tocándose podría tener una ventaja competitiva. A fin de cuentas es la química de un equipo lo que los lleva a ganar.

http://pijamasurf.com/2012/11/la-importancia-de-la-oxitocina-en-el-deporte-como-en-el-amor/