Create PHP apps using SQL Server on Ubuntu

 

Step 1.1 Install SQL Server

Note: To ensure optimal performance of SQL Server, your machine should have at least 4 GB of memory. If you need to get Ubuntu, check out the Ubuntu Downloads website.
  1. Register the Microsoft Linux repositories and add their keys
    Terminal


  • curl https://packages.microsoft.com/keys/microsoft.asc | sudo apt-key add -
    curl https://packages.microsoft.com/config/ubuntu/16.04/mssql-server-2017.list | 
     sudo tee /etc/apt/sources.list.d/mssql-server-2017.list
  • Install SQL Server
    Terminal
  • sudo apt-get update
    sudo apt-get install mssql-server
    Copy
    Results
    Reading package lists... Done
    Building dependency tree
    Reading state information... Done
    The following NEW packages will be installed:
      mssql-server
    ...
    Unpacking mssql-server ...
    Setting up mssql-server ...
  • Setup your SQL Server
    Terminal

    1. sudo /opt/mssql/bin/mssql-conf setup
      Copy
      Results
      Microsoft(R) SQL Server(R) Setup
      
      To abort setup at anytime, press Ctrl-C.
      
      The license terms for this product can be downloaded from 
      http://go.microsoft.com/fwlink/?LinkId=746388 and
      found in /usr/share/doc/mssql-server/LICENSE.TXT.
      
      Do you accept the license terms? If so, please type YES:
      Please enter a password for the system administrator (SA) account:
      Please confirm the password for the system administrator (SA) account:
    You now have SQL Server running locally on your Ubuntu machine! Check out the next section to continue installing prerequisites.

    Step 1.2 Install PHP and other required packages

    Terminal
    sudo apt-get -y install php7.0 libapache2-mod-php7.0 mcrypt php7.0-mcrypt 
    php-mbstring php-pear php7.0-dev apache2
    You have successfully installed PHP on your Ubuntu machine!

    Step 1.3 Install the ODBC Driver and SQL Command Line Utility for SQL Server

    SQLCMD is a command line tool that enables you to connect to SQL Server and run queries.
    Terminal
    curl https://packages.microsoft.com/keys/microsoft.asc | sudo apt-key add -
    curl https://packages.microsoft.com/config/ubuntu/16.04/prod.list | 
    sudo tee /etc/apt/sources.list.d/mssql-tools.list
    sudo apt-get update
    sudo ACCEPT_EULA=Y apt-get install mssql-tools
    sudo apt-get install unixodbc-dev
    echo 'export PATH="$PATH:/opt/mssql-tools/bin"' >> ~/.bash_profile
    echo 'export PATH="$PATH:/opt/mssql-tools/bin"' >> ~/.bashrc
    source ~/.bashrc
    After installing SQLCMD, you can connect to SQL Server using the following command:
    Terminal
    sqlcmd -S localhost -U sa -P yourpassword
    1> # You're connected! Type your T-SQL statements here. Use the keyword 'GO' to 
    execute each batch of statements.
    This how to run a basic inline query. The results will be printed to the STDOUT.
    Terminal
    sqlcmd -S localhost -U sa -P yourpassword -Q "SELECT @@VERSION"
    Results
    --------------------------------------------------------
    Microsoft SQL Server vNext (CTP2.0) - 14.0.500.272 (X64)
     Apr 13 2017 11:44:40
     Copyright (c) Microsoft Corporation
        on Linux (Ubuntu 16.04)
    
    1 rows(s) returned
    
    Executed in 1 ns
    You have successfully installed SQL Server Command Line Utilities on your Ubuntu machine!

    In this section you will create a simple PHP app. The PHP app will perform basic Insert, Update, Delete, and Select.

    Step 2.1 Install the PHP Driver for SQL Server

    Terminal
    sudo pecl install sqlsrv pdo_sqlsrv
    sudo echo "extension= pdo_sqlsrv.so" >> `php --ini | grep "Loaded Configuration" |
      sed -e "s|.*:\s*||"`
    sudo echo "extension= sqlsrv.so" >> `php --ini | grep "Loaded Configuration" | 
    sed -e "s|.*:\s*||"`

    Step 2.2 Create a database for your application

    Create the database using sqlcmd
    Terminal
    sqlcmd -S localhost -U sa -P your_password -Q "CREATE DATABASE SampleDB;"

    Step 2.3 Create a PHP app that connects to SQL Server and executes queries

    Terminal
    mkdir SqlServerSample
    cd SqlServerSample
    Using your favorite text editor, create a new file called connect.php in the SqlServerSample folder. Paste the code below inside into the new file.
    PHP
    
        $serverName = "localhost";
        $connectionOptions = array(
            "Database" => "SampleDB",
            "Uid" => "sa",
            "PWD" => "your_password"
        );
        //Establishes the connection
        $conn = sqlsrv_connect($serverName, $connectionOptions);
        if($conn)
            echo "Connected!"
    ?>
    Run your PHP script from the terminal.
    Terminal
    php connect.php
    Results
    Connected!
    Execute the T-SQL scripts below in the terminal with sqlcmd to create a schema, table, and insert a few rows.
    Terminal
    sqlcmd -S localhost -U sa -P your_password -d SampleDB -Q "CREATE SCHEMA TestSchema;"
    sqlcmd -S localhost -U sa -P your_password -d SampleDB -Q "CREATE TABLE TestSchema.Employees 
    (Id INT IDENTITY(1,1) NOT NULL PRIMARY KEY, Name NVARCHAR(50), Location NVARCHAR(50));"
    sqlcmd -S localhost -U sa -P your_password -d SampleDB -Q "INSERT INTO TestSchema.Employees
    (Name, Location) VALUES (N'Jared', N'Australia'), (N'Nikita', N'India'), (N'Tom', N'Germany');"
    sqlcmd -S localhost -U sa -P your_password -d SampleDB -Q "SELECT * FROM TestSchema.Employees;"
    Using your favorite text editor, create a new file called crud.php in the SqlServerSample folder. Paste the code below inside into the new file. This will insert, update, delete, and read a few rows.
    PHP
    
    $serverName = "localhost";
    $connectionOptions = array(
        "Database" => "SampleDB",
        "Uid" => "sa",
        "PWD" => "your_password"
    );
    //Establishes the connection
    $conn = sqlsrv_connect($serverName, $connectionOptions);
    
    //Insert Query
    echo ("Inserting a new row into table" . PHP_EOL);
    $tsql= "INSERT INTO TestSchema.Employees (Name, Location) VALUES (?,?);";
    $params = array('Jake','United States');
    $getResults= sqlsrv_query($conn, $tsql, $params);
    $rowsAffected = sqlsrv_rows_affected($getResults);
    if ($getResults == FALSE or $rowsAffected == FALSE)
        die(FormatErrors(sqlsrv_errors()));
    echo ($rowsAffected. " row(s) inserted: " . PHP_EOL);
    
    sqlsrv_free_stmt($getResults);
    
    //Update Query
    
    $userToUpdate = 'Nikita';
    $tsql= "UPDATE TestSchema.Employees SET Location = ? WHERE Name = ?";
    $params = array('Sweden', $userToUpdate);
    echo("Updating Location for user " . $userToUpdate . PHP_EOL);
    
    $getResults= sqlsrv_query($conn, $tsql, $params);
    $rowsAffected = sqlsrv_rows_affected($getResults);
    if ($getResults == FALSE or $rowsAffected == FALSE)
        die(FormatErrors(sqlsrv_errors()));
    echo ($rowsAffected. " row(s) updated: " . PHP_EOL);
    sqlsrv_free_stmt($getResults);
    
    //Delete Query
    $userToDelete = 'Jared';
    $tsql= "DELETE FROM TestSchema.Employees WHERE Name = ?";
    $params = array($userToDelete);
    $getResults= sqlsrv_query($conn, $tsql, $params);
    echo("Deleting user " . $userToDelete . PHP_EOL);
    $rowsAffected = sqlsrv_rows_affected($getResults);
    if ($getResults == FALSE or $rowsAffected == FALSE)
        die(FormatErrors(sqlsrv_errors()));
    echo ($rowsAffected. " row(s) deleted: " . PHP_EOL);
    sqlsrv_free_stmt($getResults);
    
    
    //Read Query
    $tsql= "SELECT Id, Name, Location FROM TestSchema.Employees;";
    $getResults= sqlsrv_query($conn, $tsql);
    echo ("Reading data from table" . PHP_EOL);
    if ($getResults == FALSE)
        die(FormatErrors(sqlsrv_errors()));
    while ($row = sqlsrv_fetch_array($getResults, SQLSRV_FETCH_ASSOC)) {
        echo ($row['Id'] . " " . $row['Name'] . " " . $row['Location'] . PHP_EOL);
    
    }
    sqlsrv_free_stmt($getResults);
    
    function FormatErrors( $errors )
    {
        /* Display errors. */
        echo "Error information: ";
    
        foreach ( $errors as $error )
        {
            echo "SQLSTATE: ".$error['SQLSTATE']."";
            echo "Code: ".$error['code']."";
            echo "Message: ".$error['message']."";
        }
    }
    ?>
    Run your PHP script from the terminal.
    Terminal
    php crud.php
    Copy
    Results
    Inserting a new row into table
    1 row(s) inserted:
    Updating Location for user Nikita
    1 row(s) updated:
    Deleting user Jared
    1 row(s) deleted:
    Reading data from table
    2 Nikita Sweden
    3 Tom Germany
    4 Jake United States
    Congrats you created your first PHP app with SQL Server! Check out the next section to learn about how you can make your PHP faster with SQL Server’s Columnstore feature.

    Now that you have explored the basics, you are ready to see how you can make your app better with SQL Server. In this module we will show you a simple example of Columnstore Indexes and how they can improve data processing speeds. Columnstore Indexes can achieve up to 100x better performance on analytical workloads and up to 10x better data compression than traditional rowstore indexes.

    Step 3.1 Create a new table with 5 million using sqlcmd

    Terminal
    sqlcmd -S localhost -U sa -P your_password -d SampleDB -t 60000 -Q "WITH a AS 
    (SELECT * FROM (VALUES(1),(2),(3),(4),(5),(6),(7),(8),(9),(10)) AS a(a))
    SELECT TOP(5000000)
    ROW_NUMBER() OVER (ORDER BY a.a) AS OrderItemId
    ,a.a + b.a + c.a + d.a + e.a + f.a + g.a + h.a AS OrderId
    ,a.a * 10 AS Price
    ,CONCAT(a.a, N' ', b.a, N' ', c.a, N' ', d.a, N' ', e.a, N' ', f.a, N' ', g.a, N' ', h.a)
     AS ProductName
    INTO Table_with_5M_rows
    FROM a, a AS b, a AS c, a AS d, a AS e, a AS f, a AS g, a AS h;"

    Step 3.2 Create a PHP app that queries this tables and measures the time taken

    Terminal
    cd ~/
    mkdir SqlServerColumnstoreSample
    cd SqlServerColumnstoreSample
    Using your favorite text editor, create a new file called columnstore.php in the SqlServerColumnstoreSample folder. Paste the following code inside it.
    PHP
    
    $time_start = microtime(true);
    
    $serverName = "localhost";
    $connectionOptions = array(
        "Database" => "SampleDB",
        "Uid" => "sa",
        "PWD" => "your_password"
    );
    //Establishes the connection
    $conn = sqlsrv_connect($serverName, $connectionOptions);
    
    //Read Query
    $tsql= "SELECT SUM(Price) as sum FROM Table_with_5M_rows";
    $getResults= sqlsrv_query($conn, $tsql);
    echo ("Sum: ");
    if ($getResults == FALSE)
        die(FormatErrors(sqlsrv_errors()));
    while ($row = sqlsrv_fetch_array($getResults, SQLSRV_FETCH_ASSOC)) {
        echo ($row['sum'] . PHP_EOL);
    
    }
    sqlsrv_free_stmt($getResults);
    
    function FormatErrors( $errors )
    {
        /* Display errors. */
        echo "Error information: ";
    
        foreach ( $errors as $error )
        {
            echo "SQLSTATE: ".$error['SQLSTATE']."";
            echo "Code: ".$error['code']."";
            echo "Message: ".$error['message']."";
        }
    }
    $time_end = microtime(true);
    $execution_time = round((($time_end - $time_start)*1000),2);
    echo 'QueryTime: '.$execution_time.' ms';
    
    
    ?>

    Step 3.3 Measure how long it takes to run the query

    Run your PHP script from the terminal.
    Terminal
    php columnstore.php
    Copy
    Results
    Sum: 50000000
    QueryTime: 363ms

    Step 3.4 Add a columnstore index to your table.

    Terminal
    sqlcmd -S localhost -U sa -P your_password -d SampleDB -Q "CREATE CLUSTERED 
    COLUMNSTORE INDEX Columnstoreindex ON Table_with_5M_rows;"

    Step 3.5 Measure how long it takes to run the query with a columnstore index

    Terminal
    php columnstore.php
    Copy
    Results
    Sum: 50000000
    QueryTime: 5ms
    Congrats you just made your PHP app faster using Columnstore Indexes!

    https://www.microsoft.com/en-us/sql-server/developer-get-started/php/ubuntu/

    Ejecutar aplicacion C# en Linux


    Vamos a nuestra terminal  e instalamos el paquete mono-gmcs, para compilar nuestros programas C#.


    #apt-get install mono-gmcs


    En ocaciones este no funciona, como en mi caso, me funciono este


    #apt-get install mono-complete

     Esto sucede porque el mono-gmcs es el paquete del compilador y el mono-complete es el stack completo.


    Una vez completado el proceso de instalación crearemos un directorio en el cual crearemos un archivo .CS el cual contendrá el código C#.

    Creamos el directorio llamado cSharp.


     #mkdir cSharp

     #cd cSharp


    Una vez dentro usaremos el editor de texto integrado en la terminal NANO, para escribir nuestro archivo de código C#.

    Ejecutamos el siguiente comando


    #nano holaMundo.cs


    Ahora procedemos a escribir nuestro código C#, en nuestro caso escribiremos una pequeña clase que imprimirá en la terminal Hola Mundo Open Source, Microsoft Love Linux .

    using System;

    namespace holaMundo
    {
        class holaMundo
        {
            public static void Main (string[] args)
            {
                Console.WriteLine ("Hola Mundo Open Source, Microsoft Love Linux");
            }
        }
    }


    Ahora en la terminal ejecutaremos el siguiente comando el cual nos compilara nuestro código.

    #mcs holaMundo.cs

    Si verificamos el archivo resultante es un .exe

    #mono holaMundo.exe









    Programación Orientada a Objetos/Introducción


    Los objetos son entidades que tienen un determinado estado, comportamiento (método) e identidad:
    • El estado está compuesto de datos o informaciones; serán uno o varios atributos a los que se habrán asignado unos valores concretos (datos).
    • El comportamiento está definido por los métodos o mensajes a los que sabe responder dicho objeto, es decir, qué operaciones se pueden realizar con él.
    • La identidad es una propiedad de un objeto que lo diferencia del resto; dicho con otras palabras, es su identificador (concepto análogo al de identificador de una variable o una constante).
    Un objeto contiene toda la información que permite definirlo e identificarlo frente a otros objetos pertenecientes a otras clases e incluso frente a objetos de una misma clase, al poder tener valores bien diferenciados en sus atributos. A su vez, los objetos disponen de mecanismos de interacción llamados métodos, que favorecen la comunicación entre ellos. Esta comunicación favorece a su vez el cambio de estado en los propios objetos. Esta característica lleva a tratarlos como unidades indivisibles, en las que no se separa el estado y el comportamiento.
    Los métodos (comportamiento) y atributos (estado) están estrechamente relacionados por la propiedad de conjunto. Esta propiedad destaca que una clase requiere de métodos para poder tratar los atributos con los que cuenta.
    El programador debe pensar indistintamente en ambos conceptos, sin separar ni darle mayor importancia a alguno de ellos. Hacerlo podría producir el hábito erróneo de crear clases contenedoras de información por un lado y clases con métodos que manejen a las primeras por el otro. De esta manera se estaría realizando una programación estructurada camuflada en un lenguaje de programación orientado a objetos.
    La POO difiere de la programación estructurada tradicional, en que en esta últimalos datos y los procedimientos están separados y sin relación, ya que lo único que se busca es el procesamiento de unos datos de entrada para obtener otros de salida.
    La programación estructurada anima al programador a pensar sobre todo en términos de procedimientos o funciones, y en segundo lugar en las estructuras de datos que esos procedimientos manejan. En la programación estructurada solo se escriben funciones que procesan datos. Los programadores que emplean POO, en cambio, primero definen objetos para luego enviarles mensajes solicitándoles que realicen sus métodos por sí mismos.

    Programación Orientada a Objetos/Origen


    Los conceptos de la programación orientada a objetos tienen origen en Simula 67, un lenguaje diseñado para hacer simulaciones, creado por Ole-Johan Dahl y Kristen Nygaard, del Centro de Cómputo Noruego en Oslo.
    En este centro se trabajaba en simulaciones de naves, que fueron confundidas por la explosión combinatoria de cómo las diversas cualidades de diferentes naves podían afectar unas a las otras. La idea surgió al agrupar los diversos tipos de naves en diversas clases de objetos, siendo responsable cada clase de objetos de definir sus propios datos y comportamientos. Fueron refinados más tarde en Smalltalk, desarrollado en Simula en Xerox PARC (cuya primera versión fue escrita sobre Basic) pero diseñado para ser un sistema completamente dinámico en el cual los objetos se podrían crear y modificar "sobre la marcha" (en tiempo de ejecución) en lugar de tener un sistema basado en programas estáticos.
    La programación orientada a objetos se fue convirtiendo en el estilo de programación dominante a mediados de los años ochenta, en gran parte debido a la influencia de C++, una extensión del lenguaje de programación C. Su dominación fue consolidada gracias al auge de las Interfaces gráficas de usuario, para las cuales la programación orientada a objetos está particularmente bien adaptada. En este caso, se habla también de programación dirigida por eventos.
    Las características de orientación a objetos fueron agregadas a muchos lenguajes existentes durante ese tiempo, incluyendo Ada, BASIC, Lisp y Pascal, entre otros. La adición de estas características a los lenguajes que no fueron diseñados inicialmente para ellas condujo a menudo a problemas de compatibilidad y en la capacidad de mantenimiento del código.
    Los lenguajes orientados a objetos "puros", por su parte, carecían de las características de las cuales muchos programadores habían venido a depender. Para saltar este obstáculo, se hicieron muchas tentativas para crear nuevos lenguajes basados en métodos orientados a objetos, pero permitiendo algunas características imperativas de maneras "seguras". El Eiffel de Bertrand Meyer fue un temprano y moderadamente acertado lenguaje con esos objetivos, pero ahora ha sido esencialmente reemplazado por Java, en gran parte debido a la aparición de Internet y a la implementación de la Máquina virtual de Java en la mayoría de navegadores. PHP en su versión 5 se ha modificado; soporta una orientación completa a objetos, cumpliendo todas las características propias de la orientación a objetos.

    Programación Orientada a Objetos/Conceptos Fundamentales



    La programación orientada a objetos es una forma de programar que trata de encontrar una solución a estos problemas. Introduce nuevos conceptos, que superan y amplían conceptos antiguos ya conocidos. Entre ellos destacan los siguientes:
    • Clase: definiciones de las propiedades y comportamiento de un tipo de objeto concreto. La instanciación es la lectura de estas definiciones y la creación de un objeto a partir de ellas.
    • Herencia: (por ejemplo, herencia de la clase C a la clase D) es la facilidad mediante la cual la clase D hereda en ella cada uno de los atributos y operaciones de C, como si esos atributos y operaciones hubiesen sido definidos por la misma D. Por lo tanto, puede usar los mismos métodos y variables publicas declaradas en C. Los componentes registrados como "privados" (private) también se heredan, pero como no pertenecen a la clase, se mantienen escondidos al programador y sólo pueden ser accedidos a través de otros métodos públicos. Esto es así para mantener hegemónico el ideal de POO.
    • Objeto: Instancia de una clase. Entidad provista de un conjunto de propiedades o atributos (datos) y de comportamiento o funcionalidad (métodos), los mismos que consecuentemente reaccionan a eventos. Se corresponden con los objetos reales del mundo que nos rodea, o con objetos internos del sistema (del programa). Es una instancia a una clase.
    • Método: algoritmo asociado a un objeto (o a una clase de objetos), cuya ejecución se desencadena tras la recepción de un "mensaje". Desde el punto de vista del comportamiento, es lo que el objeto puede hacer. Un método puede producir un cambio en las propiedades del objeto, o la generación de un "evento" con un nuevo mensaje para otro objeto del sistema.
    • Evento: es un suceso en el sistema (tal como una interacción del usuario con la máquina, o un mensaje enviado por un objeto). El sistema maneja el evento enviando el mensaje adecuado al objeto pertinente. También se puede definir como evento la reacción que puede desencadenar un objeto; es decir, la acción que genera.
    • Atributos: características que tiene la clase.
    • Mensaje: una comunicación dirigida a un objeto, que le ordena que ejecute uno de sus métodos con ciertos parámetros asociados al evento que lo generó.
    • Propiedad o atributo: contenedor de un tipo de datos asociados a un objeto (o a una clase de objetos), que hace los datos visibles desde fuera del objeto y esto se define como sus características predeterminadas, y cuyo valor puede ser alterado por la ejecución de algún método.
    • Estado interno: es una variable que se declara privada, que puede ser únicamente accedida y alterada por un método del objeto, y que se utiliza para indicar distintas situaciones posibles para el objeto (o clase de objetos). No es visible al programador que maneja una instancia de la clase.
    Componentes de un objeto: atributos, identidad, relaciones y métodos.
    Identificación de un objeto: un objeto se representa por medio de una tabla o entidad que esté compuesta por sus atributos y funciones correspondientes.
    En comparación con un lenguaje imperativo, una "variable" no es más que un contenedor interno del atributo del objeto o de un estado interno, así como la "función" es un procedimiento interno del método del objeto.

    Programación Orientada a Objetos/Características de la POO



    Existe un acuerdo acerca de qué características contempla la "orientación a objetos". Las características siguientes son las más importantes:
    • Abstracción: denota las características esenciales de un objeto, donde se capturan sus comportamientos. Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el sistema sin revelar cómo se implementan estas características. Los procesos, las funciones o los métodos pueden también ser abstraídos, y, cuando lo están, una variedad de técnicas son requeridas para ampliar una abstracción. El proceso de abstracción permite seleccionar las características relevantes dentro de un conjunto e identificar comportamientos comunes para definir nuevos tipos de entidades en el mundo real. La abstracción es clave en el proceso de análisis y diseño orientado a objetos, ya que mediante ella podemos llegar a armar un conjunto de clases que permitan modelar la realidad o el problema que se quiere atacar.
    • Encapsulamiento: significa reunir todos los elementos que pueden considerarse pertenecientes a una misma entidad, al mismo nivel de abstracción. Esto permite aumentar la cohesión de los componentes del sistema. Algunos autores confunden este concepto con el principio de ocultación, principalmente porque se suelen emplear conjuntamente.
    • Modularidad: se denomina modularidad a la propiedad que permite subdividir una aplicación en partes más pequeñas (llamadas módulos), cada una de las cuales debe ser tan independiente como sea posible de la aplicación en sí y de las restantes partes. Estos módulos se pueden compilar por separado, pero tienen conexiones con otros módulos. Al igual que la encapsulación, los lenguajes soportan la modularidad de diversas formas.
    • Principio de ocultación: cada objeto está aislado del exterior, es un módulo natural, y cada tipo de objeto expone una interfaz a otros objetos que especifica cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un objeto contra su modificación por quien no tenga derecho a acceder a ellas; solamente los propios métodos internos del objeto pueden acceder a su estado. Esto asegura que otros objetos no puedan cambiar el estado interno de un objeto de manera inesperada, eliminando efectos secundarios e interacciones inesperadas. Algunos lenguajes relajan esto, permitiendo un acceso directo a los datos internos del objeto de una manera controlada y limitando el grado de abstracción. La aplicación entera se reduce a un agregado o rompecabezas de objetos.
    • Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden compartir el mismo nombre; al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando. O, dicho de otro modo, las referencias y las colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un comportamiento en una referencia producirá el comportamiento correcto para el tipo real del objeto referenciado. Cuando esto ocurre en "tiempo de ejecución", esta última característica se llama asignación tardía o asignación dinámica. Algunos lenguajes proporcionan medios más estáticos (en "tiempo de compilación") de polimorfismo, tales como las plantillas y la sobrecarga de operadores de C++.
    • Herencia: las clases no están aisladas, sino que se relacionan entre sí, formando una jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el encapsulamiento, permitiendo a los objetos ser definidos y creados como tipos especializados de objetos preexistentes. Estos pueden compartir (y extender) su comportamiento sin tener que volver a implementarlo. Esto suele hacerse habitualmente agrupando los objetos en clases y estas en árboles o enrejados que reflejan un comportamiento común. Cuando un objeto hereda de más de una clase se dice que hay herencia múltiple.
    • Recolección de basura: la recolección de basura o garbage collector es la técnica por la cual el entorno de objetos se encarga de destruir automáticamente, y por tanto desvincular la memoria asociada, los objetos que hayan quedado sin ninguna referencia a ellos. Esto significa que el programador no debe preocuparse por la asignación o liberación de memoria, ya que el entorno la asignará al crear un nuevo objeto y la liberará cuando nadie lo esté usando.
      En la mayoría de los lenguajes híbridos que se extendieron para soportar el Paradigma de Programación Orientada a Objetos como C++ u Object Pascal, esta característica no existe y la memoria debe desasignarse expresamente.

    Programación Orientada a Objetos/Resumen


    La programación orientada a objetos es un paradigma que utiliza objetos como elementos fundamentales en la construcción de la solución. Surge en los años 70.
    Un objeto es una abstracción de algún hecho o ente del mundo real que tiene atributos que representan sus características o propiedades y métodos que representan su comportamiento o acciones que realizan.
    Todas las propiedades y métodos comunes a los objetos se encapsulan o se agrupan en clases. Una clase es una plantilla o un prototipo para crear objetos; por eso se dice que los objetos son instancias de clases.

    Programación Orientada a Objetos/Lenguajes orientados a objetos


    Simula (1967) es aceptado como el primer lenguaje que posee las características principales de un lenguaje orientado a objetos. Fue creado para hacer programas de simulación, en donde los "objetos" son la representación de la información más importante. Smalltalk (1972 a 1980) es posiblemente el ejemplo canónico, y con el que gran parte de la teoría de la programación orientada a objetos se ha desarrollado.
    Entre los lenguajes orientados a objetos se destacan los siguientes:
    • ABAP -> SAP Lenguaje orientado a eventos
    • ABL Lenguaje de programación de OpenEdge de Progress Software
    • ActionScript
    • ActionScript 3
    • Ada
    • C++
    • C#
    • Clarion
    • Clipper (lenguaje de programación) (Versión 5.x con librería de objetos Class(y))
    • D
    • Object Pascal (Embarcadero Delphi)
    • Gambas
    • Genie
    • Harbour
    • Eiffel
    • Fortran 90/95
    • Java
    • JavaScript (la herencia se realiza por medio de la programación basada en prototipos)
    • Lexico (en castellano)
    • Objective-C
    • Ocaml
    • Oz
    • R
    • Perl (soporta herencia múltiple. La resolución se realiza en preorden, pero puede modificarse al algoritmo linearization C3 por medio del módulo Class::C3 en CPAN)
    • PHP (a partir de su versión 5)
    • PowerBuilder
    • Python
    • Ruby
    • Self
    • Smalltalk (Entorno de objetos puro)
    • Magik (SmallWorld)
    • Vala
    • VB.NET
    • Visual FoxPro (en su versión 6)
    • Visual Basic 6.0
    • Visual DataFlex
    • Visual Objects
    • XBase++
    • Lenguaje DRP
    • Lenguaje de programación Scala (lenguaje usado por Twitter)
    Muchos de estos lenguajes de programación no son puramente orientados a objetos, sino que son híbridos que combinan la POO con otros paradigmas.
    Al igual que C++, otros lenguajes, como OOCOBOL, OOLISP, OOPROLOG y Object REXX, han sido creados añadiendo extensiones orientadas a objetos a un lenguaje de programación clásico.
    Un nuevo paso en la abstracción de paradigmas de programación es la Programación Orientada a Aspectos (POA). Aunque es todavía una metodología en estado de maduración, cada vez atrae a más investigadores e incluso proyectos comerciales en todo el mundo.

    Programa objeto y Programa fuente

    Programa Objeto
    -Es aquel programa que se encuentra en lenguaje máquina y que ya es ejecutable por esta.
    -Es el resultado de traducir un programa fuente para obtener un lenguaje comprensible por la máquina.

    Programación orientada a objetos (OOPS); es una técnica de programación que utiliza objetos como bloque esencial de construcción, es un tipo de programación mas cercana al razonamiento humano; surge como una solución a la programación de grandes programas, y para solventar el mantenimiento de dichas aplicaciones, ya que en la programación estructura el más mínimo cambio supone la modificación de muchas funciones relacionadas, en cambio con la OOPS solo es cuestión de añadir o modificar métodos de una clase o mejor, crear una nueva clase a partir de otra (Herencia). Dos lenguajes destacan sobre el resto para programar de esta forma, Smalltalk y C++.
    Programa fuente 
    -Es el programa escrito en alguno de los lenguajes y que no ha sido traducido al lenguaje de la maquina, es decir el programa que no está en código de máquina y que por lo tanto no puede ser ejecutable.
    -Es aquel que nos permite escribir un algoritmo mediante un lenguaje formal. Por eso al código desarrollado al programar se le llama código fuente.
    Definición de Compilador:
    -Es un programa que traduce un lenguaje de alto nivel al lenguaje máquina. Un programa compilado indica que ha sido traducido y está listo para ser ejecutado. La ejecución de los programas compilados es más rápida que la de los interpretados, ya que el interprete debe traducir mientras está en la fase de ejecución (saca todos los errores). Un compilador es un programa que traduce el programa fuente (conjunto de instrucciones de un lenguaje de alto nivel, por ejemplo Basic o Pascal) a programa objeto (instrucciones en lenguaje máquina que la computadora puede interpretar y ejecutar).
    Definición de codificación:
    Transformación que representa los elementos de un conjunto mediante los de otro, de forma tal que a cada elemento del primer conjunto le corresponda un elemento distinto del segundo.

    Estructura básica de un programa en C++

    Es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup, un lenguaje de programación C con mecanismos que permiten la manipulación de objetos, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.
    *Componente estructural básico; Funciones:
    Directivas de preprocesador
    Declaraciones globales (variables globales, funciones,…)
    Función main()
    {
    Secuencia de declaraciones e instrucciones
    }
    función1 ()
    {
    Secuencia de declaraciones e instrucciones
    }
    ...
    Función ()
    {
    Secuencia de declaraciones e instrucciones
    }
    *Directivas del preprocesador
    Los compiladores de C++ proporcionan bibliotecas de funciones.
    Cada biblioteca de funciones tiene asociado un archivo de definición que se denomina cabecera.
    Para utilizar algo de una biblioteca en un programa, hay que colocar al principio del programa una directiva de preprocesamiento seguida de la cabecera de la biblioteca entre ángulos.
    Instrucciones al compilador antes de que se compile el programa principal
    Las directivas más usuales son:
    # include
    # define
    # include
    Indica al compilador que lea las directivas antes de compilar la función principal
    *La función main()
    Una función C++ es un subprograma que devuelve un valor, un conjunto de valores  o realiza una tarea específica. Todo programa C++ tiene una única función main() que es el punto inicial de entrada al programa. Si se intenta declarar dos funciones main() dentro del programa se produce error.
    Estructura de un programa C++
    #include
    main()
    {
       …
       ...
    }
    Las sentencias escritas entre las llaves se denominan BLOQUE
    #include
    int main()
    {
       entrada_datos();
       proceso_datos();
       return 0;
       ...
    }
    Llamadas a otras funciones.
    *Tipos de datos básicos en C++
    El tipo de dato determina la naturaleza del valor que puede tomar una variable.Un tipo de dato define un dominio de valores y las operaciones que se pueden realizar con éstos valores.
    C++ dispone de unos cuantos tipos de datos predefinidos (simples) y permite al programador crear otro tipo de datos.
    Tipo de datos básicos
    • int ( Números enteros )
    • float ( Números reales )
    • double ( Números reales más grandes que float )
    • bool ( Valores lógicos )
    • char ( Caracteres y cualquier cantidad de 8 bits )
    • void ( Nada. Sirve para indicar que una función no devuelve valores)

    Cuatro momentos decisivos de un emprendedor.

    Tener buenas ideas y ejecutarlas no basta para ser un emprendedor, además hay que saber transitar fracasos y salir de esos momentos con decisiones inteligentes. En este artículo reconoceremos cuatro situaciones que un emprendedor debe sortear en búsqueda del éxito.
    Cada vez hay más emprendedores con ideas renovadoras, cada una en su área, que brillan desde su sencillez, practicidad y modelo de negocio. En algunos casos, resulta llamativo cómo han logrado el éxito rápidamente. Sin embargo, esto es sólo una muestra del final de un recorrido, vale la pena saber que emprender puede ser un trayecto duro, difícil y lleno de fracasos.
    A su vez, esta impresión del fenómeno emprendedor incentiva a otras porciones de la sociedad generando una cadena llena de eslabones. El tema es cuántos de esos eslabones quedan colgando en el camino sin formar la cadena y por qué. Una de las respuestas más rápidas es el miedo al fracaso y el fracaso en sí mismo, algo que sucede a menudo y que deben sortear con las herramientas más insólitas.
    Alejandro Parise desarrolló junto con un grupo de estudiantes universitarios de Córdoba, una aplicación llamada E-valuados que emula el funcionamiento del ya popular juego para móviles Preguntados. La app que esta ideada para que los docentes la usen en sus aulas para optimizar las clases nació en concurso de desarrollo móvil y fue mutando hasta ganar el mismo.
    Pero recién con el premio en las manos el equipo de trabajo logró tener más dudas que certezas: “El lunes siguiente al evento nos reunimos y nos preguntamos qué íbamos a hacer con esa idea que ya tenía forma. ¿La íbamos a continuar o a abandonaríamos? En el equipo de trabajo algunos estudiaban, otros trabajaban, yo trabaja en relación de dependencia. Teníamos que dedicarnos más tiempo aún, lo que seguía ya no era un concurso, y decidimos continuar”.
    Claro que una idea puede resultar ganadora de un concurso, pero la instancia siguiente es de evaluación y estudio constante, y de un trabajo que exige caminar ciego porque no hay nadie que premie cada resultado. “Hay tener mucho valor para seguir con una idea ganadora de un concurso o que recibió un capital de inversión, o que fue captada por una aceleradora.
    Así sea la primera vez que participás o la décima, cuando termina el éxtasis del juego, y para lo cual trabajaste duro, empieza el doble del trabajo. A partir de ahí, tus potenciales clientes e inversores, serán tu jurado” nos cuenta Analía Torrente, desarrolladora móvil, quien asegura que participó en varios equipos de trabajo, pero nunca se prosperó con una idea, aun cuando la misma haya ganado algo.
    Momentos decisivos
    Será preciso entonces que identifiquemos los momentos por los que transita un emprendedor constantemente, siempre teniendo presente que el éxito no es el punto final, sino que en ocasiones es el punto de partida:
    Empezar y no renunciar: Si algo tienen los emprendedores es la capacidad de intentar, pero no todos tienen la capacidad de volver a intentar una y otra vez. Tu idea puede ser muy buena, pero no muy operativa, o puede que algunos no logren visualizarla, no la comuniques bien. Si vencés el miedo ya diste un gran paso, ahora tendrás que aprender a identificar tus debilidades para intentarlo varias veces.
    Estudia tus errores: Son muy pocos los emprendimientos que logran inversión y subsisten en el ecosistema desde el primer intento. Te diría que ninguno. Verás que una vez que intentas y volvés a intentar, el fracaso se convierte en parte de tu estado de ánimo. Es importante que lidies con eso y no sólo que aprendas de tus errores, sino que te conviertas en un analítico de los mismos. Cada error suele contener un código de errores, es decir, un conjunto de decisiones que te llevaron hasta ahí. Encuentra el algoritmo que te saque rápidamente de ese lugar.
    La idea no es tuya: Tuviste una idea brillante de la que no te podés despegar por más que ya hayas fracasado una y otra vez. Te levantás de ese fracaso estudiando tus errores y volvés a lanzarte al ruedo con esa misma idea. ¡Atención! No te cases con una idea. Encarpetala por un tiempo y empezá con otra cosa, es posible que no estés preparado para resolverlo por ahora, o que esa idea no sea tan brillante como te parece. Puede pasar que sólo tenés que revisar cómo lograr esa meta con otro plan de trabajo.
    No tengas miedo de fracasar varias veces: ¿Cuál es la medida justa? En emprendedurismo no hay un número de fracasos ideal para saber cuándo llegará el momento del éxito, sino que existe un calendario de etapas que te propondrás al iniciar el trabajo y que será flexible tanto y en cuanto puedas adaptarte a esos cambios. No temerle al fracaso te permitirá tener un plazo de pruebas en las cuales puedas aumentar los procesos de optimización en cada ejercicio. Eso sí, prueba con pequeñas pruebas para ver qué pasa.
    Ganar, vender, hacer y volver a hacer parecen ser los premios del emprendedor exitoso. Yo te diría a cambio que el verdadero premio es la experiencia adquirida, todo el aprendizaje y los contactos que harás en el camino de aprender. Las nuevas ideas se convertirán en los eslabones de tu cadena.

    Colabore con este blog usando mercadopago.

    Visitenos en:

    Instagram