viernes, 3 de julio de 2015

Introduction to Web Programming

General Concepts

When first facing this new development environment, it's easy to become confused due to the enormous variety of "technologies": HTML, CSS, Javascript, JQuery, PHP, MySQL, ASP.NET, Bootstrap, SQL Server, Ruby on Rails and many more.

The answer to this problem is that every web-related technology can be classified in a certain category. All technologies in that category are essentially equivalent, and deciding which one to use is no more than an administrative decision (though, as usual, some technologies are better suited than others for specific problems or scenarios).

Once we know which category a technology belongs to, we already understand 60% of all there is to know about it. The remainder can be completed with a good reference for the API and syntax.

General structure of a web application

Every web app does essentially the same, no matter which technologies it uses:

  1. Provide a query/data input interface (frontend): This allows the user to enter data. Said data is usually called a "query" because they are used to dynamically consume a service provided by the computer (or computers) where the web server is hosted.
  2. Transmit the query to the web server, typically using the HTTP protocol.
  3. Process the query inside the server (backend): The web server processes the query data. This is where server-side scripting kicks in (more about this later).
  4. Create the response for the query: The format is defined by the query. Usually, it's XML, SOAP or JSON (with JSON being the current defacto standard).
  5. Send the response to the client, typically over the HTTP protocol.
  6. Process the response in the client side: This might be as simple as rendering HTML, but it involve calculations and extra logic which can be defined using client-side scripting (more on this later).

Let's see some examples of how web applications fit into this structure. The possible ways to combine technologies are virtually endless. Among them:

  • The client 1)requests the web browser to 2) contact a web server using the HTTP protocol and 3) asks for a 4) specific HTML document which the server 5)returns as is so that 6) the browser can render it.
  • There is a 1) Java client (a JVM running on the client computer) that 2) sends an ecrypted request, using HTTPS, to a Java Web Server that 3) processes the request using a Java Servlet which in turns uses a CORBA object to programatically generate 4) business data in XML format with an associated XSL style sheet which is in turn 5) sent to the client to 6) be rendered by the web browser as a tabe.

Types of web technologies

A while ago, we said that every web tech belongs to a category. There are various such classifications, but one of the simplest is the following:

  • Presentation: Defines how to display data on the client side. Examples: HTML, CSS. Some people set apart those technologies used to send the data: JSON, SOAP, RESTful services.
  • Server-side scripting (backend): When static HTML pages are not enough, they can be dynamically generated by the server before being sent to the client. This is possible using server-side scripting languages. Examples: PHP, ASP.NET, Perl, Python,,Ruby.
  • Client-side scripting (frontend): Nowadays, all web browsers have scripting engines. This allows for the execution of code in the client computer, which saves server resources and lets pages be more "interactive". Examples: Javascript (defacto standard).
  • Data Access: Database engines. These are the same as in Desktop programming. Examples: MySQL, SQL Server, Oracle.

Client-side scripting Libraries

Programming with "bare bones" Javascript is quite gruesome and error prone. That is why many libraries have surfaced to make developmente more productive: JQuery, Bootstrap, MochiKit, prototype, mootools. Aside from these "lightweight" libraries, there are big frameworks which offer a wider array of premade functionality, such as : AngularJS, YUI, Dojo, Backbone. Among all these, JQuery has emerged as the current defacto standard.

Introducción a la Programación Web

Generalidades

Ante el primer contacto con este nuevo entorno de desarrollo, es fácil marearse ante la gran variedad de “tecnologías”: HTML, CSS, Javascript, JQuery, PHP, MySQL, ASP.NET, Bootstrap, SQL Server, Ruby on Rails y muchas más.

La respuesta a este problema es que toda tecnología web puede clasificarse en una categoría. Todas las tecnologías de una misma categoría son esencialmente equivalentes, y decidir cuál usar es una decisión burocrática (aunque, como siempre, algunas tecnologías son mejores que otras en ciertas situaciones).

Una vez que sabemos a qué categoría pertenece una tecnología, ya entendemos el 60% sobre ella. El resto es conseguir una buena referencia para la API y la sintaxis.

Esquema general de una aplicación web

Toda aplicación web hace básicamente lo mismo, más allá de qué combinación de tecnologías use:

  1. Proveer una interfaz de consulta/ingreso de datos (frontend): Para que el usuario ingrese datos. Dichos datos, en conjunto, suelen llamarse “query” porque son usados para consultar o pedir dinámicamente un servicio provisto por la máquina o máquinas que alojan el web server (puede haber más de una).
  2. Transmitir la query al web server.
  3. Hacer procesamiento del lado del servidor (backend): El web server procesa los datos recibidos usando una especie de “middleware”.
  4. Armar el resultado a devolver: El formato está definido por la query.
  5. Devolver los resultados al cliente.
  6. Hacer procesamiento del lado del cliente: Puede ser tan simple como mostrar HTML o tan complejo como hacer cálculos, ordenar u otros manejos extra.

Veamos cómo algunos ejemplos de aplicaciones web entran en este esquema. Las posibles combinaciones de tecnologías son muchísimas. Entre ellas:

  • El cliente 1)le pide al web browser que 2) contacte un servidor web usando el protocolo HTTP y 3) le pida un 4) documento HTML específico que el servidor 5)devuelve para que 6) el browser del cliente lo muestre.
  • Tenemos un 1) cliente Java (una JVM que corre en la máquina del cliente) que 2) envía un pedido encriptado a un Java Web Server que 3) procesa el pedido con una Servlet Java que usa un objeto CORBA para generar sistemáticamente 4) datos de negocio en formato XML con una hoja de estilo XSL asociada que es 5) enviada al cliente para 6) mostrarse en su browser como una tabla.

Tipos de tecnologías web

Antes dijimos que toda aplicación web pertenece a una categoría. Existen diversas clasificaciones, pero una de las más sencillas es la siguiente:

  • Presentation: Permiten definir cómo mostrar la información en el cliente. Ejemplos: HTML, CSS. Hay quienes ponen aparte las tecnologías usadas para enviar los datos: JSON, SOAP, RESTful services.
  • Server-side scripting (backend): Cuando las páginas estáticas no son suficientes, es necesario generarlas en el servidor. Esto es posible usando lenguajes de server-side scripting. Ejemplos: PHP, ASP.NET, Perl, Python,,Ruby.
  • Client-side scripting (frontend): Hoy en día, todos los navegadores tienen engines de scripting. Esto permite ejecutar código en la máquina del cliente, lo cual permite ahorrar recursos del servidor y permite hacer las páginas más "interactivas". Ejemplos: Javascript (estándar de facto).
  • Data Access: Motores de base de datos. Esto es lo mismo que en el entorno Desktop. Ejemplos: MySQL, SQL Server, Oracle.

Bibliotecas de client-side scripting

Programar con Javascript "pelado" es bastante engorroso y propenso a error. Por eso han surgido varias bibliotecas que hacen más productivo el desarrollo: JQuery, Bootstrap, MochiKit, prototype, mootools. Aparte de estas bibliotecas "livianas", existen frameworks que proveen un mayor conjunto de funcionalidad: AngularJS, YUI, Dojo, Backbone. Entre todas estas, JQuery se ha erigido como un estándar de facto.

lunes, 13 de mayo de 2013

C++ 11's new style, explained by Bjarne Stroustrup

In a series of very interesting presentations in Microsoft's GoingNative2012 event, C++'s main creator, Bjarne Stroustrup himself, talked about the programming style introduced by the brand new C++11 standard.

The main focus of Bjarne's presentation was not the new language features, but how to use them correctly; that's what he calls "style". Up next, a summary of the key points raised:

  • Type-rich interfaces: Programmer-defined suffixes can now be used to indicate measuring units (see the new constexpr keyword).
  • Use RAII to handle resources: memory, files, sockets, hardware, operating system resources (threads, mutexes, semaphores, etc).
  • Avoid raw pointer usage, specially in public interfaces (restrict those usages to single method implementation scope). Use smart pointers classes such as unique_ptr and shared_ptr. Don't use the latter if the resource needs to be shared. And before considering pointers, consider references, or even better, create objetos on stack. All this discussion pertains to using pointers to express possession of a resource. If we just want to point to an object which does not belong to us and we can't use a reference, a pointer is acceptable.
  • Avoid native arrays; use STL containers. If passing a native array to a third-party API is necessary, an std::vector can be used, since it is guaranteed by the standard to use contiguous memory, just like a native array does. The API function should then be passed &v[0], where v is an std::vector.
  • When managing large objects (for instance, a Matrix class which we use to represent 10000 x 10000 matrices), and we want to write a method which returns an instance of that class (say, an operator+), we are forced to create a local instance and return a copy. That's a lot of overhead; a new, essential feature of C++11 is "move semantics". Instead of copying, we "move". In the previous example, we return a Matrix by value and implement a "move constructor", which defines how the "move" operation should be performed. Details on this will be left to future posts. Suffice it to say that all STL containers implement this, with the exception of std::array. This implies a significant performance boost just by compiling existing STL-using code with a C++11 compiler.
  • Use whenever possible.
  • Low level code isn't always more efficient. (for instance: C's sort function is orders of mangnitude slower than C++'s qsort). Always measure (profile) when in doubt and avoid complex premature optimizations. Low level usually means more code, which increases the chance of bugs and manteinance cost.
  • C++ 11 offers new classes for handling concurrency: std::thread and std::mutex, among others. Even better: std::async lets the runtime decide whether to use a separate thread or not, letting the programmer forget about many complexities of concurrence handling involved when handling theads manually.
  • También se agrega soporte para expresiones lambda.

Finally, here's a chart that lists which C++ 11 features are implemented by which compiler (MSVC = Visual Studio)

C++ 11 y su nuevo estilo, explicado por Bjarne Stroustrup

En una serie de charlas muy interesantes del evento GoingNative2012 organizado por Microsoft, el mísmisimo creador de C++, Bjarne Stroustrup, dio una charla sobre el nuevo estilo de programación introducido por el nuevo estándar C++ 11.

El tema de la charla no son las nuevas funcionalidades del lenguaje, sino cómo usarlas correctamente; eso es lo que Bjarne denomina "estilo". A continuación, un resumen de los puntos esenciales:

  • Type-rich interfaces: Se puede usar sufijos para indicar unidades, por ejemplo (ver la nueva keyword constexpr).
  • Usar RAII para recursos: memoria, archivos, sockets, hardware, recursos del sistema operativo (threads, mutexes, semáforos, etc).
  • Evitar el uso de punteros, especialmente en interfaces (mantener esos usos acotados a implementaciones de funciones). Usar smart pointers como unique_ptr y shared_ptr. No usar este último si no se está compartiendo el recurso. Y antes de considerar usar punteros, considerar usar referencias, o aún mejor, crear los objetos en stack. Todo esto cuando hablamos de usar punteros para expresar la pertenencia de un recurso. Si sólo queremos apuntar a un objeto que no es nuestro y no podemos usar una referencia, usar un puntero es aceptable.
  • Evitar arrays nativos; usar contenedores STL. Si es necesario pasar un array nativo a una API de terceros, por ejemplo, se puede usar un std::vector, que garantiza que toda la memoria sea contigua, igual que en un array nativo. A la función de la API se le pasa &v[0], donde v es el std::vector.
  • Cuando tenemos objetos grandes (por ejemplo, una clase Matrix que usamos para matrices de 10000 x 10000), y queremos hacer una función que devuelva una instancia de esa clase (un operator+, por ejemplo), tenemos el problema de que creamos una matriz local y devolvemos una copia. Es mucho overhead; una nueva funcionalidad clave de C++ 11 son las "move semantics". En vez de copiar, "muevo". En el ejemplo dado, devolvemos una Matrix por valor e implementamos un "move constructor", que define cómo se hace el "move". Más detalles sobre esto en un post futuro. Baste con aclarar que todos los contenedores de la STL implementan esto (excepto std::array), con lo cual la performance sube sólo por compilar para C++11 si ya usábamos contenedores STL.
  • Usar siempre que sea posible.
  • El código de bajo nivel no siempre es más eficiente (por ej: el sort de C es más lento que el qsort de C++). Siempre medir ante la duda y evitar micro-optimizaciones prematuras. Bajo nivel implica escribir más código, lo cual implica mayor posibilidad de bugs y mayor costo de mantenimiento.
  • C++ 11 ofrece clases para manejo de concurrencia: std::thread y std::mutex, entre ellas. Incluso mejor, std::async permite decidir al runtime si usar otro thread o no, dejándole toda la complejidad del manejo de la concurrencia.
  • También se agrega soporte para expresiones lambda.

Por último, acá hay un cuadro con qué funcionalidades de C++ 11 implementa cada compilador (MSVC = Visual Studio)

miércoles, 24 de abril de 2013

Visual Studio 2010 SP1 and C++/CLI strong naming bug

This particular Visual Studio version has a bug which breaks strong naming signing for C++/CLI assemblies. Said bug is documented and has a workaround which requires editing a .Targets file. Details here. In case the link dies, I'll copy the steps below:
  1. Go to %ProgramFiles(x86)%\MSBuild\Microsoft.Cpp\v4.0\Platforms\Win32
  2. Open Microsoft.Cpp.Win32.targets with a text editor (this might require administrator rights)
  3. Search for <Target Name="LinkEmbedManifest"
  4. Inside that tag, in the DelaySign attribute value, change % to $, and Link.DelaySign to LinkDelaySign (delete the period)
  5. Do the same for the KeyFile attribute (don't forget to change Link.KeyFile to LinkKeyFile)

Visual Studio 2010 SP1 y strong naming para C++/CLI

Este Visual tiene un bug que rompe la firma de assemblies C++/CLI con strong naming. Dicho bug está documentado y tiene una solución que requiere tocar un archivo .Targets del Visual Studio. Los detalles aquí. Por si el link se muere, copio los pasos a seguir:
  1. Ir a %ProgramFiles(x86)%\MSBuild\Microsoft.Cpp\v4.0\Platforms\Win32
  2. Abrir Microsoft.Cpp.Win32.targets con un editor de texto (esto puede requerir derechos de administrador)
  3. Buscar el texto <Target Name="LinkEmbedManifest"
  4. Dentro de ese tag, en el valor de la property DelaySign, cambiar % por $, y Link.DelaySign por LinkDelaySign (borrar el punto)
  5. Lo mismo para la property KeyFile (no olvidar borrar el punto para que Link.KeyFile pase a ser LinkKeyFile)

jueves, 29 de noviembre de 2012

The Horror: Uninstalling SQL Server 2008 R2 and his friends

It's common knowledge that even though Microsoft claims it's possible to have multiple versions of SQL Server Express side by side, that's generally considered a bad idea. So I set out to remove every trace of SQL Server in order to later install the latest R2 version.

After many visits to Control Panel->Add or Remove Programs, in which I removed anything which had SQL Server in its name, four (4) creatures were left standing:

  • Microsoft SQL Server 2008
  • Microsoft SQL Server 2008 Setup Files
  • Microsoft SQL Server 2008 R2
  • Microsoft SQL Server 2008 R2 Setup Files

If I tried to remove the setup files, I was told that I had to remove 2008 or 2008 R2 before. If I tried removing one of those, after running the whooooooole process without a hitch, the entry was still there. On a closer examination, R2 was always saying it was going to delete Microsoft Sync Framework, but it didn't do so (silently). So I tried nuking the sync framework myself, but then I was warned that many programs needed it, including Visual Studio 2010. Since I use that every day, I ran away in terror.

At this point, I realized I should have followed some guide when nuking the various SQL components and helper. But it was too late, so I decided to destroy all traces of SQL Server with a vengeance. This implied deleting the whole C:\Program Files\Microsoft SQL Server directory, and deleting every registry key associated, as explained in the answer to this question on Social MSDN.

But even after all that, there were still three entries on Add or Remove Programs (2008 Common Files, 2008 and some other I don't remember). After another long and fruitless look at the registry, I stumbled upon a Microsoft Fixit that saved my life..

After running it thrice, once per zombie entry, every trace of SQL had seemingly vanished. Then, I ran the SQL Server 2008 R2 installer, and I got several errors. But then I just ran the uninstaller from Add or Remove Programs and tried again, as suggested in this post. And I finally succeeded.