Relevant bibliographies by topics / Skeleton-based programming

Contents

  1. Journal articles
  2. Dissertations / Theses
  3. Book chapters
  4. Conference papers

Academic literature on the topic 'Skeleton-based programming'

Author: Grafiati
Published: 4 June 2021
Last updated: 2 February 2022

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources on the topic 'Skeleton-based programming.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Journal articles on the topic "Skeleton-based programming"

1

Dastgeer, Usman, and Christoph Kessler. "Smart Containers and Skeleton Programming for GPU-Based Systems." International Journal of Parallel Programming 44, no. 3 (March 22, 2015): 506–30. http://dx.doi.org/10.1007/s10766-015-0357-6.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Aversa, R., B. Di Martino, N. Mazzocca, and S. Venticinque. "A Skeleton Based Programming Paradigm for Mobile Multi-Agents on Distributed Systems and Its Realization within the MAGDA Mobile Agents Platform." Mobile Information Systems 4, no. 2 (2008): 131–46. http://dx.doi.org/10.1155/2008/745406.

Full text
Abstract:
Parallel programming effort can be reduced by using high level constructs such as algorithmic skeletons. Within the MAGDA toolset, supporting programming and execution of mobile agent based distributed applications, we provide a skeleton-based parallel programming environment, based on specialization of Algorithmic Skeleton Java interfaces and classes. Their implementation include mobile agent features for execution on heterogeneous systems, such as clusters of WSs and PCs, and support reliability and dynamic workload balancing. The user can thus develop a parallel, mobile agent based application by simply specialising a given set of classes and methods and using a set of added functionalities.
APA, Harvard, Vancouver, ISO, and other styles
3

Coppola, Massimo, and Marco Vanneschi. "High-performance data mining with skeleton-based structured parallel programming." Parallel Computing 28, no. 5 (May 2002): 793–813. http://dx.doi.org/10.1016/s0167-8191(02)00095-9.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

LOOGEN, RITA, YOLANDA ORTEGA-MALLÉN, and RICARDO PEÑA-MARÍ. "Parallel functional programming in Eden." Journal of Functional Programming 15, no. 3 (May 2005): 431–75. http://dx.doi.org/10.1017/s0956796805005526.

Full text
Abstract:
Eden extends the non-strict functional language Haskell with constructs to control parallel evaluation of processes. Although processes are defined explicitly, communication and synchronisation issues are handled in a way transparent to the programmer. In order to offer effective support for parallel evaluation, Eden's coordination constructs override the inherently sequential demand-driven (lazy) evaluation strategy of its computation language Haskell. Eden is a general-purpose parallel functional language suitable for developing sophisticated skeletons – which simplify parallel programming immensely – as well as for exploiting more irregular parallelism that cannot easily be captured by a predefined skeleton. The paper gives a comprehensive description of Eden, its semantics, its skeleton-based programming methodology – which is applied in three case studies – its implementation and performance. Furthermore it points at many additional results that have been achieved in the context of the Eden project.
APA, Harvard, Vancouver, ISO, and other styles
5

Aldinucci, Marco, and Marco Danelutto. "Skeleton-based parallel programming: Functional and parallel semantics in a single shot." Computer Languages, Systems & Structures 33, no. 3-4 (October 2007): 179–92. http://dx.doi.org/10.1016/j.cl.2006.07.004.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

ALDINUCCI, MARCO. "${\mathsf{eskimo}}$: EXPERIMENTING WITH SKELETONS IN THE SHARED ADDRESS MODEL." Parallel Processing Letters 13, no. 03 (September 2003): 449–60. http://dx.doi.org/10.1142/s0129626403001410.

Full text
Abstract:
We discuss the lack of expressivity in some skeleton-based parallel programming frameworks. The problem is further exacerbated when approaching irregular problems and dealing with dynamic data structures. Shared memory programming has been argued to have substantial ease of programming advantages for this class of problems. We present the [Formula: see text] library which represents an attempt to merge the two programming models by introducing skeletons in a shared memory framework.
APA, Harvard, Vancouver, ISO, and other styles
7

BISCHOF, HOLGER, SERGEI GORLATCH, and EMANUEL KITZELMANN. "COST OPTIMALITY AND PREDICTABILITY OF PARALLEL PROGRAMMING WITH SKELETONS." Parallel Processing Letters 13, no. 04 (December 2003): 575–87. http://dx.doi.org/10.1142/s0129626403001525.

Full text
Abstract:
Skeletons are reusable, parameterized program components with well-defined semantics and pre-packaged efficient parallel implementation. This paper develops a new, provably cost-optimal implementation of the DS (double-scan) skeleton for programming divide-and-conquer algorithms. Our implementation is based on a novel data structure called plist (pointed list); implementation's performance is estimated using an analytical model. We demonstrate the use of the DS skeleton for parallelizing a tridiagonal system solver and report experimental results for its MPI implementation on a Cray T3E and a Linux cluster: they confirm the performance improvement achieved by the cost-optimal implementation and demonstrate its good predictability by our performance model.
APA, Harvard, Vancouver, ISO, and other styles
8

Miao, Lu, Shu Yuan Shang, and Chen Xi Cai. "Research on Image Binding Mechanism Based on Kinect Skeletal Tracking in Virtual Fitting System." Applied Mechanics and Materials 376 (August 2013): 437–40. http://dx.doi.org/10.4028/www.scientific.net/amm.376.437.

Full text
Abstract:
On the basis of kinect skeleton track data module, proposing a skeleton track-bound algorithm, you can implement static clothing pictures real time interaction with dynamic characters, combined with WPF in Visual Studio 2010, the corresponding hardware and software resources, a set of accessible and language programming in c# virtual fitting system. Kinect human key joint points coordinates of the corresponding parameter, a corresponding operation, bound to the clothes in the image, makes the image size can be based on different size fitting character change, achieving the desired effect of fitting.
APA, Harvard, Vancouver, ISO, and other styles
9

ZAVANELLA, ANDREA. "SKELETONS, BSP AND PERFORMANCE PORTABILITY." Parallel Processing Letters 11, no. 04 (December 2001): 393–407. http://dx.doi.org/10.1142/s0129626401000683.

Full text
Abstract:
The Skeletal approach to parallel programming conjugates a high-level compositional style and efficiency. A second advantage of Skeletal programming is portability since implementation decisions are usually taken at compile time. The paper claims that an intermediate model embedding the main performance features of the target architecture facilitates performance portability across parallel architectures. This is motivated by describing the Skel-BSP framework which implements a skeleton system on top of a BSP computer. A prototype compiler based on a set of BSP templates is presented together with a set of performance models for each skeleton which allow a local optimization. The paper also introduces a global optimization strategy using a set of transformation rules. This local+global approach seems a viable solution to writing parallel software in machine-independent way (Writing Once and Compiling Everywhere).
APA, Harvard, Vancouver, ISO, and other styles
10

Tang, Yun Long, Guo Lei Zheng, Bao Rui Du, and Shu Lin Chen. "Tool Path Generation for Top Planar Surface of Ribs in Aircraft Structural Parts." Advanced Materials Research 630 (December 2012): 315–20. http://dx.doi.org/10.4028/www.scientific.net/amr.630.315.

Full text
Abstract:
In order to solve the problem regarding the rapid NC machining programming for top planar surface of ribs in aircraft structural parts, an approach based on skeleton extraction technique is presented here to generate tool path for top planar surface. Firstly, the constrained Delaunay triangulation is built to split the rib top planar surface into several sub areas and approximate skeleton branch of each sub area is extracted. Then based on these skeleton branches and process scheme, the set of machining cells of the rib top planar surface is constructed. Secondly, the problem on determining the sequence of machining cells is resolved by optimizing the machining path. Finally, the sequence of machining cells can be converted into the machining cells chain from which tool path can be calculated by CAM systems. Based on the experimental results of the comparison between the generalized pocket method and our approach, our approach is found to be more efficient in generating tool path for top planar surface of ribs.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "Skeleton-based programming"

1

Dastgeer, Usman. "Skeleton Programming for Heterogeneous GPU-based Systems." Licentiate thesis, Linköpings universitet, PELAB - Laboratoriet för programmeringsomgivningar, 2011. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-70234.

Full text
Abstract:
In this thesis, we address issues associated with programming modern heterogeneous systems while focusing on a special kind of heterogeneous systems that include multicore CPUs and one or more GPUs, called GPU-based systems.We consider the skeleton programming approach to achieve high level abstraction for efficient and portable programming of these GPU-based systemsand present our work on SkePU library which is a skeleton library for these systems. We extend the existing SkePU library with a two-dimensional (2D) data type and skeleton operations and implement several new applications using newly made skeletons. Furthermore, we consider the algorithmic choice present in SkePU and implement support to specify and automatically optimize the algorithmic choice for a skeleton call, on a given platform. To show how to achieve performance, we provide a case-study on optimized GPU-based skeleton implementation for 2D stencil computations and introduce two metrics to maximize resource utilization on a GPU. By devising a mechanism to automatically calculate these two metrics, performance can be retained while porting an application from one GPU architecture to another. Another contribution of this thesis is implementation of the runtime support for the SkePU skeleton library. This is achieved with the help of the StarPUruntime system. By this implementation,support for dynamic scheduling and load balancing for the SkePU skeleton programs is achieved. Furthermore, a capability to do hybrid executionby parallel execution on all available CPUs and GPUs in a system, even for a single skeleton invocation, is developed. SkePU initially supported only data-parallel skeletons. The first task-parallel skeleton (farm) in SkePU is implemented with support for performance-aware scheduling and hierarchical parallel execution by enabling all data parallel skeletons to be usable as tasks inside the farm construct. Experimental evaluations are carried out and presented for algorithmic selection, performance portability, dynamic scheduling and hybrid execution aspects of our work.
APA, Harvard, Vancouver, ISO, and other styles
2

Bratvold, Tore Andreas. "Skeleton-based parallelisation of functional programs." Thesis, Heriot-Watt University, 1994. http://hdl.handle.net/10399/1355.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Parsons, Peter Jolyon. "A new parallel programming system based on an algorithmic skeleton." Thesis, University of Hull, 1998. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.301632.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Wanderley, Goes Luis Fabricio. "Automatic skeleton-driven performance optimizations for transactional memory." Thesis, University of Edinburgh, 2012. http://hdl.handle.net/1842/5837.

Full text
Abstract:
The recent shift toward multi-core chips has pushed the burden of extracting performance to the programmer. In fact, programmers now have to be able to uncover more coarse-grain parallelism with every new generation of processors, or the performance of their applications will remain roughly the same or even degrade. Unfortunately, parallel programming is still hard and error prone. This has driven the development of many new parallel programming models that aim to make this process efficient. This thesis first combines the skeleton-based and transactional memory programming models in a new framework, called OpenSkel, in order to improve performance and programmability of parallel applications. This framework provides a single skeleton that allows the implementation of transactional worklist applications. Skeleton or pattern-based programming allows parallel programs to be expressed as specialized instances of generic communication and computation patterns. This leaves the programmer with only the implementation of the particular operations required to solve the problem at hand. Thus, this programming approach simplifies parallel programming by eliminating some of the major challenges of parallel programming, namely thread communication, scheduling and orchestration. However, the application programmer has still to correctly synchronize threads on data races. This commonly requires the use of locks to guarantee atomic access to shared data. In particular, lock programming is vulnerable to deadlocks and also limits coarse grain parallelism by blocking threads that could be potentially executed in parallel. Transactional Memory (TM) thus emerges as an attractive alternative model to simplify parallel programming by removing this burden of handling data races explicitly. This model allows programmers to write parallel code as transactions, which are then guaranteed by the runtime system to execute atomically and in isolation regardless of eventual data races. TM programming thus frees the application from deadlocks and enables the exploitation of coarse grain parallelism when transactions do not conflict very often. Nevertheless, thread management and orchestration are left for the application programmer. Fortunately, this can be naturally handled by a skeleton framework. This fact makes the combination of skeleton-based and transactional programming a natural step to improve programmability since these models complement each other. In fact, this combination releases the application programmer from dealing with thread management and data races, and also inherits the performance improvements of both models. In addition to it, a skeleton framework is also amenable to skeleton-driven performance optimizations that exploits the application pattern and system information. This thesis thus also presents a set of pattern-oriented optimizations that are automatically selected and applied in a significant subset of transactional memory applications that shares a common pattern called worklist. These optimizations exploit the knowledge about the worklist pattern and the TM nature of the applications to avoid transaction conflicts, to prefetch data, to reduce contention etc. Using a novel autotuning mechanism, OpenSkel dynamically selects the most suitable set of these pattern-oriented performance optimizations for each application and adjusts them accordingly. Experimental results on a subset of five applications from the STAMP benchmark suite show that the proposed autotuning mechanism can achieve performance improvements within 2%, on average, of a static oracle for a 16-core UMA (Uniform Memory Access) platform and surpasses it by 7% on average for a 32-core NUMA (Non-Uniform Memory Access) platform. Finally, this thesis also investigates skeleton-driven system-oriented performance optimizations such as thread mapping and memory page allocation. In order to do it, the OpenSkel system and also the autotuning mechanism are extended to accommodate these optimizations. The conducted experimental results on a subset of five applications from the STAMP benchmark show that the OpenSkel framework with the extended autotuning mechanism driving both pattern and system-oriented optimizations can achieve performance improvements of up to 88%, with an average of 46%, over a baseline version for a 16-core UMA platform and up to 162%, with an average of 91%, for a 32-core NUMA platform.
APA, Harvard, Vancouver, ISO, and other styles
5

Cai, Hua. "A skeleton-based approach for distributed real-time systems design and implementation." Thesis, University of Hull, 2000. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.273624.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Outram, Matthew Edward. "A skeleton-based programming environment for parallel and distributed fault-tolerant real-time systems." Thesis, University of Hull, 1999. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.310311.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Sjöström, Oskar. "Parallelizing the Edge application for GPU-based systems using the SkePU skeleton programming library." Thesis, Linköpings universitet, Programvara och system, 2015. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-122255.

Full text
Abstract:
SkePU is an auto-tunable multi-backend skeleton programming library for multi-GPU systems. SkePU is implemented as a C++ template library and has been developed at Linköping University. In this thesis the CFD flow solver Edge has been ported to SkePU. This combines the paradigm of skeleton programming with the utilization of the unstructured grid structure used by Edge. In order to do this certain extensions have been made to the SkePU library. The performance of the ported implementation has been evaluated to identify if a performance gain can be achieved by parallelizing this type of application with the help of SkePU. A moderate speedup of the application has been achieved given the size of the ported section of the Edge application. Another important outcome of the project is the provided feedback for further development of the SkePU framework.
APA, Harvard, Vancouver, ISO, and other styles
8

Mangaraj, Swadhin K. "Extension of the SkePU Skeleton ProgrammingFramework for Multi-core CPU and Multi-GPU Systems for MPI-based Clusters." Thesis, Linköpings universitet, Programvara och system, 2013. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-98813.

Full text
Abstract:
SkePU (Skeleton Programming Framework for Multi-core CPU and Multi-GPU Systems) is a parallel computing framework developed by Johan Enmyren and Christoph Kessler at Linköpings Universitet. This C++ template library provides a simple and unified interface for specifying data-parallel computations with the help of skeletons and is targeted to multiple backends e.g. for a sequential CPU, parallel CPUs using MPI and OpenMP or GPUs using CUDA and OpenCL. SkePU is comprised of seven data-parallel skeletons and one task-parallel skeleton and these skeletons use two types of containers: vector and matrix to model real-life parallel applications. In this thesis, we address the extension of the SkePU framework by extending the matrix container (which stores 2-D data values) that can efficiently use the existing skeletons to develop parallel scientific applications on large-scale clusters using MPI. This piece of work focuses on the distribution of the matrix among the participating processes which after receiving their share of data can execute the application in parallel. This work covers all of the seven data-parallel skeletons. Each skeleton has been tested with a small application program. In addition to measurement of performance improvement from the application program’s execution time, we have also done a communication cost analysis for all skeletons with MPI using the LogGP model. In order to evaluate and test the operational efficiency of the extension, we have considered a PDE solver application. Through this application, we have demonstrated the performance gain and scalability of the extended framework. The performance improvement was more when computational load dominates the memory I/O operations. The results show that using the extension can serve as a viable approach while implementing real-life parallel applications on large-scale clusters.
APA, Harvard, Vancouver, ISO, and other styles

Book chapters on the topic "Skeleton-based programming"

1

Rabhi, Fethi A. "Skeleton-based Programming Environments." In Patterns and Skeletons for Parallel and Distributed Computing, 187–208. London: Springer London, 2003. http://dx.doi.org/10.1007/978-1-4471-0097-3_7.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Coudarcher, Rémi, Jocelyn Sérot, and Jean-Pierre Dérutin. "Implementation of a Skeleton-Based Parallel Programming Environment Supporting Arbitrary Nesting." In High-Level Parallel Programming Models and Supportive Environments, 71–84. Berlin, Heidelberg: Springer Berlin Heidelberg, 2001. http://dx.doi.org/10.1007/3-540-45401-2_6.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Sérot, Jocelyn, Dominique Ginhac, and Jean-Pierre Dérutin. "SKiPPER: A Skeleton-Based Parallel Programming Environment for Real-Time Image Processing Applications." In Lecture Notes in Computer Science, 296–305. Berlin, Heidelberg: Springer Berlin Heidelberg, 1999. http://dx.doi.org/10.1007/3-540-48387-x_31.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

"Software Design Based on Using Ontologies and Algorithm Algebra." In Advances in Systems Analysis, Software Engineering, and High Performance Computing, 217–55. IGI Global, 2021. http://dx.doi.org/10.4018/978-1-5225-9384-3.ch007.

Full text
Abstract:
This chapter proposes an approach to the automated development of programs based on the use of ontological facilities and algebra-algorithmic toolkit for design and synthesis of programs (IDS). The program design ontology, developed using Protégé system and represented in OWL format, includes concepts from various subject domains (sorting, meteorological forecasting, and other) intended for description of main program objects: data, functions, and relations between them. IDS toolkit generates the initial (skeleton) algorithm scheme based on its ontological description extracted from OWL file. The generated scheme is the basis of further design of the algorithm and synthesis of a program in a target programming language. The approach is illustrated by examples of developing parallel sorting, meteorological forecasting, and N-body simulation programs.
APA, Harvard, Vancouver, ISO, and other styles
5

Leal, José Paulo, and Ricardo Queirós. "An Example-Based Generator of XSLT Programs." In Innovations in XML Applications and Metadata Management, 1–20. IGI Global, 2013. http://dx.doi.org/10.4018/978-1-4666-2669-0.ch001.

Full text
Abstract:
XSLT is a powerful and widely used language for transforming XML documents. However, its power and complexity can be overwhelming for novice or infrequent users, many of whom simply give up on using this language. On the other hand, many XSLT programs of practical use are simple enough to be automatically inferred from examples of source and target documents. An inferred XSLT program is seldom adequate for production usage but can be used as a skeleton of the final program, or at least as scaffolding in the process of coding it. It should be noted that the authors do not claim that XSLT programs, in general, can be inferred from examples. The aim of Vishnu—the XSLT generator engine described in this chapter—is to produce XSLT programs for processing documents similar to the given examples and with enough readability to be easily understood by a programmer not familiar with the language. The architecture of Vishnu is composed by a graphical editor and a programming engine. In this chapter, the authors focus on the editor as a GWT Web application where the programmer loads and edits document examples and pairs their content using graphical primitives. The programming engine receives the data collected by the editor and produces an XSLT program.
APA, Harvard, Vancouver, ISO, and other styles

Conference papers on the topic "Skeleton-based programming"

1

Metzger, Paul, Murray Cole, Christian Fensch, Marco Aldinucci, and Enrico Bini. "Enforcing Deadlines for Skeleton-based Parallel Programming." In 2020 IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS). IEEE, 2020. http://dx.doi.org/10.1109/rtas48715.2020.000-7.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Kist, Deives, Bruno Pinto, Rodrigo Bazo, Andre Rauber Du Bois, and Gerson Geraldo H. Cavalheiro. "Kanga: A Skeleton-Based Generic Interface for Parallel Programming." In IEEE 27th International Symposium on Computer Architecture and High-Performance Computing Workshops, SBAC-PADW 2015. IEEE, 2015. http://dx.doi.org/10.1109/sbac-padw.2015.16.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Mehraban, Arash, Jed Brown, Valeria Barra, Henry Tufo, Jeremy Thompson, and Richard Regueiro. "Efficient Residual and Matrix-Free Jacobian Evaluation for Three-Dimensional Tri-Quadratic Hexahedral Finite Elements With Nearly-Incompressible Neo-Hookean Hyperelasticity Applied to Soft Materials on Unstructured Meshes in Parallel, With PETSc and libCEED." In ASME 2020 International Mechanical Engineering Congress and Exposition. American Society of Mechanical Engineers, 2020. http://dx.doi.org/10.1115/imece2020-24522.

Full text
Abstract:
Abstract Soft materials such as rubber, elastomers, and soft biological tissues mechanically deform at large strain isochorically for all time, or during their initial transient (when a pore fluid, typically incompressible such as water, does not have time to flow out of the deforming polymer or soft tissue porous skeleton). Simulating these large isochoric deformations computationally, such as with the Finite Element Method (FEM), requires higher order (typically quadratic) interpolation functions and/or enhancements through hybrid/mixed methods to maintain stability. Lower order (linear) finite elements with hybrid/mixed formulation may not perform stably for all mechanical loading scenarios involving large isochoric deformations, whereas quadratic finite elements with or without hybrid/mixed formulation typically perform stably, especially when large bending or folding deformations are being simulated. For topology-optimization design of soft robotics, for instance, the FEM solid mechanics solver must run efficiently and stably. Stability is ensured by the higher order finite element formulation (with possible enhancement), but efficiency for higher order FEM remains a challenge. Thus, this paper addresses efficiency from the perspective of computer science algorithms and programming. The proposed efficient algorithm utilizes the Portable, Extensible Toolkit for Scientific Computation (PETSc), along with the libCEED library for efficient compiler optimized tensor-product-basis computation to demonstrate an efficient nonlinear solution algorithm. For preconditioning, a scalable p-multigrid method is presented whereby a hierarchy of levels is constructed. In contrast to classical geometric multigrid, also known as h-multigrid, each level in p-multigrid is related to a different approximation polynomial order, p, instead of the element size, h. A Chebyshev polynomial smoother is used on each multigrid level. Algebraic MultiGrid (AMG) is then applied to the assembled Q1 (linear) coarse mesh on the nodes of the quadratic Q2 (quadratic) mesh. This allows low storage that can be efficiently used to accelerate the convergence to solution. For a Neo-Hookean hyperelastic problem, we examine a residual and matrix-free Jacobian formulation of a tri-quadratic hexahedral finite element with enhancement. Efficiency estimates on AVX-2 architecture based on CPU time are provided as a comparison to similar simulation (and mesh) of isochoric large deformation hyperelasticity as applied to soft materials conducted with the commercially-available FEM software program ABAQUS. The particular problem in consideration is the simulation of an assistive device in the form of finger-bending in 3D.
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'Skeleton-based programming' for particular source types:
Journal articles
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography