sábado, 18 de enero de 2020

ASP.NET Core - CRUD en MVC con C# - Parte 1

Hola que tal, en este apartado aprenderás a crear el proyecto, sobre la estructura del proyecto, configuración de la Aplicación y creación del Layout, ViewImports, ViewStart e importar la librería Bootstrap y sobre editar una página de Razor.

Comencemos el desarrollo del ya conocido CRUD (Create, Read, Update and Delete), para este caso elaboraremos paso a paso el proyecto sin hacer uso de las plantillas; el proyecto se denominará con nombre de DEMO01_CRUD,:

Requisitos:
Visual Studio 2019 Community
Aplicación web ASP.NET Core
.NET Core, ASP.NET Core 2.1

Crear la solución y proyecto:
Crear la solución de nombre DEMO01_CRUD
Escribir SOLUCI en la opción buscar, seleccionar - Solución en blanco - clic en siguiente...
Ingresas el nombre, asignas la ruta y clic en crear (en las anteriores versiones del Visual Studio ambos pasos se realizaba en una sólo opción)
Crear el proyecto de nombre DEMO01_CRUD, de tipo .NET Core, ASP.NET Core 2.1:
En Visual Studio 2019 para poder agregar un nuevo proyecto debe hacer clic derecho en la solución creada anteriormente, seleccionar la opción agregar y luego clic en nuevo proyecto (en las anteriores versiones al crear la solución te brindaba la opción de poder crear  el tipo de proyecto).
Seleccionar en el tipo de lenguaje C#, seleccionar tipo de plataforma para Windows y finalmente en tipo de proyecto para Web y clic en siguiente
Ingresas el nombre, asignas la ruta y clic en crear (en las anteriores versiones del Visual Studio ambos pasos se realizaba en una sólo opción)
Verificamos la versión 2.1 de ASP.NET Core (para Visual Studio 2019 por defecto esta seleccionado la versión 3.1 - luego haremos algunas comparativas interesantes entre ambas versiones), seleccionamos tipo de plantilla Vacío y clic en crear
Estructura del proyecto .NET Core:
Normalmente los proyectos creados de .NET Core te crea la siguiente estructura al seleccionar plantillas (para este CRUD crearemos un proyecto tipo de plantilla vacío):

Controllers: Contiene los controladores que son clases para crear los servicios REST básicos.
ValuesController.cs: Archivo de ejemplo con un servicio REST llamado values que regresa un arreglo con 2 valores.
wwwroot: Contiene los archivos estáticos como imágenes, css y javascripts.
appsettings.json: Nos permite configurar aspectos básicos de nuestra aplicación como la cadena de conexión a base de datos, log de errores, seguridad, propiedades personalizadas, keys etc.
Program.cs: En este programa se define como iniciar el servidor web. Recordemos que los proyectos de .NET Core son un programa de consola que crea un servidor web.
Startup.cs: Permite configurar los servicios disponibles, como los servicios Rest, la base de datos, seguridad, documentación.

La estructura que ahora se muestra es de un proyecto de tipo plantilla vacío.
Configuración de la Aplicación Web ASP.Net Core:
Abrimos y modificando el método Configure de la clase Startup.cs por el siguiente código:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;

namespace DEMO01_CRUD
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            app.UseStaticFiles();
            app.UseDeveloperExceptionPage();
            app.UseMvc(router =>
            {
                router.MapRoute(
                name: "default",
                template: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }

}

Que es un UseMvc: UseMvc es una extensión en IApplicationBuilder que toma un delegado de acción de IRouteBuilder. IRouteBuilder se usa para configurar el enrutamiento para MVC.

Crear Layout, ViewImports, ViewStart, agregar Bootstrap y directorios:
Crearemos el directorio view en la raíz de nuestro proyecto y el luego creamos el sub directorio shared.

Seguidamente clic derecho en el directorio shared seleccionar Agregar, Nuevo Elemento. Visualizará una nueva ventana que muestra la lista de elementos, de esta lista seleccione el de Tipo: Visual C# "Página de diseño de la vista Razor" y haga clic en el botón "Agregar".
Agregando un _Layout.cshtml
Editar una página de Razor:
Modifique y guarde la página con el siguiente marcado resaltado de color naranja:

<!DOCTYPE html>
<html>
<head>
    <meta name="viewport" content="width=device-width" />
    @*<title>@ViewBag.Title</title>*@
    <title>@ViewData["Title"]</title>
    <link href="/lib/bootstrap-4.3.1/dist/css/bootstrap.css" rel="stylesheet" />
</head>
<body>
    <div class="container">
        <div class="row justify-content-center">
            <h1>CRUD MVC ASP.Net Core 2.1</h1>
        </div>
    </div>
    <div class="container body-content">
        @RenderBody()
    </div>
</body>
</html>

Que es un Loyout (_Layout.cshtml): Es la vista de diseño que contiene html Doctype, head y body como html normal, la única diferencia es llamar a los métodos RenderBody() y RenderSection(). RenderBody actúa como un marcador de posición inicial para otras vistas.

Por ejemplo, la vista Index.cshtml se creará en el sub directorio Home (..Views\Home) que se inyectará y representará como la vista de diseño que sera llamado por método RenderBody() del _Layout.cshtml (recordemos a los Master Page de web forms).

El @*<title>@ViewBag.Title</title>*@ es remplazado por <title>@ViewData["Title"]</title> El ViewData al igual que el ViewBag son utilizados para transferir datos del controlador a la vista. ViewData es un diccionario que puede contener pares clave-valor donde cada clave debe ser una cadena al igual que se visualiza en el "Title" que sera el encargado de transferir el titulo de la vista asociado al _Layout.cshtml.

Descargas el Package Bootstrap
Luego clic derecho en wwwroot y creamos el directorio lib agregamos todo el contenido que se encuentra en carpeta de bootstrap-4.3.1. Después hacer referencia en el _Layout.cshtml agregan el siguiente <link href="/lib/bootstrap-4.3.1/dist/css/bootstrap.css" rel="stylesheet" />

A continuación haga clic derecho en el directorio carpeta view seleccionar Agregar, Nuevo Elemento. En la lista de elementos, seleccione Importaciones de la vista de Razor" de Tipo Visual C# "Página de importaciones de la vista de Razor" y haga clic en el botón "Agregar". Esto agregará el archivo _ViewImports.cshtml.
Agregando un _ViewImports.cshtml
Crea el directorio Models en la raíz del proyecto (por ahora solo nos servirá para importar en _ViewImports.cshtml)

Abre el archivo _ViewImports.cshtml e importa los siguiente espacios de nombres:

@using DEMO01_CRUD.Models
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers

Los TagHelpers son nuevas características en ASP.NET Core, que nos ayudan a agregar fácilmente el código que es bastante parecido al HTML estándar, pero es procesado por el motor Razor en el servidor, lo que le brinda la ventaja de la representación del lado del servidor.

Finalmente para ir cerrando la primera parte de este apartado; clic derecho en el directorio carpeta view seleccionar Agregar, Nuevo Elemento. En la lista de elementos, seleccione Inicio de la vista de Razor" de Tipo Visual C# "Página de inicio de la vista de Razor" y haga clic en el botón "Agregar". Esto agregará el archivo _ViewStart.cshtml.
Agregar un _ViewStart.cshtml
Al agregar el archivo _ViewStart.cshtml se creará con el siguiente código inicial:

@{
    Layout = "_Layout";
}

Código que indica que todas las vistas tendrán el diseño del archivo _Layout.cshtml que se encuentra dentro de la carpeta shared (compartida).

Hasta ahora el proyecto contendrá la siguiente estructura:
Estructura de una Aplicación Web ASP.Net Core
En esta primera parte usted aprendió acerca de como:
Crear la solución y proyecto en ASP.Net Core
Sobre estructura del proyecto en ASP.Net Core
Sobre configuración de la Aplicación Web ASP.Net Core
Crear Layout, ViewImports, ViewStart e importar la librería Bootstrap
Además de editar una página de Razor

Parte 2: Crear la base de datos, cadena de conexión, agregar el modelo de datos y función de validación de lado del cliente.

viernes, 10 de enero de 2020

ASP.NET Core - Implementando CRUD en MVC con C#

Hola a todos, antes de iniciar cualquier desarrollo e implementación de una aplicación web haciendo uso de este magnifico Framework - ASP.NET Core; comenzaremos con el desarrollo del ya conocido CRUD (Create, Read, Update and Delete).

Como ya es conocido por muchos que Microsoft está escalando grandes pasos hacia el software libre acompañado de su IDEs como Visual Studio y Visual Studio Code.

Requisitos:
Microsoft Visual Studio Community 2019
Microsoft .Net Framework
Microsoft SQL Server 2017 (RTM-GDR) - Express Edition (64-bit)
Framework Bootstrap (para mejorar el diseño de nuestra aplicación)
Framework  jQuery Validation (para la validación de lado del cliente)

Aquí dejo todos los pasos a seguir:
ASP.NET Core - CRUD en MVC con C# - Parte 1
ASP.NET Core - CRUD en MVC con C# - Parte 2
ASP.NET Core - CRUD en MVC con C# - Parte 3

Puedes descargar la fuente desde:
Agradecer de antemano por la acogida de este nuevo artículo publicado acerca cómo Implementar un CRUD en MVC con C# haciendo uso de ASP.NET Core, y anunciar que en los próximos días publicaremos nuevos artículos acerca de Xamarin.From, Oracle y Cloud Computing.

Bendiciones, fuerte abrazo a todos...!!!

Te puede interesar:
ASP.NET Core - PAGINACIÓN en MVC con C#

sábado, 4 de enero de 2020

¿Qué es ASP.NET Core?


ASP.NET Core es totalmente un nuevo Framework de código abierto y multiplataforma para la creación de aplicaciones modernas conectadas a Internet, normalmente conocidas como aplicaciones Web y APIs Web.

Diseñado para proporcionar un desarrollo optimizado para las aplicaciones que se implementan tanto en la nube como en servidores dedicados en las instalaciones de entorno local del cliente.

Se pueden desarrollar y ejecutar aplicaciones ASP.NET Core ya sea en los sistemas operativos como Windows, Mac y Linux; ASP.NET Core puede ejecutarse sobre el Framework .NET completo o sobre .NET Core.

.NET Core es una nueva versión modular del Framework .NET que permite el uso multiplataforma de .NET; es decir una abstracción o un subconjunto del Framework .NET por lo que no tiene toda la funcionalidad del Framework completo, y puede emplearse para creación de aplicaciones web, de escritorio y móviles.

El uso del Framework .NET completo nos permitirá poder añadir cualquier dependencia que necesitemos del Framework, pero perderemos todas las ventajas que tienen las aplicaciones .NET Core, tales como la multiplataforma, la mejora del rendimiento, el menor tamaño de las aplicaciones, entre otras bondades. Para analizar los ensamblados y ver si se pueden portar a .NET Core aplicaciones de .NET se sugiere hacer uso de analizador de portabilidad de .Net.

¿Por qué utilizar ASP.NET Core en lugar de ASP.NET?
ASP.NET Core es un rediseño totalmente completo de ASP.NET, es decir NO es una actualización de ASP.NET 4, por lo que su arquitectura ha sido diseñada para resultar más ligera y modular.

ASP.NET Core no está basado en System.Web.dll que aporta un exceso de funcionalidad, se basa en un conjunto de paquetes NuGet granulares y bien factorizados, permitiendo optimizar tu aplicación para incluir solo los paquetes NuGet que necesitas.


Algunos beneficios de ASP.NET Core contra ASP.NET:
Seguridad más estricta: Menor intercambio de información y rendimiento mejorado, ya que está formado por paquetes NuGet, lo que permite una modularidad total, de ésta forma solo añadiremos los paquetes con la funcionalidad que necesitemos.
Plataforma unificada: Una sola plataforma para la creación de interfaz web y las APIs web.
Integración de los frameworks modernos de cliente y flujos de trabajo de desarrollo.
Un sistema de configuración basado en la nube. Preparado para su integración de forma sencilla en entornos en la nube.
Inyección de dependencias incorporada.
Las peticiones HTTP se procesan siguiendo un flujo que puede ser modificado de forma modular para adaptarse a nuestras necesidades, que nos permite poder controlar el procesado de las peticiones HTTP en nuestra aplicación.
Capacidad para alojar en IIS u otros servidores web como Apache. o self-host en su propio proceso.
Nuevas herramientas: Para simplificar la fase de desarrollo web moderno.
Crea y ejecuta aplicaciones multiplataforma ASP.NET Core en Windows, Mac y Linux.
Orientado a código abierto y de amplia comunidad en constante crecimiento.

Mi Conclusión:
ASP.NET Core es un Framework totalmente creado desde cero pensado en la implementación de multiplataforma y buscando lo mayor eficiencia posible. Por ello, desde YA es interesante aprenderla en el caso de que quieras crear aplicaciones web que sean capaces de ejecutarse en Windows, Linux o Mac, o si el rendimiento es realmente crucial para todas tus implementaciones web y las APIs.

Considerando que el equipo de desarrollo de .NET en Microsoft está dedicado y volcado en esta nueva edición y lo seguirá estando en los próximos años, así que cada vez tendrá mayor relevancia a considerar el nuestras próximas implementaciones.


Algunas páginas recomendadas:

A seguir aprendiendo la que más nos apasiona... que viva la Arquitectura | Software | Mejora de Procesos | Agile e Innovación Digital, no todo es relacionado al desarrollo de software ;) siempre hay algo que aprender y recuerden... la pasión es las que te mueve, no lo que te pagan necesariamente, eso después viene, el dinero es un resultado... prepárate y esté listo... excelente año 2020 para todos.

También te puede interesar:

sábado, 3 de agosto de 2019

Buscar Texto en archivo config o txt – C#

Dada la necesidad de realizar la búsqueda de una palabra en particular (que debe ser remplazada más adelante) en archivos de tipo “.congif” de ciertas aplicaciones web y servicios desplegadas en un determinado servidor; tratándose de lo tedioso o complejo que puede surgir dicha actividad e decido implementar un pequeño proceso que realice la operativa de buscar el tipo de archivo y encontrar la coincidencia de una determinada palabra que puede ser remplazada u otros fines en particular según el caso amerite.

1.      Requisitos:
Visual Studio 2017 Community
Programación C# - Console
Framework 4.6 (para desarrollo y ejecución compilada)

2.      Crear aplicación de tipo consola:

2.1.   Crear la solución de nombre ConsoleApp
2.2.  Crear el proyecto de nombre ConsoleAppSearchText, tipo de Aplicación de Consola y seleccionar el Framework 4.6:

-    Se agregar la clase Program.cs, y
-    El archivo App.config

3.      Asignar valores a las llaves:

3.1.   App.config: Agregar valores relacionado a la búsqueda.

       Agregar la sección <appSettings></appSettings> en el archivo App.config, y sobre dicha sección ingresar las siguientes llaves (keySearchTextValue, keyFileRouteScan y keyFileExtension) y valores (server999, \\route\of\application\web\ y .config):

<appSettings>
      <add key="keySearchTextValue" value="server999" />
      <add key="keyFileRouteScan" value="\\route\of\application\web\" />
      <add key="keyFileExtension" value=".config" />
</appSettings>

Detalle de las llaves:

keySearchTextValue: El valor de la palabra en particular a buscar.
keyFileRouteScan: Ruta principal del directorio donde se ubicara e iniciara la búsqueda.
keyFileExtension: Extensión del archivo donde se buscara la palabra en particular.

4.     Implementar la solución:

4.1.   Program.cs: Implementar la solución en la clase Program

Importar los namespace System.Collections.Generic, System.Linq,  System.Configuration y System.IO:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Configuration;
using System.IO;

4.2.   Invocar las llaves agregadas en el archivo App.config para poder leer los valores:

Para la lectura de un archivo de configuraciones se debe importar el namespace using System.Configuration.

Crear las validables strContains, strFolderScan y strExtension de tipo string; variables que se encargaran de leer los valores ingresados en las llaves del archivo de configuraciones – App.config:

string strContains = ConfigurationSettings.AppSettings["keySearchTextValue"].ToString();
string strFolderScan = ConfigurationSettings.AppSettings["keyFileRouteScan"].ToString();
string strExtension = ConfigurationSettings.AppSettings["keyFileExtension"].ToString();

4.3.   Leer las variables de tipo string que se asignan los valores de las llaves ingresadas en el archivo App.config:

Proporcionar las propiedad y métodos para poder crear, copiar, eliminar, mover o abrir archivos, en este caso lo que se realizará será abrir cada archivo a buscar según la extensión (.config – según nuestra implementación a elaborar para la solución del caso) y ruta de la ubicación encontrada, para esto se debe importa el namespace using System.IO y agregar las siguientes líneas de código:

DirectoryInfo dir = new DirectoryInfo(strFolderScan);
IEnumerable<FileInfo> fileList = dir.GetFiles("*.*", SearchOption.AllDirectories);

Detalle de código ingresado:

DirectoryInfo dir = new DirectoryInfo(strFolderScan);

Inicializa la instancia de la clase DirectoryInfo para realizar la lectura de la ruta de acuerdo al valor obtenido de la validable strFolderScan, que se encarga de leer el valor de la llave keyFileRouteScan ("\\route\of\application\web\")

IEnumerable<FileInfo> fileList = dir.GetFiles("*.*", SearchOption.AllDirectories);

Se encarga de listar en memoria todos los archivo encontrado según la ruta inicial ingresada. Para el uso del enumerador (IEnumerable) se debe importar el namespaces using System.Collections.Generic;

4.4.   Construye el script de tipo LINQ y almacenar valores en memoria:

     Almacenar la lista de archivos (según la lista en memoria) encontrados y filtrar de acuerdo a la extensión ingresada “.congif” (según nuestra implementación a elaborar para la solución del caso), para ello se construye el script de tipo LINQ y se filtra de acuerdo al valor de la variable strExtension, que se encarga de leer el valor de la llave key="keyFileExtension" value=".config"

IEnumerable<FileInfo> fileQuery =
           from file in fileList
           where file.Extension == strExtension//".config"
           orderby file.Name
                  select file; 

Para el uso LINQ se debe importar el namespaces using System.Linq;

4.5.   Listar ubicación y línea de la coincidencia del texto encontrado:

       Recorrer la lista según el script LINQ y leer todos los archivos de extensión “.congif” y pintar en la consola todos los valores que contiene el texto server999

foreach (FileInfo fi in fileQuery)
            {
                int counter = 0;
                string[] lines = File.ReadAllLines(fi.FullName);
                Console.WriteLine("LOCATION " + fi.FullName);

                foreach (string line in lines)
                {
                    counter++;
                    if (line.Contains(strContains))//server999
                        Console.WriteLine("\t" + "LINE " + counter + " :: " + line);
                }
}      

Detalle de código ingresado:

La variable int counter = 0 inicializa con 0, incrementa en el segundo foreach al recorrer el contenido del archivo ubicado.

La variable string[] lines = File.ReadAllLines(fi.FullName) se encarga de leer línea por línea del archivo ubicado

Console.WriteLine("LOCATION " + fi.FullName) Encargado de pintar toda la ubicación o ruta de cada archivo encontrado de tipo extensión “.congif”

Console.WriteLine("\t" + "LINE " + counter + " :: " + line) Encargado de pintar el número de la ubicación (counter) donde fue encontrada la coincidencia del texto encontrado (line=”server999”) en el archivo de tipo extensión “.congif”

Para poder conocer más acerca de la sentencia foreach en C# puede visitar la página de Microsoft.

5.      Ejecutar solución implementado:

Resultado:
La coincidencia de la palabra server999 se ubican en la línea 15 y 22 del archivo C:\Users\...\Web – copia.config


6.      Conclusión:

La solución planteada pretende agilizar la búsqueda del texto en particular en un archivo de tipo “.config” y posicionar la línea de la coincidencia y ubicación completa del archivo donde se encontró dicha coincidencia.

Se puede aplicar para archivos de tipo “.txt” cambiando la llave keyFileExtension (<add key="keyFileExtension" value=".txt" />)

Puedes descarga el código fuente desde GitHub:
 Console Applitacion in C Shared

domingo, 11 de noviembre de 2018

Qué es SoLoMo?

Qué es SoLoMo?
Es la combinación del comienzo de tres palabras - Social, Location y Mobile. En realidad es una nueva tendencia donde las tecnologías vienen transformando el paradigma de las comunicaciones, todo esto gracias a las aplicaciones móviles que pueden interactuar en tiempo real compartiendo información a través de las redes sociales con procesamiento de datos y situaciones geográficas aplicando la difusión de algún producto o servicio.

Lo interesante de todo esto es que nos encontramos cada día en un mercado hiperconectado, es decir donde los consumidores tienen a su alcance cualquier información de nuestro servicio o producto, pero, esta relación va un paso más allá que todo este contenido se difunde rápidamente gracias a las recomendaciones de los usuarios a sus demás contactos en el momento en que se encuentran comprando en nuestra tienda, o bien, mirando un producto desde una página Web, de modo que se está trabajando íntegramente como parte del marketing digital o Social Commerce.

En la actualidad:
Los smartphones (teléfonos inteligente) permiten a los usuarios consultar en Internet cualquier duda sobre lo que intentan buscar o lo que se les ha recomendado desde estos dispositivos móviles. Estos tipo de aplicaciones son denominados como SoLoMo, las que ofrecen al usuario la geolocalización GPS con la que podrán compartir dónde se encuentra y los negocios que frecuenta.

Foursquare:
Es uno de los sistemas más populares de servicio de localización web aplicado a las redes sociales.

Para finalizar este pequeño articulo, sugiero sacar provecho de esta revolución que esta dando mucho que hablar en la nueva era del comercio electrónico y del marketing digital, teniendo perfiles profesionales que como mínimo hacen uso de Facebook, Twitter y Linkedin aplicando SoLoMo.

Conclusión:
SoLoMo son usuarios que consumen contenido en el lugar en el que se encuentre, es decir, es saber la ubicación del usuario, qué está haciendo, con quienes lo comparte y cuál es su apreciación o comentario de lo que hace en ese momento.

sábado, 3 de noviembre de 2018

Usabilidad Web


El diseño no es sólo cómo se ve y cómo se siente; el diseño es cómo funciona, y para conocer como funciona debemos conocer su usabilidad de la web.

¿Qué es usabilidad web?
Viene del ingles que es Usability, muchos comenzaron a usar este termino en la tecnología pero recordemos que el término Usability en inglés significa facilidad de uso que tiene una interfaz, es decir un objeto.

Es decir es el grado de uso que tiene un objeto cuando el usuario interactúa. Entonces es como la cualidad que tiene una interfaz o un objeto. Considerando que el diseño no es usado por sí mismo, sino que son sus características en conjunto con el contexto del usuario las que van a determinar el grado de usabilidad.

¿Qué es un error en la usabilidad Web?
Cuando el usuario no puede cumplir con su objetivo, no importa el motivo del error si fue hecho al propósito o de manera casual, lo que importa es que hay un erro en ese momento y que el usuario tuvo una mala experiencia, es decir hay una mala facilidad de uso, y es evidentemente que hay un error de usabilidad por la mala experiencia  del usuario.

5 Componentes de Usabilidad:
  1. Facilidad de Uso: Que tan fácil es para el usuario poder realizar las primeras interacciones en el primer momento que se enfrenta con la interfaz, con el diseño qué tan fácil es entenderlo. Es decir es el primer contacto del usuario con el diseño.
  2. La eficiencia: Una vez que el usuario aya conocido el diseño, qué tan eficiente es el diseño para que el usuario pueda realizar las otras tareas o actividades en la web.
  3. Memorabilidad: Que tan intuitivo es el diseño, porque si el usuario pasa un tiempo sin interactuar con este diseño y luego vuelve a experimentarlo de manera rápida quiere decir que el aprendizaje fue rápido y que el diseño fue intuitivo.
  4. Los errores: Evaluar la cantidad de errores, la gravedad de los errores y si se puede recuperar. Recuperar en base a la necesidad del usuario y que pueda cumplir con sus objetivos ya sea por otro lado.
  5. La satisfacción: Es un componente muy importante cuando evaluamos usabilidad porque es lo que realmente nos va indicar si el usuario va a volver, es decir hay una satisfacción general con el usuario cuando interactúa con el diseño. Así mismo, esta la utilidad, es decir que la web sea útil ante la necesidad del usuario, e ahí la importancia de la necesidad de conocer las necesidades de nuestro usuarios.
¿Por qué es importante?
La importancia esta en que las personas interactúan, y regresan por mayor información y puedan hablar de nuestra web.

Si algo no es fácil de usar, la gente se va ir, no lo va a recordar, no hablará de ello, por lo tanto ese diseño no va tener éxito.

¿Cómo mejoramos la usabilidad?
Realizando test de usabilidad, para detectar los errores, la gravedad del error, lo mas importantes es que nos acercamos más a nuestro usuarios, conocerlos y saber más de sus objetivos y saber que la interacción que tiene con el diseño nos traerá satisfacción que podemos aprender muchísimo de todo esto.

¿Cuándo aplicar usabilidad?
La respuesta es siempre, desde el inicio hacia el final y nunca olvidarnos de que hay que iterar con nuestro diseño y probar todo el tiempo si lo que estamos agregando, lo que estamos haciendo satisface al usuario y si es de fácil uso o no.

No olvidarnos que es un proceso iterativo y que tenemos que ir siempre testeando nuestro diseño.

lunes, 1 de enero de 2018

Benchmarking

Definición de benchmarking:
Proceso mediante el cual se recopila información y se obtienen nuevas ideas, mediante la comparación de aspectos de tu empresa con los líderes o los competidores más fuertes del mercado, es decir es un punto de referencia sobre el cual las empresas comparan algunas de sus áreas.

Objetivos del benchmarking:
Nos encontramos en un mundo enormemente competitivo donde las empresas han de compararse con lo mejor que haya en el mercado para ganar ventaja en áreas fundamentales como en:

Nivel de calidad: Es el valor creado sobre un producto, teniendo en cuenta su precio y los costes necesarios para su fabricación y venta.
Productividad: Las empresas comparan cuánto producen y cuánto consumen para obtener esa cantidad con el objetivo de comparar eficiencia en los procesos.

Tipos de benchmarking:
Interno: Se suele dar en grandes empresas formadas por numerosos departamentos y/o divisiones, en las que es muy común compara los niveles alcanzados dentro de la misma organización.

Competitivo: Se utiliza cuando hay una competencia agresiva, comparando algunos aspectos con los competidores más directos o con los líderes del mercado sobre un cierto producto. Normalmente, es el tipo de benchmarking más complicado de llevar a cabo dada la limitada información que las empresas ofrecen sobre sus procesos.

Funcional: Consiste en compararse con empresas que no pertencen a tu misma industria; con este consigues la ventaja de obtener la información necesaria al no ser competidor de la empresa.

Etapas
Para diseñar y hacer correctamente un proceso de benchmarking en tu empresa, se recomienda seguir los siguientes pasos: planificación, recopilación de datos, análisis, acción y seguimiento.

Planificación:
El objetivo principal de esta primera etapa es planificar la investigación que se tiene que realizar.
En esta etapa hemos de responder a tres preguntas: -¿Qué quiero medir? Toda investigación tiene que tener un porqué, y éste debe estar relacionado con un área de nuestra empresa que queremos mejorar. -¿A quién voy a medir? Para responder a esta segunda pregunta hemos de plantearnos que tipo de benchmarking vamos a seguir: competitivo, interno o funcional. Una vez hayamos tomado la decisión sabremos si nos compararemos con un departamento propio o con una empresa de dentro o fuera del sector. -¿Cómo vamos hacerlo? Para llevar a cabo el proyecto hemos de crear un equipo de trabajo para que sea responsable de la organización y de la dirección del mismo.

Datos:
La recopilación de datos es fundamental para el benchmarking, de ello dependerá en gran medida el éxito o el fracaso de todo el proceso. Podemos obtener datos de diferentes fuentes: interna, asociaciones profesionales o investigaciones propias entre otras.
Análisis:
Una vez hemos recopilado la información necesaria, hemos de analizar los elementos que causan las diferencias entre nuestra compañía y las empresas estudiadas, para poder identificar las oportunidades de mejora. Una vez hemos identificado la magnitud de las diferencias, es el momento de proponer las mejoras que vamos a llevar a cabo. Hay que tener en cuenta que únicamente seleccionaremos aquellas mejoras que por tamaño, recursos e infraestructura sea viable llevar a cabo por nuestra empresa.

Acción:
El siguiente paso después de analizar la información y de haber seleccionado los aspectos de referencia en las empresas seleccionadas, es el momento de adaptarlos a nuestra empresa pero siempre implementando mejoras. Dicho de otro modo, después de analizar la información y de lograr identificar los mejores aspectos de las empresas que hemos seleccionado, los tomamos como puntos de referencia para adaptarlos a nuestra empresa pero siempre añadiéndole alguna mejora o alguna ventaja que le aporte valor a nuestros clientes.

Seguimiento y mejora:
En esta última etapa se debe hacer un informe con toda la información destacada del proceso. Esto ayudará a retomar el trabajo en proyectos posteriores. La idea es que se convierta en un ejercicio de la empresa sostenido en el tiempo para adoptar una mejora continua. 

Ejemplo:
Adaptar las mejores prácticas en atención y servicio al cliente.

Caso de Éxito
  • McDonalds
  • Starbucks
  • Xerox
En resumen
El benchamarking es una herramienta que consiste en tomar como referencia a las mejores alternativas y adaptar sus métodos, sus estrategias, dentro de la legalidad de nuestro proceso y mejorar nuestro producto.