Content Delivery Policies in Replicated Web Services: Client-Side vs. Server-Side

2005 ◽  
Vol 8 (1) ◽  
pp. 47-60 ◽  
Author(s):  
Marco Conti ◽  
Enrico Gregori ◽  
Willy Lapenna
Keyword(s):  
Web Services ◽  
Content Delivery ◽  
Server Side ◽  
Client Side

scholarly journals Interoperabilitas perangkat lunak menggunakan RESTful web service

2018 ◽  
Vol 4 (1) ◽  
pp. 14
Author(s):  
M. Miftakul Amin
Keyword(s):  
Web Services ◽  
Web Service ◽  
Programming Languages ◽  
Visual Basic ◽  
Heterogeneous Environments ◽  
Server Side ◽  
Systems Software ◽  
Restful Web Service ◽  
Restful Web Services ◽  
Client Side

Pengembangan sistem informasi membutuhkan interoperabilitas dalam lingkungan yang heterogen, dilihat dari sistem operasi, perangkat lunak, bahasa pemrograman, dan basis data, sehingga dapat saling berkomunikasi dan bertukar data atau informasi. RESTful web service dapat digunakan sebagai salah satu teknologi untuk mewujudkan interoperabilitas. Sebuah studi kasus tentang aplikasi perpustakaan telah digunakan dalam penelitian ini. Aplikasi tersebut dibangun dengan Slim Framework PHP untuk sisi server dan Visual Basic pada sisi client. Komunikasi antara client dan server menggunakan HTTP method yaitu GET, POST, PUT, dan DELETE. Pengujian telah dilakukan untuk melihat performa dari web service yang telah dikembangkan menggunakan perangkat lunak Postman. Hasil dari penelitian ini menunjukkan bahwa, aplikasi client dapat mengakses web service yang disediakan di sisi server sebagai wujud interoperabilitas.   Information development systems need interoperability in heterogeneous environments, seen from operating systems, software, programming languages, and databases, so that they can communicate and exchange data or information. RESTful web services can be used as one of the technologies to realize interoperability. As case studies build library applications using PHP Slim Framework on the server side, while Visual Basic programming language is used on the client side. Communication Between client and server using HTTP Method that is GET, POST, PUT, and DELETE. Testing has been done to see the performance of web service functionality that has been developed using Postman software. The result shows that client applications can access the web services provided on the server side as a form of interoperability.

scholarly journals A Javascript GIS Platform Based on Invocable Geospatial Web Services

2018 ◽  
Author(s):  
Konstantinos Evangelidis ◽  
Theofilos Papadopoulos
Keyword(s):  
Web Services ◽  
Location Based Services ◽  
Web Gis ◽  
Smart Devices ◽  
Semantic Web Technologies ◽  
Web Browser ◽  
Server Side ◽  
Client Side ◽  
Geospatial Web Services ◽  
Gis Platform

Semantic Web technologies are being increasingly adopted by the geospatial community during last decade through the utilization of open standards for expressing and serving geospatial data. This was also dramatically assisted by an ever increasing access and usage of geographic mapping and location-based services via smart devices in people’s daily activities. In this paper we explore the developmental framework of a pure Javascript client-side GIS platform exclusively based on invocable geospatial Web services. We also extend Javascript utilization on the server side by deploying a node server acting as a bridge between open source WPS libraries and popular geoprocessing engines. The vehicle for such an exploration is a cross platform Web browser capable of interpreting Javascript commands to achieve interaction with geospatial providers. The tool is a generic Web interface providing capabilities of acquiring spatial datasets, composing layouts and applying geospatial processes. In an ideal form the end-user will have to identify those services, which satisfy a geo-related need and put them in the appropriate row. The final output may act as a potential collector of freely available geospatial web services. Its server-side components may exploit geospatial processing suppliers composing that way a light-weight fully transparent open Web GIS platform.

Case Studies Using JavaScript-Based Frameworks

2014 ◽  
pp. 189-209
Keyword(s):  
Web Services ◽  
Case Studies ◽  
Third Party ◽  
Markup Language ◽  
Business Logic ◽  
Thin Client ◽  
Server Side ◽  
Extensible Markup ◽  
Client Side ◽  
Hypertext Markup Language

In development of thin-client applications, it is a common practice to use server-side technologies in order to create data and business logic back-ends and client side-technologies to create lightweight HyperText Markup Language (HTML)-based front-ends. In the development of Web 2.0 applications, the data and business logic back-ends are typically built on top of third-party Web services. In this context, Simple Object Access Protocol (SOAP) has been traditionally used as the standard communication protocol for eXtensible Markup Language (XML)-based Web services. This chapter presents a review of the support for invoking SOAP-based Web services using Java; then, it discusses the development, using jQuery, Prototype, Dojo, and Java Server Pages (JSP), of different thin-client applications based on third-party SOAP Web services by means of a series of case studies to exemplify the use of some User Interface (UI) patterns for accomplishing rich design principles such as stay on the page and use transitions.

The Distribution of Testing Activities in Web Services and SOA Environment

2013 ◽  
pp. 119-134
Author(s):  
Izzat Alsmadi ◽  
Sascha Alda
Keyword(s):  
Web Services ◽  
Software Development ◽  
Development Environment ◽  
Communication Services ◽  
Server Side ◽  
Challenges And Opportunities ◽  
Testing Stand ◽  
Client Side ◽  
New Software Development ◽  
Software Development Environments

Testing in Web services and SOA environment can be far more distributed in comparison with testing stand-alone or traditional applications. This is because such systems are composed of several hybrid components. These include Web servers and their related components, server side applications, communication services, and client side Web services. In this chapter, the authors focus on challenges and opportunities for software testing in SOA environment. They divide testing activities based on three classifications: testing activities that are going to be similar to those in traditional software development environments, testing activities that will be less usable or popular in SOA, and testing activities that will evolve significantly to adapt to the new environment. The authors believe that most generic testing activities are going to stay in any new software development environment. However, their importance, significance, challenges, and difficulties are going to be dependent on the subject environment. Some tasks will be easier to implement and test and others will either be un-applicable or difficult to test and implement in comparison with testing in traditional software development environments.

scholarly journals Performance Enhancement of Soap Via Multi Level Caching

2010 ◽  
Vol 9 (2) ◽  
pp. 47-52
Author(s):  
Samiksha Shukla ◽  
D. K. Mishra ◽  
Kapil Tiwari
Keyword(s):  
Web Services ◽  
Web Application ◽  
High Performance ◽  
Performance Enhancement ◽  
Access Protocol ◽  
New Approach ◽  
Server Side ◽  
Multi Level ◽  
Client Side ◽  
Remote Communications

Due to complex infrastructure of web application response time for different service request by client requires significantly larger time. Simple Object Access Protocol (SOAP) is a recent and emerging technology in the field of web services, which aims at replacing traditional methods of remote communications. Basic aim of designing SOAP was to increase interoperability among broad range of programs and environment, SOAP allows applications from different languages, installed on different platforms to communicate with each other over the network. Web services demand security, high performance and extensibility. SOAP provides various benefits for interoperability but we need to pay price of performance degradation and security for that. This formulates SOAP a poor preference for high performance web services. In this paper we present a new approach by enabling multi-level caching at client side as well as server side. Reference describes implementation based on the Apache Java SOAP client, which gives radically enhanced performance.

scholarly journals WPS-based technology for client-side remote sensing data processing

2015 ◽  
Vol XL-7/W3 ◽  
pp. 643-649 ◽  
Author(s):  
E. Kazakov ◽  
A. Terekhov ◽  
E. Kapralov ◽  
E. Panidi
Keyword(s):  
Remote Sensing ◽  
Web Services ◽  
Data Processing ◽  
Remote Sensing Data ◽  
Basic Research ◽  
Data Types ◽  
Sensing Data ◽  
Server Side ◽  
Executable Code ◽  
Client Side

Server-side processing is principal for most of the current Web-based geospatial data processing tools. However, in some cases the client-side geoprocessing may be more convenient and acceptable. This study is dedicated to the development of methodology and techniques of Web services elaboration, which allow the client-side geoprocessing also. The practical objectives of the research are focused on the remote sensing data processing, which are one of the most resource-intensive data types. <br><br> The idea underlying the study is to propose such geoprocessing Web service schema that will be compatible with the current serveroriented Open Geospatial Consortium standard (OGC WPS standard), and additionally will allow to run the processing on the client, transmitting processing tool (executable code) over the network instead of the data. At the same time, the unity of executable code must be preserved, and the transmitted code should be the same to that is used for server-side processing. This unity should provide unconditional identity of the processing results that performed using of any schema. The appropriate services are pointed by the authors as a Hybrid Geoprocessing Web Services (HGWSs). <br><br> The common approaches to architecture and structure of the HGWSs are proposed at the current stage as like as a number of service prototypes. For the testing of selected approaches, the geoportal prototype was implemented, which provides access to created HGWS. Further works are conducted on the formalization of platform independent HGWSs implementation techniques, and on the approaches to conceptualization of theirs safe use and chaining possibilities. <br><br> The proposed schema of HGWSs implementation could become one of the possible solutions for the distributed systems, assuming that the processing servers could play the role of the clients connecting to the service supply server. <br><br> The study was partially supported by Russian Foundation for Basic Research (RFBR), research project No. 13-05-12079 ofi_m.

DYNAMIC REST SERVICES ORCHESTRATION USING THE KNOWLEDGE BASE

2019 ◽  
Author(s):  
Kostyantyn Kharchenko
Keyword(s):  
Knowledge Base ◽  
Service Oriented Architecture ◽  
Main Idea ◽  
The Real ◽  
Server Side ◽  
Service Oriented ◽  
Services Orchestration ◽  
Client Side ◽  
Abstract Operation ◽  
Microservice Architecture

The approach to organizing the automated calculations’ execution process using the web services (in particular, REST-services) is reviewed. The given solution will simplify the procedure of introduction of the new functionality in applied systems built according to the service-oriented architecture and microservice architecture principles. The main idea of the proposed solution is in maximum division of the server-side logic development and the client-side logic, when clients are used to set the abstract computation goals without any dependencies to existing applied services. It is proposed to rely on the centralized scheme to organize the computations (named as orchestration) and to put to the knowledge base the set of rules used to build (in multiple steps) the concrete computational scenario from the abstract goal. It is proposed to include the computing task’s execution subsystem to the software architecture of the applied system. This subsystem is composed of the service which is processing the incoming requests for execution, the service registry and the orchestration service. The clients send requests to the execution subsystem without any references to the real-world services to be called. The service registry searches the knowledge base for the corresponding input request template, then the abstract operation description search for the request template is performed. Each abstract operation may already have its implementation in the form of workflow composed of invocations of the real applied services’ operations. In case of absence of the corresponding workflow in the database, this workflow implementation could be synthesized dynamically according to the input and output data and the functionality description of the abstract operation and registered applied services. The workflows are executed by the orchestrator service. Thus, adding some new functions to the client side can be possible without any changes at the server side. And vice versa, adding new services can impact the execution of the calculations without updating the clients.

CADDAC: Multi-Client Collaborative Shape Design System with Server-based Geometry Kernel

2003 ◽  
Vol 3 (2) ◽  
pp. 170-173 ◽  
Author(s):  
Karthik Ramani, ◽  
Abhishek Agrawal, and ◽  
Mahendra Babu ◽  
Christoph Hoffmann
Keyword(s):  
Global Economy ◽  
Design System ◽  
Shape Design ◽  
Server Side ◽  
Collaborative Product Design ◽  
Flexible Architecture ◽  
Computationally Intensive ◽  
New Feature ◽  
Rendering Pipeline ◽  
Client Side

New and efficient paradigms for web-based collaborative product design in a global economy will be driven by increased outsourcing, increased competition, and pressures to reduce product development time. We have developed a three-tier (client-server-database) architecture based collaborative shape design system, Computer Aided Distributed Design and Collaboration (CADDAC). CADDAC has a centralized geometry kernel and constraint solver. The server-side provides support for solid modeling, constraint solving operations, data management, and synchronization of clients. The client-side performs real-time creation, modification, and deletion of geometry over the network. In order to keep the clients thin, many computationally intensive operations are performed at the server. Only the graphics rendering pipeline operations are performed at the client-side. A key contribution of this work is a flexible architecture that decouples Application Data (Model), Controllers, Viewers, and Collaboration. This decoupling allows new feature development to be modular and easy to develop and manage.

Sign in / Sign up

Export Citation Format

Share Document