Deploying Distributed Computing

2000 ◽  
pp. 91-108
Author(s):  
Steve Sawyer ◽  
William Gibbons
Keyword(s):  
Distributed Computing ◽  
Large Scale ◽  
Computing System ◽  
Large Organization ◽  
Client Server ◽  
Teaching Case ◽  
Technology Governance ◽  
Technical Architecture ◽  
Software Implementations ◽  
Server Architecture

This teaching case describes the efforts of one department in a large organization to migrate from an internally developed, mainframe-based, computing system to a system based on purchased software running on a client/server architecture. The case highlights issues with large scale software implementations such as those demanded by enterprise resource package (ERP) installations. Often, the ERP selected by an organization does not have all the required functionality. This demands purchasing and installing additional packages (known colloquially as “bolt-ons”) to provide the needed functionality. These implementations lead to issues regarding oversight of the technical architecture, both project and technology governance, and user department capability for managing the installation of new systems.

Deploying Distributed Computing

2000 ◽  
pp. 24-38
Author(s):  
Steve Sawyer ◽  
William Gibbons
Keyword(s):  
Distributed Computing ◽  
Large Scale ◽  
Computing System ◽  
Large Organization ◽  
Client Server ◽  
Teaching Case ◽  
Technology Governance ◽  
Technical Architecture ◽  
Software Implementations ◽  
Server Architecture

This teaching case describes the efforts of one department in a large organization to migrate from an internally developed, mainframe-based, computing system to a system based on purchased software running on a client/server architecture. The case highlights issues with large scale software implementations such as those demanded by enterprise resource package (ERP) installations. Often, the ERP selected by an organization does not have all the required functionality. This demands purchasing and installing additional packages (known colloquially as bolt-ons) to provide the needed functionality. These implementations lead to issues regarding oversight of the technical architecture, both project and technology governance, and user department capability for managing the installation of new systems.

scholarly journals Building a Secure Biomedical Data Sharing Decentralized App (DApp): Tutorial

10.2196/13601 ◽  
2019 ◽  
Vol 21 (10) ◽  
pp. e13601 ◽  
Author(s):  
Matthew Johnson ◽  
Michael Jones ◽  
Mark Shervey ◽  
Joel T Dudley ◽  
Noah Zimmerman
Keyword(s):  
Data Privacy ◽  
Computing System ◽  
Use Case ◽  
Biomedical Data ◽  
New Paradigm ◽  
Instructional Resources ◽  
Software Developers ◽  
Client Server ◽  
Smart Contract ◽  
Server Architecture

Decentralized apps (DApps) are computer programs that run on a distributed computing system, such as a blockchain network. Unlike the client-server architecture that powers most internet apps, DApps that are integrated with a blockchain network can execute app logic that is guaranteed to be transparent, verifiable, and immutable. This new paradigm has a number of unique properties that are attractive to the biomedical and health care communities. However, instructional resources are scarcely available for biomedical software developers to begin building DApps on a blockchain. Such apps require new ways of thinking about how to build, maintain, and deploy software. This tutorial serves as a complete working prototype of a DApp, motivated by a real use case in biomedical research requiring data privacy. We describe the architecture of a DApp, the implementation details of a smart contract, a sample iPhone operating system (iOS) DApp that interacts with the smart contract, and the development tools and libraries necessary to get started. The code necessary to recreate the app is publicly available.

Expa nsion of the functional of the client-server subsystem of distributed design of VLSI

2021 ◽  
pp. 33-38
Author(s):  
V.M. Glushan ◽  
Keyword(s):  
Distributed Computing ◽  
Simulation Modeling ◽  
Distributed Design ◽  
Client Server ◽  
Functional Capabilities ◽  
Urgent Task ◽  
Partitioning Algorithm ◽  
Server Architecture ◽  
Client Server Architecture

Reducing the time for multiplying matrices of large dimensions is an urgent task, since it finds application in many application areas. One of the ways to solve it is distributed computing based on the use of client-server architectures. The article proposes to expand the functional capabilities of an earlier developed subsystem for distributed design of VLSI, also built using a client-server architecture (CSA). Based on the formulated fundamental principles of dividing matrices into blocks depending on a given number of processors, a partitioning algorithm has been developed and an estimate of its complexity has been given. The results of simulation modeling of multiplication of matrices of large dimensions are presented, which confirmed the possibility of expanding the KSA functional for distributed design of VLSI.

A Lightweight Distributed Computing System Based on JavaScript Technology

2010 ◽  
Vol 34-35 ◽  
pp. 1911-1915
Author(s):  
Jun Tang
Keyword(s):  
Distributed Computing ◽  
Information Exchange ◽  
Large Scale ◽  
Computing System ◽  
The Internet ◽  
Computational Problem ◽  
Intermediary Role ◽  
Computational Platform ◽  
It Expert ◽  
The Web

Because the web is not only the platform for information exchange but also the computational platform based on JavaScript engine, every computer having installed modern browser on the Internet can easily access the web and execute some JavaScript programs. Under above conditions, we develop a lightweight distributed computing system based on the web and JavaScript technologies. Our system plays an intermediary role between the IT expert who has to solve large-scale computational problem and end users on the Internet. In the other words, people could easily cooperate with each other to finish complicated computational problem through the support of our system.

scholarly journals Building a Distributed Computing System for LDMX

2021 ◽  
Vol 251 ◽  
pp. 02038
Author(s):  
Lene Kristian Bryngemark ◽  
David Cameron ◽  
Valentina Dutta ◽  
Thomas Eichlersmith ◽  
Balazs Konya ◽  
...  
Keyword(s):  
Dark Matter ◽  
Distributed Computing ◽  
Particle Physics ◽  
Large Scale ◽  
Research Collaboration ◽  
Pilot Project ◽  
Computing System ◽  
Mass Region ◽  
Small Scale ◽  
Component Integration

Particle physics experiments rely extensively on computing and data services, making e-infrastructure an integral part of the research collaboration. Constructing and operating distributed computing can however be challenging for a smaller-scale collaboration. The Light Dark Matter eXperiment (LDMX) is a planned small-scale accelerator-based experiment to search for dark matter in the sub-GeV mass region. Finalizing the design of the detector relies on Monte-Carlo simulation of expected physics processes. A distributed computing pilot project was proposed to better utilize available resources at the collaborating institutes, and to improve scalability and reproducibility. This paper outlines the chosen lightweight distributed solution, presenting requirements, the component integration steps, and the experiences using a pilot system for tests with large-scale simulations. The system leverages existing technologies wherever possible, minimizing the need for software development, and deploys only non-intrusive components at the participating sites. The pilot proved that integrating existing components can dramatically reduce the effort needed to build and operate a distributed e-infrastructure, making it attainable even for smaller research collaborations.

scholarly journals Parallel Nonnegative Matrix Factorization with Manifold Regularization

2018 ◽  
Vol 2018 ◽  
pp. 1-10
Author(s):  
Fudong Liu ◽  
Zheng Shan ◽  
Yihang Chen
Keyword(s):  
Distributed Computing ◽  
Matrix Factorization ◽  
Large Scale ◽  
Nonnegative Matrix Factorization ◽  
Nonnegative Matrix ◽  
Computing System ◽  
Construction Method ◽  
Manifold Regularization ◽  
Single Node ◽  
Text Corpora

Nonnegative matrix factorization (NMF) decomposes a high-dimensional nonnegative matrix into the product of two reduced dimensional nonnegative matrices. However, conventional NMF neither qualifies large-scale datasets as it maintains all data in memory nor preserves the geometrical structure of data which is needed in some practical tasks. In this paper, we propose a parallel NMF with manifold regularization method (PNMF-M) to overcome the aforementioned deficiencies by parallelizing the manifold regularized NMF on distributed computing system. In particular, PNMF-M distributes both data samples and factor matrices to multiple computing nodes instead of loading the whole dataset in a single node and updates both factor matrices locally on each node. In this way, PNMF-M succeeds to resolve the pressure of memory consumption for large-scale datasets and to speed up the computation by parallelization. For constructing the adjacency matrix in manifold regularization, we propose a two-step distributed graph construction method, which is proved to be equivalent to the batch construction method. Experimental results on popular text corpora and image datasets demonstrate that PNMF-M significantly improves both scalability and time efficiency of conventional NMF thanks to the parallelization on distributed computing system; meanwhile it significantly enhances the representation ability of conventional NMF thanks to the incorporated manifold regularization.

Assurance for Temporal Compatibility Using Contracts

2009 ◽  
pp. 360-371
Author(s):  
Omkar J. Tilak
Keyword(s):  
Distributed Computing ◽  
Software Development ◽  
Distributed System ◽  
Large Scale ◽  
Formal Method ◽  
Computing System ◽  
Temporal Constraints ◽  
System Activity ◽  
Temporal Interaction

Software realization of a large-scale Distributed Computing System (DCS) is achieved through the Componentbased Software Development (CBSD) approach. A DCS consists of many autonomous components that interact with each other to coordinate each system activity. The need for such coordination, along with requirements such as heterogeneity, scalability, security, and availability, considerably increases the complexity of code in a distributed system. This chapter depicts a formal method to specify component interactions involving temporal constraints. Using the component interactions, various types of temporal interaction compatibility classes are defined. A simple case study is presented that indicates the benefits of the component interaction specifications discussed in this chapter.

Sign in / Sign up

Export Citation Format

Share Document