Relevant bibliographies by topics / C (programming languages)

Contents

  1. Journal articles
  2. Dissertations / Theses
  3. Books
  4. Book chapters
  5. Conference papers
  6. Reports

Academic literature on the topic 'C (programming languages)'

Author: Grafiati
Published: 4 June 2021
Last updated: 1 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 'C (programming languages).'

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 "C (programming languages)"

1

Cheng, H. H. "Extending C and FORTRAN for Design Automation." Journal of Mechanical Design 117, no. 3 (1995): 390–95. http://dx.doi.org/10.1115/1.2826691.

Full text
Abstract:
The CH programming language is designed to be a superset of C. CH bridges the gap between C and FORTRAN; it encompasses all the programming capabilities of FORTRAN 77 and consists of features of many other programming languages and software packages. Unlike other general-purpose programming languages, CH is designed to be especially suitable for applications in mechanical systems engineering. Because of our research interests, many programming features in CH have been implemented for design automation, although they are useful in other applications as well. In this paper we will describe these new programming features for design automation, as they are currently implemented in CH in comparison with C and FORTRAN 77.
APA, Harvard, Vancouver, ISO, and other styles
2

Rak, Filip, and Jozef Wiora. "Comparison of ESP programming platforms." Computer Science and Information Technologies 2, no. 2 (2021): 77–86. http://dx.doi.org/10.11591/csit.v2i2.p77-86.

Full text
Abstract:
The growing popularity of ESP boards has led to the development of several programming platforms. They allow users to develop applications for ESP modules in different programming languages, such as C++, C, Lua, MicroPython, or using AT Commands. Each of them is very specific and has different advantages. The programming style, efficiency, speed of execution, level of advancement, or memory usage will differ from one language to another. Users mostly base their choice depending on their programming skills and goals of the planned projects. The aim of this work is to determine, which language is the best suitable for a particular user for a particular type of project. We have described and compared the mentioned languages. We have prepared test tasks to indicate quantified values. There is no common rule because each of the languages is intended for a different kind of user. While one of the languages is slower but simpler in usage for a beginner, the other one requires broad knowledge but offers availability to develop very complex applications.
APA, Harvard, Vancouver, ISO, and other styles
3

GARCIA, RONALD, JAAKKO JARVI, ANDREW LUMSDAINE, JEREMY SIEK, and JEREMIAH WILLCOCK. "An extended comparative study of language support for generic programming." Journal of Functional Programming 17, no. 2 (2007): 145–205. http://dx.doi.org/10.1017/s0956796806006198.

Full text
Abstract:
AbstractMany modern programming languages support basic generics, sufficient to implement type-safe polymorphic containers. Some languages have moved beyond this basic support, and in doing so have enabled a broader, more powerful form of generic programming. This paper reports on a comprehensive comparison of facilities for generic programming in eight programming languages: C++, Standard ML, Objective Caml, Haskell, Eiffel, Java, C# (with its proposed generics extension), and Cecil. By implementing a substantial example in each of these languages, we illustrate how the basic roles of generic programming can be represented in each language. We also identify eight language properties that support this broader view of generic programming: support for multi-type concepts, multiple constraints on type parameters, convenient associated type access, constraints on associated types, retroactive modeling, type aliases, separate compilation of algorithms and data structures, and implicit argument type deduction for generic algorithms. We find that these features are necessary to avoid awkward designs, poor maintainability, and painfully verbose code. As languages increasingly support generics, it is important that language designers understand the features necessary to enable the effective use of generics and that their absence can cause difficulties for programmers.
APA, Harvard, Vancouver, ISO, and other styles
4

BERNARDY, JEAN-PHILIPPE, PATRIK JANSSON, MARCIN ZALEWSKI, and SIBYLLE SCHUPP. "Generic programming with C++ concepts and Haskell type classes—a comparison." Journal of Functional Programming 20, no. 3-4 (2010): 271–302. http://dx.doi.org/10.1017/s095679681000016x.

Full text
Abstract:
AbstractEarlier studies have introduced a list of high-level evaluation criteria to assess how well a language supports generic programming. Languages that meet all criteria include Haskell because of its type classes and C++ with the concept feature. We refine these criteria into a taxonomy that captures commonalities and differences between type classes in Haskell and concepts in C++ and discuss which differences are incidental and which ones are due to other language features. The taxonomy allows for an improved understanding of language support for generic programming, and the comparison is useful for the ongoing discussions among language designers and users of both languages.
APA, Harvard, Vancouver, ISO, and other styles
5

González García, Cristian, Jordán Pascual Espada B., Cristina Pelayo G-Bustelo, and Juan Manuel Cueva Lovelle. "EL FUTURO DE APPLE: SWIFT VERSUS OBJECTIVE-C." Redes de Ingeniería 6, no. 2 (2015): 6. http://dx.doi.org/10.14483/udistrital.jour.redes.2015.2.a01.

Full text
Abstract:
Hace unos meses Apple presentó un nuevo lenguaje de programación para sus plataformas: Swift. Con Swift, Apple pretende atraer a los programadores de los lenguajes de programación basados en la sintaxis de C++ y darles una mayor abstracción, que con Objective-C, para que sea más fácil programar para las plataformas de Apple. Por estas razones, se hace necesario contrastar lo pretendido por Apple y realizar un estudio del lenguaje de programación a fin de contrastar su objetivo. Para ello, se hicieron dos evaluaciones, una cualitativa y otra cuantitativa, con el propósito de verificar en qué medida Swift es un avance respecto a Objective-C.DThe Future of Apple: Swift Versus Objective-CABSTRACTFew months ago, Apple presented a new programming language: Swift. With Swift, Apple pretends to attract the programmers of the programming languages based on C++ syntax and gives them a higher abstraction than with Objective-C for being easier to programme to Apple’s platforms. For these reasons, it is necessary to contrast what is intended by Apple and do a study of the programming language to ascertain their goal. For this purpose, we did two evaluations, firstly a qualitative evaluation and after, a quantitative evaluation to verify in how much Swift is an advance with respect to Objective-C.Keywords: computer languages, computer programming, functional programming, object oriented programming, programming, software.
APA, Harvard, Vancouver, ISO, and other styles
6

Szűgyi, Zalán, Márk Török, Norbert Pataki, and Tamás Kozsik. "High-level multicore programming with C++11." Computer Science and Information Systems 9, no. 3 (2012): 1187–202. http://dx.doi.org/10.2298/csis111231027s.

Full text
Abstract:
Nowadays, one of the most important challenges in programming is the efficient usage of multicore processors. All modern programming languages support multicore programming at native or library level. C++11, the next standard of the C++ programming language, also supports multithreading at a low level. In this paper we argue for some extensions of the C++ Standard Template Library based on the features of C++11. These extensions enhance the standard library to be more powerful in the multicore realm. Our approach is based on functors and lambda expressions, which are major extensions in the language. We contribute three case studies: how to efficiently compose functors in pipelines, how to evaluate boolean operators in parallel, and how to efficiently accumulate over associative functors.
APA, Harvard, Vancouver, ISO, and other styles
7

Liang, Xu, Ke Ming Wang, and Gui Yu Xin. "Application of C Sharp and MATLAB Mixed Programming Based on .Net Assembly in Blind Source Separation." Applied Mechanics and Materials 599-601 (August 2014): 1407–10. http://dx.doi.org/10.4028/www.scientific.net/amm.599-601.1407.

Full text
Abstract:
Comparing with other High-level programming languages, C Sharp (C#) is more efficient in software development. While MATLAB language provides a series of powerful functions of numerical calculation that facilitate adoption of algorithms, which are widely applied in blind source separation (BSS). Combining the advantages of the two languages, this paper presents an implementation of mixed programming and the development of a simplified blind signal processing system. Application results show the system developed by mixed programming is successful.
APA, Harvard, Vancouver, ISO, and other styles
8

Costanza, Pascal, Charlotte Herzeel, and Wilfried Verachtert. "Comparing Ease of Programming in C++, Go, and Java for Implementing a Next-Generation Sequencing Tool." Evolutionary Bioinformatics 15 (January 2019): 117693431986901. http://dx.doi.org/10.1177/1176934319869015.

Full text
Abstract:
elPrep is an extensible multithreaded software framework for efficiently processing Sequence Alignment/Map (SAM)/Binary Alignment/Map (BAM) files in next-generation sequencing pipelines. Similar to other SAM/BAM tools, a key challenge in elPrep is memory management, as such programs need to manipulate large amounts of data. We therefore investigated 3 programming languages with support for assisted or automated memory management for implementing elPrep, namely C++, Go, and Java. We implemented a nontrivial subset of elPrep in all 3 programming languages and compared them by benchmarking their runtime performance and memory use to determine the best language in terms of computational performance. In a previous article, we motivated why, based on these results, we eventually selected Go as our implementation language. In this article, we discuss the difficulty of achieving the best performance in each language in terms of programming language constructs and standard library support. While benchmarks are easy to objectively measure and evaluate, this is less obvious for assessing ease of programming. However, because we expect elPrep to be regularly modified and extended, this is an equally important aspect. We illustrate representative examples of challenges in all 3 languages, and give our opinion why we think that Go is a reasonable choice also in this light.
APA, Harvard, Vancouver, ISO, and other styles
9

Naveed, Muhammad Shumail. "Comparison of C++ and Java in Implementing Introductory Programming Algorithms." Quaid-e-Awam University Research Journal of Engineering Science & Technology 19, no. 1 (2021): 95–103. http://dx.doi.org/10.52584/qrj.1901.14.

Full text
Abstract:
Computer programming is the heart of computer science and C++ and Java are the most popular and widely used languages. The performance of C++ and Java programming languages has been benchmarked using robotics, numerical, genetic and evolutionary algorithms, but not using introductory programming algorithms. This article examined C++ and Java by analysing the implementation of novice algorithms of introductory programming courses by evaluating the difficulty, effort, time and delivered bugs of programs with Halstead software metrics. The study identified that Java is more difficult than C++ in the implementation of selected algorithms. Similarly, the efforts required to translate the novice algorithms in Java are higher than C++. The time involved in translating selected algorithms in C++ is lower than Java. Similarly, the number of delivered bugs in C++ is lower than Java. The study suggests that C++ is more suitable than Java for the implementation of introductory programming algorithms and reasonably more suitable for introductory programming courses. The study emboldens the programming linguists to do further analyses in contemplating other programming languages with Halstead software metrics and other kinds of algorithms.
APA, Harvard, Vancouver, ISO, and other styles
10

Santana, Vanessa M., and Paolina Centonze. "SECURITY MECHANISMS AND ANALYSIS FOR INSECURE DATA STORAGE AND UNINTENDED DATA LEAKAGE FOR MOBILE APPLICATIONS." INTERNATIONAL JOURNAL OF COMPUTERS & TECHNOLOGY 15, no. 8 (2016): 7008–20. http://dx.doi.org/10.24297/ijct.v15i8.3754.

Full text
Abstract:
Using one mobile programming language like Objective-C, Swift or Java is challenging enough because of the many things that need to be considered from a security point of view, like the programming language secure guidelines and vulnerabilities. With the introduction of Swift in 2014 it’s now possible to build Swift/Objective-C mobile applications. Building a mobile application using two languages also adds a greater attack surface for hackers because of the need for developers to stay up to date on vulnerabilities on more than one language and operating system.To our best knowledge, since as of today, there is no academic-research based effort comparing Swift, Objective-C and Android from a programming language and platform security point of view. Our comparative analysis covers a subset of OWASP top ten mobile vulnerabilities and seeing how Swift, Objective-C and Android programming languages safeguard against these risks and how the built-in platform security mechanisms for Android and Apple for the chosen subset of OWASP vulnerabilities compare when placed side-by-side.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "C (programming languages)"

1

Pichon-Pharabod, Jean Yves Alexis. "A no-thin-air memory model for programming languages." Thesis, University of Cambridge, 2018. https://www.repository.cam.ac.uk/handle/1810/274465.

Full text
Abstract:
Many hardware and compiler optimisations introduced to speed up single-threaded programs also introduce additional, sometimes surprising, behaviours for concurrent programs with shared mutable state. How many of these extra behaviours occur in practice depends on the combination of the hardware, compiler, runtime, etc. that make up the platform. A memory model, which prescribes what values each read of a concurrent program can read, allows programmers to determine whether a program behaves as expected without having to worry about the details of the platform. However, capturing these behaviours in a memory model without also including undesirable "out-of-thin-air" behaviours that do not occur in practice has proved elusive. The memory model of C and C++ allows out-of-thin-air behaviour, while the Java memory model fails to capture some behaviours that are introduced in practice by compiler optimisations. In this thesis, we propose a memory model that forbids out-of-thin-air behaviour, yet allows the behaviours that do occur. Our memory model follows operational intuitions of how the hardware and compilers operate. We illustrate that it behaves as desired on a series of litmus tests. We show that it captures at least some of the expected behaviours, that it forms an envelope around some common compiler optimisations, and that it is implementable on common hardware using the expected compilation schemes. We also show that it supports some established programming idioms.
APA, Harvard, Vancouver, ISO, and other styles
2

McNamara, Brian. "Multiparadigm programming novel devices for implementing functional and logic programming constructs in C++ /." Diss., Available online, Georgia Institute of Technology, 2004:, 2004. http://etd.gatech.edu/theses/available/etd-07122004-121450/unrestricted/mcnamara%5Fbrian%5Fm%5F200407%5Fphd.pdf.

Full text
Abstract:
Thesis (Ph. D.)--College of Computing, Georgia Institute of Technology, 2005. Directed by Yannis Smaragdakis.<br>Spencer Rugaber, Committee Member ; Olin Shivers, Committee Member ; Mary Jean Harrold, Committee Member ; Yannis Smaragdakis, Committee Chair ; Philip Wadler, Committee Member. Includes bibliographical references.
APA, Harvard, Vancouver, ISO, and other styles
3

Tonchev, Ognyan, and Mohammed Salih. "High-level programming languages translator." Thesis, Blekinge Tekniska Högskola, Avdelningen för för interaktion och systemdesign, 2008. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-2560.

Full text
Abstract:
This paper discusses a high level language translator. If we divide translators of programming languages in two types: those working for two specific languages and universal translators that can be used for translation between different programming languages, the solution that will be presented in this work can be classified as both, specific language oriented and an universal translator. For the purpose of the research it was limited to translate only from Java to C++, but it can easily be extended to translate between any other high level languages. For simplifying the process of translation the project uses an intermediate step. All programs in the input language are first compiled to an abstract XML language and then to the desired output language. That way it is not necessary to translate directly from one programming language to another which is a very tricky and difficult task and could make the solution difficult to be maintained and extended. Hence the translator can also be used to translate from any high level language to XML. That gives another advantage to our solution: an XML representation of a computer program is valuable information by itself. We describe the design and implementation of the solution, demonstrate how it works and also give information on how it can be extended to work for any other programming language.<br>This paper discusses a high level language translator. If we divide translators of programming languages in two types: those working for two specific languages and universal translators that can be used for translation between different programming languages, the solution that will be presented in this work can be classified as both, specific language oriented and an universal translator. For the purpose of the research it was limited to translate only from Java to C++, but it can easily be extended to translate between any other high level languages. For simplifying the process of translation the project uses an intermediate step. All programs in the input language are first compiled to an abstract XML language and then to the desired output language. That way it is not necessary to translate directly from one programming language to another which is a very tricky and difficult task and could make the solution difficult to be maintained and extended. Hence the translator can also be used to translate from any high level language to XML. That gives another advantage to our solution: an XML representation of a computer program is valuable information by itself. We describe the design and implementation of the solution, demonstrate how it works and also give information on how it can be extended to work for any other programming language.
APA, Harvard, Vancouver, ISO, and other styles
4

Laos, Pontus, and Alexander Libot. "Comparing Conventional- and Modern Programming Languages for Developing a File System." Thesis, Malmö universitet, Institutionen för datavetenskap och medieteknik (DVMT), 2021. http://urn.kb.se/resolve?urn=urn:nbn:se:mau:diva-43451.

Full text
Abstract:
Most of the software stack is built upon C today. C is a very flexible language, but the flexibility also brings some safety risks, particularly when handling memory through pointers. Rust is a new programming language which can guarantee memory safety without performance-heavy runtime services such as garbage collection. In this article, two partial file systems are implemented based on the design of EXT2. One system is implemented in C — Nafs — and one system is implemented in Rust — Rufs. A number of benchmarks are also developed, with the purpose of testing the most common features of a file system. After running the benchmarks, the results showed that Nafs provided better performance for all but one feature. There could be many reasons for this, and some hypotheses are discussed. Aspects like different compiler optimizations, the use of pointer dereferencing vs. data structure representation, using dynamic memory, and using system calls are considered. Some optimizations to Rufs are also implemented, and their impact analyzed. Earlier research has shown that Rust can guarantee memory safety while still providing good performance. It has also shown that Rust can be used to implement system programs, such as operating system kernels. Over the course of this article, it is shown that safe Rust can be used to implement a file system — thereby guaranteeing a memory safe program. It is also shown that a file system implemented in safe Rust provides worse performance than a similar system written in C. Future work will have to tell whether a file system can be as performant in Rust as in C, by using different implementation methods or unsafe Rust for some of the most performance critical parts of the system.
APA, Harvard, Vancouver, ISO, and other styles
5

Concepcion, Rowen. "Introducing Non-Determinism to the Parallel C Compiler." CSUSB ScholarWorks, 2014. https://scholarworks.lib.csusb.edu/etd/22.

Full text
Abstract:
The Planguages project is the birthplace of the Planguage programmingapproach, which is designed to alleviate the task of writing parallelprograms and harness massively parallel computers and networks of workstations. Planguage has two existing translators, Parallel C (PC) and Pfortran,which is used for their base languages, C and Fortran77. The translatorswork with MPI (Message Passing Interface) for communications. SOS(ipStreams, Overlapping and Shortcutting), a function library that supportsthe three named functionalities, can be used to further optimize parallel algorithms. This project is the next step in the continuing project of updatingthe PC Compiler. The goal is to test the viability of using “shortcutting”functions. Parallel programs with the ability to shortcut can be generatedby the updated version of the PC Compiler. In addition, this project introducesthe ability of the PC Compiler to translate a race condition intoa non-deterministic solution. This document explores different phases of the project in detail. Thefollowing phases are included: software design, algorithm design, analysis,and results. The deliverables, source code, and diagrams are included asAppendices.
APA, Harvard, Vancouver, ISO, and other styles
6

Roback, Joseph Anthony. "Gossamer: A Lightweight Approach to Using Multicore Machines." Diss., The University of Arizona, 2010. http://hdl.handle.net/10150/194468.

Full text
Abstract:
The key to performance improvements in the multicore era is for software toutilize the newly available concurrency. Consequently, programmers will have tolearn new programming techniques, and software systems will have to be able tomanage the parallelism effectively. The challenge is to do so simply, portably,and efficiently.This dissertation presents a lightweight programming framework called Gossamerthat is easy to use, enables the solution of a broad range of parallelprogramming problems, and produces efficient code. Gossamer supports task andrecursive parallelism, iterative parallelism, domain decomposition, pipelinedcomputations, and MapReduce computations. Gossamer contains (1) a set ofhigh-level annotations that one adds to a sequential program to specifyconcurrency and synchronization, (2) a source-to-source translator that producesan optimized program, and (3) a run-time system that provides efficient threadsand synchronization. The annotation-based programming model simplifies writingparallel programs by allowing the programmer to concentrate on the applicationand not the extensive bookkeeping involved with concurrency and synchronization;moreover, the annotations never reference any particulars of the underlyinghardware.
APA, Harvard, Vancouver, ISO, and other styles
7

Li, Bin. "An interface between single assignment C and vector pascal." Connect to e-thesis, 2007. http://theses.gla.ac.uk/107/.

Full text
Abstract:
Thesis (Ph.D.) - University of Glasgow, 2007.<br>Ph.D. thesis submitted to the Department of Computing Science, Faculty of Information and Mathematical Sciences, University of Glasgow, 2007. Includes bibliographical references. Print version also available.
APA, Harvard, Vancouver, ISO, and other styles
8

Karlbäck, Rasmus, and Anton Orö. "Holistic View on Alternative Programming languages for Radio Access Network Applications in Cloud and Embedded Deployments." Thesis, Linköpings universitet, Programvara och system, 2021. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-176307.

Full text
Abstract:
With the emergence of cloud based solutions, companies such as Ericsson AB have started investigating different means of modernizing current implementations of software systems. With many new programming languages emerging such as Rust and Go, investigating the suitability of these languages compared to C++ can be seen as a part of this modernization process. There are many important aspects to consider when investigating the suitability of new programming languages, and this thesis makes an attempt at considering most of them. Therefore both performance which is a common metric as well as development efficiency which is a less common metric, were combined to provide a holistic view. Performance was defined as CPU usage, maximum memory usage, processing time per sequence and latency at runtime, which was measured on both x86 and ARM based hardware. Development efficiency was defined as the combination of the productivity metric, the maintainability index metric and the cognitive complexity metric. Combining these two metrics resulted in two general guidelines: if the application is constantly under change and performance is not critical, Go should be the language of choice. If instead performance is critical C++ should be the language of choice. Overall, when choosing a suitable programming language, one needs to weigh development efficiency against performance to make a decision.
APA, Harvard, Vancouver, ISO, and other styles
9

Shear, Raymond F. "Implementation of a Modula 2 subset compiler supporting a "C" language interface using commonly available UNIX tools /." Online version of thesis, 1989. http://hdl.handle.net/1850/10505.

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

Masliah, Ian. "Méthodes de génération automatique de code appliquées à l’algèbre linéaire numérique dans le calcul haute performance." Thesis, Université Paris-Saclay (ComUE), 2016. http://www.theses.fr/2016SACLS285/document.

Full text
Abstract:
Les architectures parallèles sont aujourd'hui présentes dans tous les systèmes informatiques, allant des smartphones aux supercalculateurs en passant par les ordinateurs de bureau. Programmer efficacement ces architectures en fonction des applications requiert un effort pluridisciplinaire portant sur les langages dédiés (Domain Specific Languages - DSL), les techniques de génération de code et d'optimisation, et les algorithmes numériques propres aux applications. Dans cette thèse, nous présentons une méthode de programmation haut niveau prenant en compte les caractéristiques des architectures hétérogènes et les propriétés existantes des matrices pour produire un solveur générique d'algèbre linéaire dense. Notre modèle de programmation supporte les transferts explicites et implicites entre un processeur (CPU) et un processeur graphique qui peut être généraliste (GPU) ou intégré (IGP). Dans la mesure où les GPU sont devenus un outil important pour le calcul haute performance, il est essentiel d'intégrer leur usage dans les plateformes de calcul. Une architecture récente telle que l'IGP requiert des connaissances supplémentaires pour pouvoir être programmée efficacement. Notre méthodologie a pour but de simplifier le développement sur ces architectures parallèles en utilisant des outils de programmation haut niveau. À titre d'exemple, nous avons développé un solveur de moindres carrés en précision mixte basé sur les équations semi-normales qui n'existait pas dans les bibliothèques actuelles. Nous avons par la suite étendu nos travaux à un modèle de programmation multi-étape ("multi-stage") pour résoudre les problèmes d'interopérabilité entre les modèles de programmation CPU et GPU. Nous utilisons cette technique pour générer automatiquement du code pour accélérateur à partir d'un code effectuant des opérations point par point ou utilisant des squelettes algorithmiques. L'approche multi-étape nous assure que le typage du code généré est valide. Nous avons ensuite montré que notre méthode est applicable à d'autres architectures et algorithmes. Les routines développées ont été intégrées dans une bibliothèque de calcul appelée NT2.Enfin, nous montrons comment la programmation haut niveau peut être appliquée à des calculs groupés et des contractions de tenseurs. Tout d'abord, nous expliquons comment concevoir un modèle de container en utilisant des techniques de programmation basées sur le C++ moderne (C++-14). Ensuite, nous avons implémenté un produit de matrices optimisé pour des matrices de petites tailles en utilisant des instructions SIMD. Pour ce faire, nous avons pris en compte les multiples problèmes liés au calcul groupé ainsi que les problèmes de localité mémoire et de vectorisation. En combinant la programmation haut niveau avec des techniques avancées de programmation parallèle, nous montrons qu'il est possible d'obtenir de meilleures performances que celles des bibliothèques numériques actuelles<br>Parallelism in today's computer architectures is ubiquitous whether it be in supercomputers, workstations or on portable devices such as smartphones. Exploiting efficiently these systems for a specific application requires a multidisciplinary effort that concerns Domain Specific Languages (DSL), code generation and optimization techniques and application-specific numerical algorithms. In this PhD thesis, we present a method of high level programming that takes into account the features of heterogenous architectures and the properties of matrices to build a generic dense linear algebra solver. Our programming model supports both implicit or explicit data transfers to and from General-Purpose Graphics Processing Units (GPGPU) and Integrated Graphic Processors (IGPs). As GPUs have become an asset in high performance computing, incorporating their use in general solvers is an important issue. Recent architectures such as IGPs also require further knowledge to program them efficiently. Our methodology aims at simplifying the development on parallel architectures through the use of high level programming techniques. As an example, we developed a least-squares solver based on semi-normal equations in mixed precision that cannot be found in current libraries. This solver achieves similar performance as other mixed-precision algorithms. We extend our approach to a new multistage programming model that alleviates the interoperability problems between the CPU and GPU programming models. Our multistage approach is used to automatically generate GPU code for CPU-based element-wise expressions and parallel skeletons while allowing for type-safe program generation. We illustrate that this work can be applied to recent architectures and algorithms. The resulting code has been incorporated into a C++ library called NT2. Finally, we investigate how to apply high level programming techniques to batched computations and tensor contractions. We start by explaining how to design a simple data container using modern C++14 programming techniques. Then, we study the issues around batched computations, memory locality and code vectorization to implement a highly optimized matrix-matrix product for small sizes using SIMD instructions. By combining a high level programming approach and advanced parallel programming techniques, we show that we can outperform state of the art numerical libraries
APA, Harvard, Vancouver, ISO, and other styles
More sources

Books on the topic "C (programming languages)"

1

Worthington, Steve. C programming. Boyd & Fraser Pub. Co., 1988.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
2

Marc, Liyanage, ed. C programming. Peachpit Press, 2005.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
3

1974-, Signer Andreas, ed. C++ programming. Peachpit Press, 2006.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
4

Mark, Lee. C programming. Global Media, 2007.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
5

Scott, Wiltamuth, and Golde Peter, eds. The C# programming language. 2nd ed. Addison-Wesley, 2006.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
6

Scott, Wiltamuth, and Golde Peter, eds. The C# programming language. Addison-Wesley, 2004.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
7

Programming in ANSI C. Group D Publications, 1993.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
8

Programming in ANSI C. 2nd ed. Group D, 1996.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
9

Lars, Klander, ed. Jamsa's C/C&& programmer's bible: The ultimate guide to C/C&& programming. Jamsa, 1998.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
10

Jamsa, Kris A. Jamsa's C/C++ programmer's bible: The ultimate guide to C/C++ programming. Jamsa Press, 1998.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
More sources

Book chapters on the topic "C (programming languages)"

1

Lee, Kent D. "C++." In Foundations of Programming Languages. Springer International Publishing, 2014. http://dx.doi.org/10.1007/978-3-319-13314-0_4.

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

O’Regan, Gerard. "C and C++ Programming Languages." In The Innovation in Computing Companion. Springer International Publishing, 2018. http://dx.doi.org/10.1007/978-3-030-02619-6_14.

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

de Bayser, Maximilien, and Renato Cerqueira. "A System for Runtime Type Introspection in C++." In Programming Languages. Springer Berlin Heidelberg, 2012. http://dx.doi.org/10.1007/978-3-642-33182-4_9.

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

Kulisch, Urich, Rudi Klatte, Andreas Wiethoff, et al. "The Programming Languages C and C++." In C-XSC. Springer Berlin Heidelberg, 1993. http://dx.doi.org/10.1007/978-3-642-58058-1_2.

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

Stroustrup, Bjarne. "Foundations of C++." In Programming Languages and Systems. Springer Berlin Heidelberg, 2012. http://dx.doi.org/10.1007/978-3-642-28869-2_1.

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

Norrish, Michael. "Deterministic Expressions in C." In Programming Languages and Systems. Springer Berlin Heidelberg, 1999. http://dx.doi.org/10.1007/3-540-49099-x_10.

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

Cahill, Vinny, and Donal Lafferty. "Computers, Programming Languages, and C#." In Learning to Program the Object-oriented Way with C#. Springer London, 2002. http://dx.doi.org/10.1007/978-1-4471-0115-4_2.

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

Leijen, Daan. "Implementing Algebraic Effects in C." In Programming Languages and Systems. Springer International Publishing, 2017. http://dx.doi.org/10.1007/978-3-319-71237-6_17.

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

Craig, Iain. "C#." In The Interpretation of Object-Oriented Programming Languages. Springer London, 2002. http://dx.doi.org/10.1007/978-1-4471-0199-4_9.

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

Beringer, Lennart, Gordon Stewart, Robert Dockins, and Andrew W. Appel. "Verified Compilation for Shared-Memory C." In Programming Languages and Systems. Springer Berlin Heidelberg, 2014. http://dx.doi.org/10.1007/978-3-642-54833-8_7.

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

Conference papers on the topic "C (programming languages)"

1

Lessman, Roger E. "Programming languages, OOP, and C++." In the 28th annual Southeast regional conference. ACM Press, 1990. http://dx.doi.org/10.1145/98949.98981.

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

Cheng, Harry H. "Extending C and FORTRAN for Design Automation." In ASME 1994 Design Technical Conferences collocated with the ASME 1994 International Computers in Engineering Conference and Exhibition and the ASME 1994 8th Annual Database Symposium. American Society of Mechanical Engineers, 1994. http://dx.doi.org/10.1115/detc1994-0051.

Full text
Abstract:
Abstract The CH programming language, a high-performance C, is designed to be a superset of ANSI C. CH bridges the gap between ANSI C and FORTRAN; it encompasses almost all the programming capabilities of FORTRAN 77 in the current implementation and consists of features of many other programming languages and software packages. Unlike other general-purpose programming languages, CH is designed to be especially suitable for applications in mechanical systems engineering. Because of our research interests, many programming features in CH have been implemented for design automation, although they are useful in other applications as well. In this paper we will describe these new programming features for design automation, as they are currently implemented in CH in comparison with ANSI C and FORTRAN 77.
APA, Harvard, Vancouver, ISO, and other styles
3

Dobrescu, L. "Replacing ANSI C with other modern programming languages." In 2014 International Symposium on Fundamentals of Electrical Engineering (ISFEE). IEEE, 2014. http://dx.doi.org/10.1109/isfee.2014.7050621.

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

Nienhuis, Kyndylan, Kayvan Memarian, and Peter Sewell. "An operational semantics for C/C++11 concurrency." In SPLASH '16: Conference on Systems, Programming, Languages, and Applications: Software for Humanity. ACM, 2016. http://dx.doi.org/10.1145/2983990.2983997.

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

Ringert, Jan Oliver, Bernhard Rumpe, and Andreas Wortmann. "Composing code generators for C&C ADLs with Application-specific behavior languages (tool demonstration)." In GPCE'15: Generative Programming: Concepts and Experiences. ACM, 2015. http://dx.doi.org/10.1145/2814204.2814224.

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

Belloch, Jose Antonio, Adrián Castelló, and Sergio Iserte. "Accessible C-programming course from scratch using a MOOC platform without limitations." In Fourth International Conference on Higher Education Advances. Universitat Politècnica València, 2018. http://dx.doi.org/10.4995/head18.2018.8176.

Full text
Abstract:
The C language has been used for ages in the application development in multidisciplinary environments. However, in the academia, this language is being replaced by other higher-level languages due to they are easier to understand, learn and apply. Moreover, the necessity of professionals with a good knowledge in those high-level languages is constantly increasing because of the boosting of mobile devices. This scenario generates a lack of low-level language programmers, required in other less trendy fields, but equal or more important, such as science, engineering or research. In order to revive the interest in low-level languages and provide those minority fields with well-prepared staff, we present in this work a MOCC C-programming course that is addressed to any kind of people with or without IT background. A feature that differentiates this course from others programming online-based courses is that we mainly focus on the C language syntax providing, via a self-tuned virtual machine, an encapsulated environment that hides any interaction with the command-line of the underlying operating system. A secondary target of this work is to foster the computer science degree students to enrol the computer architecture specialization at the Universitat Jaume I (Spain). For this purpose, the High Performance Computing and Architectures research group of that University has decided to use this C course as a tool for fulfill the gap of the current syllabus. The results show that half of the participants that completed the first session of the course have satisfactorily finished the course, and the number of computer science degree students that chose the computer architecture specialization the following academic course was increment by 3x.
APA, Harvard, Vancouver, ISO, and other styles
7

Ou, Peizhao, and Brian Demsky. "AutoMO: automatic inference of memory order parameters for C/C++11." In SPLASH '15: Conference on Systems, Programming, Languages, and Applications: Software for Humanity. ACM, 2015. http://dx.doi.org/10.1145/2814270.2814286.

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

Flur, Shaked, Susmit Sarkar, Christopher Pulte, et al. "Mixed-size concurrency: ARM, POWER, C/C++11, and SC." In POPL '17: The 44th Annual ACM SIGPLAN Symposium on Principles of Programming Languages. ACM, 2017. http://dx.doi.org/10.1145/3009837.3009839.

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

Rigger, Manuel. "Sandboxed execution of C and other unsafe languages on the Java virtual machine." In 2018: 2nd International Conference on the Art, Science, and Engineering of Programming 2018. ACM, 2018. http://dx.doi.org/10.1145/3191697.3213795.

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

Maas, Martin, David G. Andersen, Michael Isard, Mohammad Mahdi Javanmard, Kathryn S. McKinley, and Colin Raffel. "Learning-based Memory Allocation for C++ Server Workloads." In ASPLOS '20: Architectural Support for Programming Languages and Operating Systems. ACM, 2020. http://dx.doi.org/10.1145/3373376.3378525.

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

Reports on the topic "C (programming languages)"

1

Guarna, Vincent A., and Jr. VPC - A Proposal for a Vector Parallel C Programming Language. Defense Technical Information Center, 1987. http://dx.doi.org/10.21236/ada190885.

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

Thomas, Bruce Hunter. A scheme for translating control flow in the C programming language to Grafcet with examples. National Bureau of Standards, 1988. http://dx.doi.org/10.6028/nbs.ir.88-3741.

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

Chalupsky, Hans, and Robert M. MacGregor. STELLA - A Lisp-Like Language for Symbolic Programming with Delivery in Common Lisp, C++, and Java. Defense Technical Information Center, 1999. http://dx.doi.org/10.21236/ada461405.

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

CAMPBELL, PHILIP L. An Implementation of the Berlekamp-Massey Linear Feedback Shift-Register Synthesis Algorithm in the C Programming Language. Office of Scientific and Technical Information (OSTI), 1999. http://dx.doi.org/10.2172/12658.

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

Federal Information Processing Standards Publication: C - software standard, programming language. National Institute of Standards and Technology, 1991. http://dx.doi.org/10.6028/nist.fips.160-1991.

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

Federal Information Processing Standards Publication: for information systems - programming language - C. National Institute of Standards and Technology, 1989. http://dx.doi.org/10.6028/nist.fips.160.

Full text
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'C (programming languages)' for particular source types:
Journal articles Dissertations / Theses Books
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