Este documento discute diferentes técnicas para versionar APIs REST. Presenta varios enfoques como usar la versión en la URI, encabezados personalizados o tipo de contenido. También cubre implementaciones como versionar controladores por nombre o espacio de nombres. Finalmente, ofrece recomendaciones como priorizar la evolución sobre la revolución y usar versiones de forma coherente.
Una máquina de estado es un paradigma bien conocido para el desarrollo de programas, proporciona un estilo de modelado con el que puede modelar su flujo de trabajo de una manera impulsada por eventos. En esta charla te estaremos mostrando como implementar este paradigma en tus aplicaciones .NET, usando como ejemplo un app en Xamarin Forms.
React is a declarative, efficient, and flexible JavaScript library for building user interfaces. It uses virtual DOM which improves performance and can render on both client and server. React encourages a component-based approach where UI is broken into independent reusable pieces that accept external data through properties. Components manage their own state which allows the UI to update over time in response to user input. This makes React code more predictable and easier to debug than traditional two-way data binding.
Getting started with the reactjs, basics of reactjs, introduction of reactjs, core concepts of reactjs and comparison with the other libraries/frameworks
This document contains an agenda and slides for a React workshop presented by Bojan Golubovic. The workshop covers the history and basics of React, including components, JSX, the virtual DOM, and React data flow. It also discusses related tools like Redux and React Router. The goal is to provide basic knowledge of React and how to build real-world applications with it.
React js is a free and open-source front-end JavaScript library for building user interfaces based on UI components. It allows creating reusable UI components that can be nested to build complex applications. A React component may maintain internal state and re-render when data changes. React uses a declarative paradigm that makes code more predictable and easier to debug.
To use React, install Node packages and create a new project using create-react-app. Components let you break up the UI into reusable pieces responsible for rendering HTML. Components can be stateful class components or stateless function components. Components can be created using ES6 class syntax or function syntax and can be nested. Choosing between class and function depends on requirements like using
8 Reasons to Use React Query" is likely a presentation discussing the benefits of using the React Query library for managing and caching data in a React application. The slides may cover topics such as efficient data fetching, automatic caching and stale-while-revalidate, real-time updates, and easy-to-use hooks for handling queries and mutations. Additionally, the slides may also highlight how React Query helps improve the performance, developer experience, and user experience of the application.
React is a JavaScript library for building user interfaces. It is not a full framework and only handles the view layer. React uses a component-based approach where UI is broken into independent, reusable pieces. Components render HTML and have their own internal state. This makes components predictable and easier to debug. However, React alone is not enough to build full applications and must be used with other libraries for functionality like data fetching and routing. While React takes more time to learn initially, it can improve development speed and code quality for larger teams through its patterns and emphasis on component design.
Una máquina de estado es un paradigma bien conocido para el desarrollo de programas, proporciona un estilo de modelado con el que puede modelar su flujo de trabajo de una manera impulsada por eventos. En esta charla te estaremos mostrando como implementar este paradigma en tus aplicaciones .NET, usando como ejemplo un app en Xamarin Forms.
React is a declarative, efficient, and flexible JavaScript library for building user interfaces. It uses virtual DOM which improves performance and can render on both client and server. React encourages a component-based approach where UI is broken into independent reusable pieces that accept external data through properties. Components manage their own state which allows the UI to update over time in response to user input. This makes React code more predictable and easier to debug than traditional two-way data binding.
Getting started with the reactjs, basics of reactjs, introduction of reactjs, core concepts of reactjs and comparison with the other libraries/frameworks
This document contains an agenda and slides for a React workshop presented by Bojan Golubovic. The workshop covers the history and basics of React, including components, JSX, the virtual DOM, and React data flow. It also discusses related tools like Redux and React Router. The goal is to provide basic knowledge of React and how to build real-world applications with it.
React js is a free and open-source front-end JavaScript library for building user interfaces based on UI components. It allows creating reusable UI components that can be nested to build complex applications. A React component may maintain internal state and re-render when data changes. React uses a declarative paradigm that makes code more predictable and easier to debug.
To use React, install Node packages and create a new project using create-react-app. Components let you break up the UI into reusable pieces responsible for rendering HTML. Components can be stateful class components or stateless function components. Components can be created using ES6 class syntax or function syntax and can be nested. Choosing between class and function depends on requirements like using
8 Reasons to Use React Query" is likely a presentation discussing the benefits of using the React Query library for managing and caching data in a React application. The slides may cover topics such as efficient data fetching, automatic caching and stale-while-revalidate, real-time updates, and easy-to-use hooks for handling queries and mutations. Additionally, the slides may also highlight how React Query helps improve the performance, developer experience, and user experience of the application.
React is a JavaScript library for building user interfaces. It is not a full framework and only handles the view layer. React uses a component-based approach where UI is broken into independent, reusable pieces. Components render HTML and have their own internal state. This makes components predictable and easier to debug. However, React alone is not enough to build full applications and must be used with other libraries for functionality like data fetching and routing. While React takes more time to learn initially, it can improve development speed and code quality for larger teams through its patterns and emphasis on component design.
In this presentation, Prashant Sharma of Valuebound has talked about ReactJS - a JavaScript library for building user interfaces. Check out the agendas to know what is there for you.
----------------------------------------------------------
Get Socialistic
Our website: http://valuebound.com/
LinkedIn: http://bit.ly/2eKgdux
Facebook: https://www.facebook.com/valuebound/
Twitter: http://bit.ly/2gFPTi8
This document provides information about NetBeans IDE and GUI programming. It discusses the NetBeans interface including components like the menu bar, tool bar, GUI builder palette, inspector window, and code editor window. It also covers concepts like projects, forms, and components in NetBeans. Common controls like buttons, labels, text fields, checkboxes and their properties/methods are explained. Steps for designing an application like creating a project, adding a JFrame form and components are outlined. Examples for different controls like buttons, labels, text fields, radio buttons etc are also included.
Learn how to build RESTful API using Node JS with Express Js Framework. Database used is Mongo DB (Mongoose Library). Learn Step by step what is Node JS, Express, API and Mongo DB. Explain and sample code step to build RESTful API
Handle Exceptions in Selenium Webdriver | EdurekaEdureka!
** Selenium Certification Training: https://www.edureka.co/testing-with-selenium-webdriver **
This Edureka PPT on Exceptions in Selenium Webdriver will talk about exception handling in selenium. It will also tell you about various types of exceptions and how to handle them using various methods. Below topics are covered in this PPT:
What is Exception handling?
Exception Hierarchy
Checked vs Unchecked Exceptions
Types of Exceptions
Exception Methods
Selenium playlist: https://goo.gl/NmuzXE
Selenium Blog playlist: http://bit.ly/2B7C3QR
Follow us to never miss an update in the future.
YouTube: https://www.youtube.com/user/edurekaIN
Instagram: https://www.instagram.com/edureka_learning/
Facebook: https://www.facebook.com/edurekaIN/
Twitter: https://twitter.com/edurekain
LinkedIn: https://www.linkedin.com/company/edureka
This document provides an introduction and overview of ASP.NET and Web Forms. It discusses the background of ASP and how ASP.NET was developed to address challenges with ASP. The key features of ASP.NET, including Web Forms, Web Services, and the .NET Framework are described. The document then covers the ASP.NET programming model based on controls and events, and how postbacks maintain page state without requiring additional code. It also introduces the ASP.NET object model and server-side controls.
This document discusses Flutter, a Google-developed UI toolkit for building mobile apps using the Dart programming language. It highlights key features of Flutter like compiling to native code, not relying on OEM widgets, and providing a single codebase for both Android and iOS. It covers topics like Flutter's widgets, animations, productivity benefits, and IDE support. Examples of beautiful apps built with Flutter are showcased. The document concludes with recommendations on how to get started with Flutter, like using it for part of an existing app or prototyping a new idea.
The document discusses Flutter for web, a new capability that allows Flutter code to be compiled to run natively in a web browser. It explains that Flutter for web uses the same codebase as mobile Flutter apps and allows embedding Flutter content on web pages. However, it notes that some platform-specific features and plugins may not yet be supported for web. The author expresses excitement about Flutter for web's potential but also some uncertainty until it reaches a stable release.
The document discusses React's virtual DOM and how it allows for more efficient DOM updates compared to directly manipulating the real DOM. It explains that the virtual DOM is an in-memory representation of the real DOM that allows React to calculate efficient DOM changes before applying them to the real DOM. This avoids unnecessary re-renders and improves performance. It also describes how React uses a diff algorithm and DOM traversal with breadth-first search to determine the minimal number of operations needed to transform the virtual DOM before updating the real DOM in a batched way.
This document describes an online car rental portal that allows customers to view available cars, register profiles, and book cars. It has modules for users to book cars, view bookings, update profiles, and logout. The admin module allows admins to manage vehicle brands, vehicles, bookings, queries, users, and dashboard metrics. The system is built using PHP for the backend and uses a MySQL database. It provides advantages like being fully functional and flexible and streamlining administrative processes. Features include automation, a friendly interface, access control, easy updating and strong security.
This document presents information on the MERN stack and how it can be used to build a Twitter clone application. It defines each component of the MERN stack: MongoDB for the database, ExpressJS for the backend framework, ReactJS for the frontend framework, and NodeJS as the runtime environment. It explains that MongoDB is a flexible NoSQL database, ExpressJS simplifies backend coding in NodeJS, ReactJS allows building user interfaces with JavaScript, and NodeJS enables running JavaScript on the server. The document outlines the main benefits of using the MERN stack, such as having a single coding language across front- and backend and the ability to build dynamic web apps quickly. It concludes by describing how to start the server and client for
Frontend 'vs' Backend Getting the Right MixBob Paulin
Modern website architectures are typically composed of 2 parts: frontend and backend. Building out frontend and backend components requires diverse skill sets and often have competing interests when it comes to developer productivity and site performance. This talk will discuss some ways Java frameworks deal with these issues as well as benefits and tradeoffs. The talk will include combine demos with cutting edge frontend frameworks (Handlebarsjs, CoffeeScript, Less) and popular Java backends (Spring, Apache CXF).
Bio:
Bob Paulin is an independent consultant that has been developing on Java for the past 10 years. Bob is focuses on Business Enablement and Web Centric Applications. He’s presented in the past at CJUG on Apache Sling and is currently helping his clients perform modular development/design, automation for continuous delivery, and build forward leaning web applications. When not coding, Bob enjoys coaching football and spending time with his with his wife and 3 kids.
The document discusses the differences between frontend and backend development. Frontend development involves the design and visual elements that users interact with, such as graphics, text, and menus. Backend development involves the behind-the-scenes work to ensure the proper functioning of a website, including how data is processed and delivered to users. Frontend is client-side, while backend is server-side. Common frontend languages are HTML, CSS, and JavaScript, whereas backend languages include Java, Ruby, Python and PHP. While distinct, frontend and backend work together and rely on each other to create fully-functional websites.
Flutter vs React native 2019 - a detailed comparison for app owners and business to find out which framework is the best fit for your cross-platform app development project.
This document introduces React JS, a JavaScript library for building user interfaces. It discusses that React uses a virtual DOM for efficient updates, implements one-way reactive data flow, and uses composable components. Key aspects of React covered include JSX syntax, the component lifecycle, managing component state, and thinking in React by breaking down requirements into UI components.
This document provides an introduction to Node.js, including what it is, its advantages, and how its process model works. Node.js is an open-source JavaScript runtime environment that uses asynchronous programming and non-blocking I/O. It allows building highly scalable server-side applications using JavaScript. Unlike traditional web servers which use threads, Node.js runs in a single process with a single thread and handles I/O asynchronously so it can handle multiple requests concurrently without blocking. This increases performance and scalability compared to traditional threaded servers.
Hibernate is an object-relational mapping tool that allows developers to more easily write applications that interact with relational databases. It does this by allowing developers to map Java classes to database tables and columns, so that developers can interact with data through Java objects rather than directly with SQL statements. Hibernate handles the conversion between Java objects and database rows behind the scenes. Some key benefits of using Hibernate include faster data retrieval, avoiding manual database connection management, and easier handling of database schema changes.
The document discusses key features of ECMAScript 6 (ES6), including:
- Default parameters, template literals, multi-line strings, spread operator, and enhanced object literals which add concise syntaxes.
- Arrow functions which provide a shorter syntax for writing anonymous functions.
- Block-scoped constructs like let and const that add block scoping to variables and constants.
- Classes which provide a cleaner way to define constructor functions and objects.
- Hoisting differences between function declarations and class declarations.
- Using ES6 today by compiling it to ES5 using a tool like Babel.
Despliegue de aplicaciones en Azure Web AppsHernan Guzman
Presentación usada para conferencia sobre despliegue de aplicaciones en Azure Web Apps en el Politecnico Jaime Isaza Cadavid y la Universidad Autónoma Latinoamericana
In this presentation, Prashant Sharma of Valuebound has talked about ReactJS - a JavaScript library for building user interfaces. Check out the agendas to know what is there for you.
----------------------------------------------------------
Get Socialistic
Our website: http://valuebound.com/
LinkedIn: http://bit.ly/2eKgdux
Facebook: https://www.facebook.com/valuebound/
Twitter: http://bit.ly/2gFPTi8
This document provides information about NetBeans IDE and GUI programming. It discusses the NetBeans interface including components like the menu bar, tool bar, GUI builder palette, inspector window, and code editor window. It also covers concepts like projects, forms, and components in NetBeans. Common controls like buttons, labels, text fields, checkboxes and their properties/methods are explained. Steps for designing an application like creating a project, adding a JFrame form and components are outlined. Examples for different controls like buttons, labels, text fields, radio buttons etc are also included.
Learn how to build RESTful API using Node JS with Express Js Framework. Database used is Mongo DB (Mongoose Library). Learn Step by step what is Node JS, Express, API and Mongo DB. Explain and sample code step to build RESTful API
Handle Exceptions in Selenium Webdriver | EdurekaEdureka!
** Selenium Certification Training: https://www.edureka.co/testing-with-selenium-webdriver **
This Edureka PPT on Exceptions in Selenium Webdriver will talk about exception handling in selenium. It will also tell you about various types of exceptions and how to handle them using various methods. Below topics are covered in this PPT:
What is Exception handling?
Exception Hierarchy
Checked vs Unchecked Exceptions
Types of Exceptions
Exception Methods
Selenium playlist: https://goo.gl/NmuzXE
Selenium Blog playlist: http://bit.ly/2B7C3QR
Follow us to never miss an update in the future.
YouTube: https://www.youtube.com/user/edurekaIN
Instagram: https://www.instagram.com/edureka_learning/
Facebook: https://www.facebook.com/edurekaIN/
Twitter: https://twitter.com/edurekain
LinkedIn: https://www.linkedin.com/company/edureka
This document provides an introduction and overview of ASP.NET and Web Forms. It discusses the background of ASP and how ASP.NET was developed to address challenges with ASP. The key features of ASP.NET, including Web Forms, Web Services, and the .NET Framework are described. The document then covers the ASP.NET programming model based on controls and events, and how postbacks maintain page state without requiring additional code. It also introduces the ASP.NET object model and server-side controls.
This document discusses Flutter, a Google-developed UI toolkit for building mobile apps using the Dart programming language. It highlights key features of Flutter like compiling to native code, not relying on OEM widgets, and providing a single codebase for both Android and iOS. It covers topics like Flutter's widgets, animations, productivity benefits, and IDE support. Examples of beautiful apps built with Flutter are showcased. The document concludes with recommendations on how to get started with Flutter, like using it for part of an existing app or prototyping a new idea.
The document discusses Flutter for web, a new capability that allows Flutter code to be compiled to run natively in a web browser. It explains that Flutter for web uses the same codebase as mobile Flutter apps and allows embedding Flutter content on web pages. However, it notes that some platform-specific features and plugins may not yet be supported for web. The author expresses excitement about Flutter for web's potential but also some uncertainty until it reaches a stable release.
The document discusses React's virtual DOM and how it allows for more efficient DOM updates compared to directly manipulating the real DOM. It explains that the virtual DOM is an in-memory representation of the real DOM that allows React to calculate efficient DOM changes before applying them to the real DOM. This avoids unnecessary re-renders and improves performance. It also describes how React uses a diff algorithm and DOM traversal with breadth-first search to determine the minimal number of operations needed to transform the virtual DOM before updating the real DOM in a batched way.
This document describes an online car rental portal that allows customers to view available cars, register profiles, and book cars. It has modules for users to book cars, view bookings, update profiles, and logout. The admin module allows admins to manage vehicle brands, vehicles, bookings, queries, users, and dashboard metrics. The system is built using PHP for the backend and uses a MySQL database. It provides advantages like being fully functional and flexible and streamlining administrative processes. Features include automation, a friendly interface, access control, easy updating and strong security.
This document presents information on the MERN stack and how it can be used to build a Twitter clone application. It defines each component of the MERN stack: MongoDB for the database, ExpressJS for the backend framework, ReactJS for the frontend framework, and NodeJS as the runtime environment. It explains that MongoDB is a flexible NoSQL database, ExpressJS simplifies backend coding in NodeJS, ReactJS allows building user interfaces with JavaScript, and NodeJS enables running JavaScript on the server. The document outlines the main benefits of using the MERN stack, such as having a single coding language across front- and backend and the ability to build dynamic web apps quickly. It concludes by describing how to start the server and client for
Frontend 'vs' Backend Getting the Right MixBob Paulin
Modern website architectures are typically composed of 2 parts: frontend and backend. Building out frontend and backend components requires diverse skill sets and often have competing interests when it comes to developer productivity and site performance. This talk will discuss some ways Java frameworks deal with these issues as well as benefits and tradeoffs. The talk will include combine demos with cutting edge frontend frameworks (Handlebarsjs, CoffeeScript, Less) and popular Java backends (Spring, Apache CXF).
Bio:
Bob Paulin is an independent consultant that has been developing on Java for the past 10 years. Bob is focuses on Business Enablement and Web Centric Applications. He’s presented in the past at CJUG on Apache Sling and is currently helping his clients perform modular development/design, automation for continuous delivery, and build forward leaning web applications. When not coding, Bob enjoys coaching football and spending time with his with his wife and 3 kids.
The document discusses the differences between frontend and backend development. Frontend development involves the design and visual elements that users interact with, such as graphics, text, and menus. Backend development involves the behind-the-scenes work to ensure the proper functioning of a website, including how data is processed and delivered to users. Frontend is client-side, while backend is server-side. Common frontend languages are HTML, CSS, and JavaScript, whereas backend languages include Java, Ruby, Python and PHP. While distinct, frontend and backend work together and rely on each other to create fully-functional websites.
Flutter vs React native 2019 - a detailed comparison for app owners and business to find out which framework is the best fit for your cross-platform app development project.
This document introduces React JS, a JavaScript library for building user interfaces. It discusses that React uses a virtual DOM for efficient updates, implements one-way reactive data flow, and uses composable components. Key aspects of React covered include JSX syntax, the component lifecycle, managing component state, and thinking in React by breaking down requirements into UI components.
This document provides an introduction to Node.js, including what it is, its advantages, and how its process model works. Node.js is an open-source JavaScript runtime environment that uses asynchronous programming and non-blocking I/O. It allows building highly scalable server-side applications using JavaScript. Unlike traditional web servers which use threads, Node.js runs in a single process with a single thread and handles I/O asynchronously so it can handle multiple requests concurrently without blocking. This increases performance and scalability compared to traditional threaded servers.
Hibernate is an object-relational mapping tool that allows developers to more easily write applications that interact with relational databases. It does this by allowing developers to map Java classes to database tables and columns, so that developers can interact with data through Java objects rather than directly with SQL statements. Hibernate handles the conversion between Java objects and database rows behind the scenes. Some key benefits of using Hibernate include faster data retrieval, avoiding manual database connection management, and easier handling of database schema changes.
The document discusses key features of ECMAScript 6 (ES6), including:
- Default parameters, template literals, multi-line strings, spread operator, and enhanced object literals which add concise syntaxes.
- Arrow functions which provide a shorter syntax for writing anonymous functions.
- Block-scoped constructs like let and const that add block scoping to variables and constants.
- Classes which provide a cleaner way to define constructor functions and objects.
- Hoisting differences between function declarations and class declarations.
- Using ES6 today by compiling it to ES5 using a tool like Babel.
Despliegue de aplicaciones en Azure Web AppsHernan Guzman
Presentación usada para conferencia sobre despliegue de aplicaciones en Azure Web Apps en el Politecnico Jaime Isaza Cadavid y la Universidad Autónoma Latinoamericana
El documento presenta una introducción teórica al desarrollo de APIs utilizando la arquitectura REST. Explica conceptos clave como recursos, identificadores, representaciones, operadores y códigos de respuesta HTTP. También recomienda estructurar el API siguiendo patrones MVC, realizar pruebas unitarias, utilizar caché y autenticación, y considerar frameworks existentes.
Construye un backend para tus app móviles con con ASP.NET Web ApiHernan Guzman
Este documento describe cómo construir un backend para aplicaciones con ASP.NET Web API. Explica brevemente qué es Web API y por qué usarlo, y cómo permite acceder a más clientes de forma escalable incluso en la nube. También cubre cómo publicar un servicio Web API de forma tradicional o en la nube, y demuestra su uso en un smartphone.
Este documento presenta una introducción a una API RESTful creada con Node.js. Explica brevemente Node.js y las APIs RESTful, y luego muestra la estructura y código de un servidor de ejemplo que expone una API para gestionar charlas. El código incluye modelos, rutas y servicios para operaciones CRUD sobre recursos de charla, implementando así una API RESTful completa para la gestión de charlas.
Picasso es una librería para cargar imágenes de forma eficiente en aplicaciones Android. Asynchronous HTTP Client permite realizar peticiones HTTP de forma asíncrona para obtener datos de APIs. Otto es un bus de eventos que permite desacoplar los componentes de una aplicación que se comunican mediante la publicación y suscripción de mensajes.
Diapositivas correspondientes a la parte sobre la plataforma de desarrollo Google App Engine del curso de extensión universitaria "Cloud Computing. Desarrollo de Aplicaciones y Minería Web", celebrado en la Escuela Universitaria de Ingeniería Informática de Oviedo
Este documento describe los servicios web y su implementación en diferentes lenguajes de programación como PHP, Perl, Java y las APIs de Google. Explica cómo crear un servidor y cliente XML-RPC en PHP, un servicio web simple "Hola Mundo" en Perl, cómo definir y consumir un servicio web de validación de tarjetas de crédito en Java, y lista las diferentes APIs que Google ofrece para desarrolladores.
Tutoriales - Explorando AWS con Java.
Aprende a descubrir los diferentes servicios que ofrece AWS para explotar por medio de Java a través de la capa gratuita.
Este documento presenta un curso de desarrollo web que enseña sobre tecnologías modernas como HTML5, CSS3, JavaScript, APIs REST, DOM, BOM, jQuery y AJAX. Explica conceptos como el modelo de objetos del documento y navegador, peticiones asincrónicas, almacenamiento local y geolocalización.
Este documento describe las tecnologías para implementar microservicios, incluyendo Node.js, Express, Go y .NET Core. Explica conceptos como APIs agnósticas de lenguaje, REST, HATEOAS y persitencia en bases de datos NoSQL y SQL. También cubre temas como escalabilidad, registro, monitoreo, configuración, despliegue en Heroku, Bluemix, Docker y Docker Compose. Finalmente, discute ventajas y desventajas del stack MEAN para microservicios.
Este documento presenta las principales características de Spring 3.0. Spring 3.0 incluye mejoras como una nueva implementación del lenguaje de expresiones de Spring, soporte para configuración basada en Java, extensiones para soportar REST y negociación de contenido, y abstracciones para mapeo de objetos a XML. Spring 3.0 también actualiza la API para aprovechar las características de Java 5 como generics.
Este documento proporciona información sobre cómo conectar aplicaciones Android a servicios de Internet utilizando REST. Explica conceptos clave como REST, librerías como Retrofit para realizar llamadas HTTP, y el proceso de diseñar una aplicación que se conecta a una API. También incluye ejemplos de código para ilustrar el uso de Retrofit para realizar solicitudes a un servicio RESTful y manejar respuestas.
ASP.NET es un framework para desarrollar aplicaciones web que permite separar la interfaz de usuario de la lógica del sitio y procesar datos en el servidor. Los Web Forms son la parte principal de ASP.NET y permiten crear páginas dinámicas que se compilan y ejecutan en el servidor generando HTML para el cliente. ASP.NET incluye controles que encapsulan funcionalidad común y facilitan el desarrollo de aplicaciones web ricas e interactivas.
1. El documento discute posibles soluciones para implementar un chat por HTTP como Iframe scripting y propone que AJAX es una solución elegante. 2. Explica el esquema de funcionamiento de AJAX donde el navegador realiza peticiones asíncronas al servidor y actualiza el DOM sin recargar la página. 3. Revisa herramientas para desarrollo AJAX como Firebug que permiten debuggear aplicaciones AJAX.
Este documento introduce las aplicaciones web y la tecnología Java. Explica que Java es un lenguaje orientado a objetos creado por Sun Microsystems que ha tenido éxito gracias a Internet y su independencia de plataforma. También describe las características clave de Java como la herencia, polimorfismo y encapsulación. Luego, introduce conceptos como servlets, JSP y servidores de aplicaciones, los cuales permiten crear aplicaciones web dinámicas utilizando Java. Finalmente, provee un ejemplo básico de cómo funcionan los servlets y
El documento describe la historia del desarrollo web desde HTML estático hasta ASP.NET dinámico. Explica conceptos como HTTP, servidores web, aplicaciones web y cómo interactúan los navegadores y servidores a través de peticiones y respuestas HTTP. También define elementos clave como HTML forms y las páginas ASP.NET que generan dinámicamente código HTML en el servidor.
App todo gas: WordPress no es solo para webPaco Marchante
El documento explica qué es una API y una API-REST. Una API permite la comunicación entre componentes de software a través de funciones y procedimientos. Una API-REST usa solicitudes HTTP para recuperar, actualizar y eliminar recursos de forma similar a cómo funcionan las páginas web. El documento también describe cómo crear endpoints personalizados en WordPress usando la API-REST para acceder a datos de forma programática.
Este documento presenta una guía para la práctica 3 sobre Common Gateway Interface (CGI) y ASP.NET. Explica los conceptos básicos de CGI como métodos HTTP, implementación en C# y configuración en Apache. Luego introduce ASP.NET, describiendo sus principales componentes como WebForms, WebServices y la estructura básica de una aplicación web ASP.NET incluyendo páginas ASPX, controles del servidor web y técnicas como objetos persistentes y cookies. Finalmente incluye algunas referencias sobre estos temas.
1) El documento introduce Google Web Toolkit (GWT), una tecnología para acelerar el desarrollo de aplicaciones web ricas mediante el uso de Java. 2) GWT compila el código Java en código JavaScript optimizado para su ejecución en los principales navegadores. 3) El documento explica conceptos como la arquitectura de GWT, la construcción de interfaces gráficas, la comunicación con servidores y otras características.
Este documento describe diferentes tecnologías y APIs para desarrollar servicios web utilizando Java, PHP, Perl y Google. Explica cómo crear servicios web con JAX-WS, JAX-RPC y JAXB en Java, así como utilizando XML-RPC y SOAP en PHP. También cubre el uso de SOAP::Lite para crear servicios web en Perl y lista numerosas APIs de Google como Google Maps, Google Docs y Google Calendar.
Este documento presenta una introducción a la programación avanzada para desarrollo web. Explica conceptos clave como servidores web, contenedores web, servlets, JSP y aplicaciones web con Java. También incluye una guía rápida de HTML y una descripción de la estructura y configuración típica de aplicaciones web con Java.
Este documento discute temas avanzados de GWT como pruebas de cliente, depuración, JSNI, enlace diferido, AJAX y RPC. Explica cómo ejecutar pruebas de cliente en diferentes modos como JUnit, Selenium y RemoteWeb. También cubre cómo depurar aplicaciones GWT de forma similar a otras aplicaciones Java y la recomendación de hacer TDD en lugar de depurar. Luego describe características clave de GWT como JSNI para usar JavaScript dentro de Java, enlace diferido para seleccionar implementaciones basadas en el navegador y AJ
Appcircus Academy: Integración de Social Media en AndroidAlberto Ruibal
Este documento describe cómo integrar redes sociales como Twitter, LinkedIn, Google+ y Facebook en aplicaciones Android. Explica los pasos para obtener claves de API, autenticar usuarios, realizar llamadas a las API y mostrar datos de las redes sociales como actualizaciones y perfiles de usuario. También cubre temas como mejorar anuncios con datos de usuarios y usar redes sociales para inicios de sesión y compartir contenido.
Workshop sobre APIs realizado el 27 de abril en el Centro de Innovación de BBVA. En este evento hemos visto los detalles del funcionamiento, gestión de errores y conceptos de seguridad aplicados a APIs.
Similar a REST Versioning Architecture with ASP.NET MVC Web API v1.2 (20)
38. En general, se considera que la combinación de
descubrimiento de recursos en tiempo de ejecución,
mensajes auto-descriptivos y clientes reactivos son críticos
para conseguir un Web API evolucionable.
También se considera que, aunque son conceptos difíciles
de entender e implementar, la flexibilidad y escalabilidad
que aportan supera con creces su costo.
39. En general, en la filosofía REST, versionar recursos se
considera una mala práctica o evidencia de un pobre
diseño.
40.
41. TIPO DESCRIPCIÓN
Payload La versión es parte del mensaje.
Query String
La versión es un parámetro que forma parte de la URI
del recurso.
URL Suffix
La versión es parte del URI, y se anexa al final del
mismo.
Custom Header
La versión es suministrada en una cabecera propia no
estándar.
URL La versión es parte indirecta del URI del recurso.
Media Type
Content Type
La versión es suministrada como el media type
esperado de la representación del recurso.
TIPO DESCRIPCIÓN
Payload La versión es parte del mensaje.
Query String
La versión es un parámetro que forma parte de la URI
del recurso.
URL Suffix
La versión es parte del URI, y se anexa al final del
mismo.
54. Version del Controlador por Nombre
public class DummyController : ApiController
{
...
}
public class DummyV2Controller : ApiController
{
...
}
public class V2DummyController : ApiController
{
...
}
public class DummyControllerV2 : ApiController
{
...
}
public class DummyControllerV2 : ApiController
{
// Este controlador no es válido, porque no cumple con la convención de ASP.NET MVC y
// ASP.NET Web API sobre nombres para controladores.
...
}
55. Versión de Controlador por Espacio de Nombres
namespace My.Cool.Api.V1
{
public class DummyController : ApiController
{
...
}
}
namespace My.Cool.Api.V2
{
public class DummyController : ApiController
{
...
}
}
56.
57.
58. Código para los Ejemplos
public class Console
{
public int Id { get; set; }
public string Name { get; set; }
}
public class NexGenConsole : Console
{
public bool IsNexGen { get; set; }
}
59. Código para los Ejemplos
public class ConsoleController : ApiController
{
public virtual IEnumerable<Console> GetConsoles
{
get { return ... }
}
public virtual Console GetConsole(int id)
{
return new Console { Id = id, Name = @"PS3" };
}
}
public class ConsoleV2Controller : ConsoleController
{
public override Console GetConsole(int id)
{
return new NexGenConsole { Id = id, Name = @"PS4", IsNexGen = true };
}
}
60. Código para los Ejemplos
internal static class VersionFinder
{
public static int GetVersionFromRequestData(HttpRequestMessage request) {...}
private static bool NeedsUriVersioning(HttpRequestMessage request, out string version)
{ ... }
private static bool NeedsHeaderVersioning(HttpRequestMessage request, out string version)
{ ... }
private static bool NeedsAcceptVersioning(HttpRequestMessage request, out string version)
{ ... }
private static int VersionToInt(string versionString) { ... }
}
70. Versionado a través de Enrutamiento por Convención
public static class WebApiConfig
{
public static void Register(HttpConfiguration config, IDependencyResolver dependencyResolver)
{
if (config != null)
{
...
config.Services.Replace(typeof(IHttpControllerSelector),
new VersionAwareControllerSelector(config));
...
}
}
}
71. Versionado a través de Enrutamiento por Convención
public static class WebApiConfig
{
public static void Register(HttpConfiguration config, IDependencyResolver dependencyResolver)
{
if (config != null)
{
...
config.Routes.MapHttpRoute(name: @"VersionedApi",
routeTemplate: @"api/v{version}/{controller}/{id}",
defaults: new { id = RouteParameter.Optional },
constraints: new { version = @"[1-9]+[d]*" });
config.Routes.MapHttpRoute(name: @"DefaultApi",
routeTemplate: @"api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
...
}
}
}
74. Versionado a través de Enrutamiento por Atributos
Uno de los primeros pasos es decorar los controladores
con los atributos de enrutamiento apropiados.
[RoutePrefix(@"api/v1")]
public class ConsoleAttributeController : ApiController
{
[Route(@"consoles")]
public virtual IEnumerable<Console> Console RetrieveConsoles()
{
return ...
}
[Route(@"consoles/{id:int}")]
public virtual Console RetrieveConsole(int id)
{
return new Console { Id = id, Name = @"PS3" };
}
}
75. Versionado a través de Enrutamiento por Atributos
[RoutePrefix(@"api/v2")]
public class ConsoleAttributeV2Controller : ConsoleAttributeController
{
[Route(@"consoles/{id:int}")]
public override Console RetrieveConsole(int id)
{
return new NexGenConsole { Id = id, Name = @"PS4", IsNexGen = true };
}
}
Y ya sólo con esto, se tendría versionado mediante URL,
ya que la declaración de la ruta directamente en el
controlador o la acción, es la naturaleza misma del
enrutamiento por atributo.
77. Versionado a través de Enrutamiento por Atributos
Soportar las modalidades de custom header y custom
media type, simplemente requiere identificar el origen
del dato correspondiente a la versión.
78. Versionado a través de Enrutamiento por Atributos
Sin embargo, es necesario informar a los atributos de
enrutamiento de la existencia de una restricción por
versión, para lo cual:
79. Versionado a través de Enrutamiento por Atributos
internal class VersionConstraint : IHttpRouteConstraint
{
private readonly int allowedVersion;
public VersionConstraint(int version)
{
this.allowedVersion = version;
}
public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName,
IDictionary<string, object> values, HttpRouteDirection routeDirection)
{
return request == null ?
false :
this.allowedVersion == VersionFinder.GetVersionFromRequestData(request);
}
}
80. Versionado a través de Enrutamiento por Atributos
internal class VersionedRouteAttribute : RouteFactoryAttribute
{
public VersionedRouteAttribute(string template)
: base(template)
{
this.Order = -1;
}
public int Version { get; set; }
public override IDictionary<string, object> Constraints
{
get
{
return new HttpRouteValueDictionary
{
{ string.Empty, new VersionConstraint(this.Version) }
};
}
}
}
81. Versionado a través de Enrutamiento por Atributos
Finalmente, decoramos los controladores con el nuevo
atributo VersionedRouteAttribute.
[RoutePrefix(@"api")]
public class ConsoleAttributeController : ApiController
{
[HttpGet, Route(@“v1/consoles")]
[VersionedRoute(@"consoles", Version = 1)]
public virtual IEnumerable<Console> Console Get()
{
return ...
}
[HttpGet, Route(@“v1/consoles/{id:int}")]
[VersionedRoute(@“consoles/{id:int}", Version = 1)]
public virtual Console Get(int id)
{
return new Console { Id = id, Name = @"PS3" };
}
}
82. Versionado a través de Enrutamiento por Atributos
[RoutePrefix(@"api")]
public class ConsoleAttributeV2Controller : ConsoleAttributeController
{
[HttpGet, Route(@"v2/consoles")]
[VersionedRoute(@"consoles", Version = 2)]
public override IEnumerable<Console> RetrieveConsoles()
{
return base.RetrieveConsoles();
}
[HttpGet, Route(@"v2/consoles/{id:int}")]
[VersionedRoute(@"consoles/{id:int}", Version = 2)]
public override Console Get(int id)
{
return new NexGenConsole { Id = id, Name = @"PS4", IsNexGen = true };
}
}
Y ahora se cuenta con versionado por URL, plus
versionado por custom header y custom media type.
85. Encontraremos diferentes
posiciones filosóficas sobre la
“manera correcta” de alcanzar
REST, sobre qué es RESTful, y
qué no lo es.
Desafortunadamente, lo
filosófico pasa a lo religioso y
se pierde el foco sobre cuál
debería ser el objetivo real:
construir software que
funcione y un API coherente
que permita consumirle e
integrarle fácilmente.
¿Quién sabe qué es esto?Les presento a INTERNET, tal y como existía en su primera versión en 1977 cuando se llamaba ARPANET.
En 1989, Tim Berners-Lee, un científico del CERN, inventó la World Wide Web, un sistema de acceso a los documentos vinculados a través de Internet. El acceso a estos documentos requería un protocolo para acceder (o navegar) hacia y entre ellos.
Dicho protocolo se conoce hoy día como el protocolo de transferencia de hipertexto (HTTP). Este protocolo es en el centro de lo que impulsa sitios web y APIs Web.
Este es Internet hoy día…En un principio podemos pensar que es una colección de sitios web, de páginas que podemos visitar, donde ver información útil, donde tenemos acceso a una ventana a la vida – que nos quieran mostrar – los demás.
Es mucho más que eso…
Todos esos sitios, en su mayoría, nos ofrecen un API para interactuar con ellos. Expanden los límites de su funcionalidad y de lo que ofrecen a través de un API que nos permite explotar aún más sus capacidades.
La actual tendencia, en temas de API en Internet, son las Web API, también conocidas como API REST.
Piensen en cualquiera de sus sitios web favoritos: Facebook, 9GAG, Twitter… todos exponen alguna forma de API, y actualmente todos son REST.
¿Saben de qué es la foto? Es de la misión Apollo 13, donde los ingenieros trataban de encontrar la manera de encajar un filtro de aire (CO2) de forma cúbica en un agujero de forma cilíndrica.
El cambio es inevitable. Los cambios en una Web API son inevitables a medida que el conocimiento y la experiencia que se adquiere sobre un sistema y el negocio al que atienden mejora y se incrementa.
Gestionar el impacto de estos cambios ciertamente puede ser un reto, sobre todo cuando aparece la amenaza de romper la integración que se tenga con los clientes del Web API.
Estas son las preguntas alrededor de las cuales realizar el diseño de la Web API.
A primera vista se podría pensar a un enfoque en cascada, pero no es en absoluto el caso. No se trata de diseñar todo el API antes de su construcción; no es una receta
para la parálisis por análisis.
Definitivamente, hay decisiones que debe tomar por adelantado, pero que son de alto nivel y se relacionan con el diseño del API general. No requieren entender
o predecir todos los aspectos del sistema. Más bien, estas decisiones han de sentar las bases para que el API tenga la capacidad de evolucionar de forma iterativa y orgánica.
De una petición a la siguiente, el estado de los recursos puede cambiar drásticamente, por lo que la representación que se devuelve puede ser muy diferente.
Ejemplos de media types son:
text/html
text/xml
image/png
application/json
Los media types son identificados con dos componentes: la primera corresponde al nivel superior que describe de forma genérica el tipo de información; y la segunda denominada subtipo y que describe el formato concreto y su estructura de datos esperada.
Si bien el término REST se refiere originalmente a un conjunto de principios de arquitectura, hoy día se usa en un sentido más amplio para describir cualquier interfaz entre sistemas que utilice directamente el protocolo y los verbos HTTP para obtener datos o indicar la ejecución de operaciones sobre los datos, en cualquier formato (XML, JSON, etc) sin las abstracciones adicionales de los protocolos basados en patrones de intercambio de mensajes, como por ejemplo SOAP.
A servicios web públicamente disponibles en Internet se les suele denominar como servicios RESTful.
En esencia, hablar de Servicios REST o de Interfaces RESTful es hablar de lo mismo.
En el mundo .NET solemos llamar a los servicios REST como Web APIs.
En Web APIs se emplea permalinks para apuntar a la versión más reciente.
Por ejemplo, hace unos años la representación estándar era XML, hoy es JSON, mañana puede ser otra cosa totalmente diferente…
Esto en principio no es nada descabellado, ya que es justamente como funcionan los navegadores web.
Desde la perspectiva de desarrollo de sistemas capaces de evolucionar, es útil tener considerar el versionado como el último recurso, cómo una admisión de fracaso.
Asignar un “V1” al API inicial es proclamar (casi a gritos) que ya sabe que el API no puede evolucionar, y que surgirán cambios rompedores cuando se publique la versión “V2”.
Sin embargo, todos somos humanos, y como tal nos equivocamos. En este caso, el emitir versiones es lo que hacemos cuando hemos agotado todas las demás opciones.
URL Es el mecanismo más directo y más popular. No obstante es uno de los que más molesta a los puristas de REST, ya que insisten (y tienen razón) que un URI debe referir a un recurso único y distinguido.
Custom Header y Media Content Un custom header permite preservar las URIs entre versiones, a pesar de ser efectivamente una duplicidad del comportamiento ya implementado y existente en HTTP de negociación del contenido (content negotiation). Lo anterior se evita justamente empleando la cabecera Accept de HTTP, con lo cual se evita la mencionada duplicidad.
Sin embargo, en ambos casos, se fuerza a los clientes a conocer de ante mano que cabeceras deben enviar en una solicitud para especificar la correcta versión del recurso que desean acceder.
Y Ciertamente, en ambos cosas, se permite preservar un conjunto limpio y claro de URLs hacia los recursos, pero agrega la necesidad de lidiar con la complejidad de servir diferentes versiones de contenido en algún punto del código del Web API. A veces, y dependiendo de la tecnología, esta complejidad termina llegando a la implementación del controlador, que se más allá de sólo encargarse del procesamiento y atención del recurso, termina también siendo responsable de determinar que versión del mismo (y su representación) enviar al llamador.
Así, cambios en el código de un ensamblado (por ejemplo por corrección de errores o bugs) implicará un cambio de versión del mismo…
…Pero no necesariamente implica un cambio en el API que contiene, ya que no hay cambios en la interfaz pública.
Cambios en los recursos, sus representaciones o sus puntos de acceso si implicará un cambio del API, y también de su correspondiente ensamblado.
Planos del proyecto cancelado para la autovía de la Bahía de Seattle.
Coherente es la palabra clave a lo largo de esta parte de la presentación…
El modelo de datos debe estar estabilizado antes de comenzar a diseñar el Web API. Esto ayudará a minimizar la generación espontanea y acelerada de versiones por imponderables o cosas “que no se pensaron o tuvieron en cuenta”.
Si los consumidores invierten tiempo (y por ende dinero y esfuerzo) en escribir código que permita emplear nuestro Web API, entonces nosotros debemos hacer el máximo esfuerzo por no romper esa integración.
Siempre manteniendo la línea de la coherencia. Ejemplo: combinar URL con custom media type.
En la medida de lo posible evitar “1.1”, “2.2.3”.
El software puede evolucionar en otras versiones debido a correcciones de errores o bugs, o mejoras de rendimiento, o cambios en sus tecnologías inherentes (como frameworks o bases de datos). Pero el Web API como tal, sus recursos y representaciones no han cambiado, por lo cual no requieren versionarse de nuevo.
En los principios SOLID, el principio “Open\Closed” de Bertrand Meyer sugiere que las entidades y componentes de un software deben ser abiertas (open) para su extensión, y cerradas (closed) para su modificación. Esto llevado al contexto de los Web APIs tiene la implicación de que un recurso no debe cambiar arbitrariamente su firma, sino más bien extenderse (son sobrecargas por ejemplo) para soportar nuevos parámetros o restricciones.
Por ejemplo, Facebook garantiza que cada versión de su Web API durará al menos dos años, y será removida pasados dos años tras la emisión de una versión más nueva. Por ejemplo, si la versión v2.3 es liberada el 25 de marzo, 2015, y la versión de v2.4 se libera el 7 de Agosto de 2015, entonces la versión v2.3 dejará de estar disponible el 7 de Agosto de 2017, exactamente dos años después de la emisión de la versión v2.4.Este tipo de políticas deben estar correctamente documentadas y públicas.
Por ejemplo, si empleamos versionado por URL, cuando un consumidor accede a un recurso viejo, se podría contestar con códigos HTTP 301 o 302 según convenga, para informar del cambio de localización del recurso debido a una nueva versión del mismo. Así:
301 Moved Permanently para indicar que el recurso en el URI de la solicitud se ha movido permanentemente a otro URI, el cual debería ser un permalink sin información de versión a la instancia de la nueva versión del recurso). Este código de estado puede emplearse para indicar una versión del Web API obsoleta o no soportada, informando al consumidor del reemplazo por la nueva versión.
302 Found para indicar que el recurso solicitado está temporalmente localizado en otro sitio, y que por lo tanto el URI sigue siendo soportado. Este código de estado puede ser útil cuando URIs sin información de versión (permalinks) no estén disponibles y se desee informar a los consumidores que aún así la URI es correcta, que serán re-direccionados temporalmente a una URI con información de versión, pero que deberían seguir empleando la URI original.