Littérature scientifique sur le sujet « Code source (informatique) – Documentation »
Créez une référence correcte selon les styles APA, MLA, Chicago, Harvard et plusieurs autres
Sommaire
Consultez les listes thématiques d’articles de revues, de livres, de thèses, de rapports de conférences et d’autres sources académiques sur le sujet « Code source (informatique) – Documentation ».
À côté de chaque source dans la liste de références il y a un bouton « Ajouter à la bibliographie ». Cliquez sur ce bouton, et nous générerons automatiquement la référence bibliographique pour la source choisie selon votre style de citation préféré : APA, MLA, Harvard, Vancouver, Chicago, etc.
Vous pouvez aussi télécharger le texte intégral de la publication scolaire au format pdf et consulter son résumé en ligne lorsque ces informations sont inclues dans les métadonnées.
Articles de revues sur le sujet "Code source (informatique) – Documentation"
Wang 王冰, Bingjie 洁., Joel Leja, Ivo Labbé, Rachel Bezanson, Katherine E. Whitaker, Gabriel Brammer, Lukas J. Furtak et al. « The UNCOVER Survey : A First-look HST+JWST Catalog of Galaxy Redshifts and Stellar Population Properties Spanning 0.2 ≲ z ≲ 15 ». Astrophysical Journal Supplement Series 270, no 1 (28 décembre 2023) : 12. http://dx.doi.org/10.3847/1538-4365/ad0846.
Texte intégralPan, Lu, Huy Q. Dinh, Yudi Pawitan et Trung Nghia Vu. « Isoform-level quantification for single-cell RNA sequencing ». Bioinformatics 38, no 5 (2 décembre 2021) : 1287–94. http://dx.doi.org/10.1093/bioinformatics/btab807.
Texte intégralCouture, Stéphane. « L'écriture collective du code source informatique ». Revue d'anthropologie des connaissances 6, 1, no 1 (2012) : 21. http://dx.doi.org/10.3917/rac.015.0061.
Texte intégralBoumann, K. « Terminologische Databank En Geautomatiseerde Informatie En Documentatie ». Vertalen in theorie en praktijk 21 (1 janvier 1985) : 128–33. http://dx.doi.org/10.1075/ttwia.21.16bou.
Texte intégralAl-Msie'deen, Ra'Fat, et Anas H. Blasi. « Supporting software documentation with source code summarization ». International Journal of ADVANCED AND APPLIED SCIENCES 6, no 1 (janvier 2019) : 59–67. http://dx.doi.org/10.21833/ijaas.2019.01.008.
Texte intégralSulír, Matúš, et Jaroslav Porubän. « Source Code Documentation Generation Using Program Execution ». Information 8, no 4 (17 novembre 2017) : 148. http://dx.doi.org/10.3390/info8040148.
Texte intégralWu, Y. C., et T. P. Baker. « A source code documentation system for Ada ». ACM SIGAda Ada Letters IX, no 5 (juillet 1989) : 84–88. http://dx.doi.org/10.1145/71340.71344.
Texte intégralArthur, Menaka Pushpa. « Automatic Source Code Documentation using Code Summarization Technique of NLP ». Procedia Computer Science 171 (2020) : 2522–31. http://dx.doi.org/10.1016/j.procs.2020.04.273.
Texte intégralCarvalho, Nuno, Alberto Simões et José Almeida. « DMOSS : Open source software documentation assessment ». Computer Science and Information Systems 11, no 4 (2014) : 1197–207. http://dx.doi.org/10.2298/csis131005027c.
Texte intégralWang, April Yi, Dakuo Wang, Jaimie Drozdal, Michael Muller, Soya Park, Justin D. Weisz, Xuye Liu, Lingfei Wu et Casey Dugan. « Documentation Matters : Human-Centered AI System to Assist Data Science Code Documentation in Computational Notebooks ». ACM Transactions on Computer-Human Interaction 29, no 2 (30 avril 2022) : 1–33. http://dx.doi.org/10.1145/3489465.
Texte intégralThèses sur le sujet "Code source (informatique) – Documentation"
Oumaziz, Mohamed Ameziane. « Cloning beyond source code : a study of the practices in API documentation and infrastructure as code ». Thesis, Bordeaux, 2020. http://www.theses.fr/2020BORD0007.
Texte intégralWhen developing a software, maintenance and evolution represents an important part of the development's life-cycle, making up to 80% of the overall cost and effort.During the maintenance effort, it happens that developers have to resort to copying and pasting source code fragments in order to reuse them.Such practice, seemingly harmless is more frequent than we expect.Commonly referred to as ``clones'' in the literature, these source code duplicates are a well-known and studied topic in software engineering.In this thesis, we aim at shedding some light on copy-paste practices on software artifacts. In particular, we chose to focus our contributions on two specific types of software artifacts: API documentation and build files (i.e. Dockerfiles).For both contributions, we follow a common empirical study methodology. First, We show that API documentations and software build files (i.e. Dockerfiles) actually face duplicates issues and that such duplicates are frequent.Secondly, we identify the reasons behind the existence of such duplicates.Thirdly, We perform a survey on experimented developers and find that they're aware of such duplicates, frequently face them. But still have a mixed opinion regarding them.Finally, We show that both software artifacts lack reuse mechanisms to cope with duplicates, and that some developers even resort to ad-hoc tools to manage them
Latappy, Corentin. « Les pratiques de code : de la documentation à la détection ». Electronic Thesis or Diss., Bordeaux, 2024. http://www.theses.fr/2024BORD0101.
Texte intégralCoding practices are increasingly used in the field of software development. Their implementation ensures maintainability, readability, and consistency of the code, which greatly contributes to software quality. Most of these practices are implemented in static analysis tools, or linters, which automatically alert developers when a practice is not followed. However,more and more organizations, tending to create their own internal practices, encounter problems with their understanding and adoption by developers. First, for a practice to be applied, it must first be understood by developers, thus requiring properly written documentation. Yet, this topic of documentation has been little studied in the scientific literature. Then, to promote their adoption, it would be necessary to be able to extend existing analysis tools to integrate new practices, which is difficult given the expertise required to make these modifications. Packmind, a company based in Bordeaux, develops a solution to support developers in bringing out these internal practices through workshops. However, it suffers from the same issues mentioned above. In this thesis, we first focused on providing recommendations to the authors of practice documentation. To do this, we analyzed the documentation of more than 100 rules from 16 different linters to extract a taxonomy of documentation objectives and types of content present. We then conducted a survey among developers to assess their expectations in terms of documentation. This notably allowed us to observe that the reasons why a practice should be applied were very poorly documented, while they are perceived as essential by developers. Secondly, we studied the feasibility of automatically identifying violations of practices from examples. Our context, forcing us to detect internal practices for which we have few examples to learn from, pushed us to implement transfer learning on themachine learning model CodeBERT.We show that the models thus trained achieve good performance in an experimental context, but that accuracy collapseswhenwe apply them to real code bases
Che, Denise. « Automatic documentation generation from source code ». Thesis, Massachusetts Institute of Technology, 2016. http://hdl.handle.net/1721.1/112822.
Texte intégralThis electronic version was submitted by the student author. The certified thesis is available in the Institute Archives and Special Collections.
Cataloged from student-submitted PDF version of thesis.
Includes bibliographical references (page 46).
Many systems lack robust documentation because writing documentation comes at a cost for developers and offers little immediate benefits. To motivate developers to write more documentation, we need a framework that beneficially incorporates documentation into the functionalities of the codebase. We explored this idea in the context of Exhibit, a data publishing framework developed at MIT CSAIL's Haystack group. Exhibit enables those without much programming experience to create data-rich interactive webpages. We created an automatic documentation system with an approach that motives the creation of rich specifications by developers, which leads to good documentation. The code required for documentation benefits developers by simplifying the codebase and providing fault tolerance through a modular error checking mechanism. This system intends to aid new and returning users of Exhibit in learning the Exhibit syntax and in creating their Exhibits by providing extensive, up-to-date documentation for all the available views and facets in Exhibit along with an interactive example component. The interactive example component provides an interface that allows users to experiment with combinations of the different settings and also aids developers during the unit testing process.
by Denise Che.
M. Eng.
Jaeger, Julien. « Source-to-source transformations for irregular and multithreaded code optimization ». Versailles-St Quentin en Yvelines, 2012. http://www.theses.fr/2012VERS0015.
Texte intégralIn this dissertation, we show that source-to-source optimization is an efficient method to generate a high performance program for irregular and heterogeneous code from a basic implementation. After describing the evolution of processor architectures, we provide two methods. The first one extract codelets from an irregular code, optimizing these codelets, and predicting the performance of the modified program. The other one limits the impact of alignment issues due to vectorization or bank conflicts. We also present two parallelization technics, one generating parallel codelets, the other scheduling a task graph on an heterogeneous system
Tévar, Hernández Helena. « Evolution of SoftwareDocumentation Over Time : An analysis of the quality of softwaredocumentation ». Thesis, Linnéuniversitetet, Institutionen för datavetenskap och medieteknik (DM), 2020. http://urn.kb.se/resolve?urn=urn:nbn:se:lnu:diva-97561.
Texte intégralDepaz, Pierre. « The role of aesthetics in understanding source code ». Electronic Thesis or Diss., Paris 3, 2023. http://www.theses.fr/2023PA030084.
Texte intégralThis thesis investigates how the aesthetic properties of source code enable the representation of programmed semantic spaces, in relation with the function and understanding of computer processes. By examining program texts and the discourses around it, we highlight how source code aesthetics are both dependent on the context in which they are written, and contingent to other literary, architectural, and mathematical aesthetics, varying along different scales of reading. Particularly, we show how the aesthetic properties of source code manifest expressive power due to their existence as a dynamic, functional, and shared computational interface to the world, through formal organizations which facilitate semantic compression and spatial exploration
Lebras, Youenn. « Code optimization based on source to source transformations using profile guided metrics ». Thesis, Université Paris-Saclay (ComUE), 2019. http://www.theses.fr/2019SACLV037/document.
Texte intégralOur goal is to develop a framework allowing the definition of source code transformations based on dynamic metrics.This framework be integrated to the MAQAO tool suite developed at the UVSQ / ECR.We present a set of source-to-source transformations guidable by the end user and by the dynamic metrics coming from the various MAQAO tools in order to work at source and binary levels.This framework can also be used as a pre-processor to simplify the development by enabling to perform cleanly and automatically some simple but time-consuming and error-prone transformations (i.e .: loop/function specialization, ...)
Chilowicz, Michel. « Recherche de similarité dans du code source ». Phd thesis, Université Paris-Est, 2010. http://tel.archives-ouvertes.fr/tel-00587628.
Texte intégralHabchi, Sarra. « Understanding mobile-specific code smells ». Thesis, Lille 1, 2019. http://www.theses.fr/2019LIL1I089.
Texte intégralObject-Oriented code smells are well-known concepts in software engineering. They refer to bad design and development practices commonly observed in software systems. With the emergence of mobile apps, new classes of code smells have been identified to refer to bad development practices that are specific to mobile platforms. These mobile-specific code smells differ from object-oriented ones by focusing on performance issues reported in the documentation or developer guidelines. Since their identification, many research works approached mobile-specific code smells to propose detection tools and study them. Nonetheless, most of these studies only focused on measuring the performance impact of such code smells and did not provide any insights about their motives and potential solutions. In particular, we lack knowledge about (i) the rationales behind the accrual of mobile code smells, (ii) the developers’ perception of mobile code smells, and (iii) the generalizability of code smells across different mobile platforms. These lacks hinder the understanding of mobile code smells and consequently prevent the design of adequate solutions for them. Therefore, we conduct in this thesis a series of empirical studies with the aim of understanding mobile code smells. First, we study the expansion of code smells in different mobile platforms. Then, we conduct a large-scale study to analyze the change history of mobile apps and discern the factors that favor the introduction and survival of code smells. To consolidate these studies, we also perform a user study to investigate developers’ perception of code smells and the adequacy of static analyzers as a solution for coping with them. Finally, we perform a qualitative study to question the established foundation about the definition and detection of mobile code smells. The results of these studies revealed important research findings. Notably, we showed that pragmatism, prioritization, and individual attitudes are not relevant factors for the accrual of mobile code smells. The problem is rather caused by ignorance and oversight, which are prevalent among mobile developers. Furthermore, we highlighted several flaws in the code smell definitions that are currently adopted by the research community. These results allowed us to elaborate some recommendations for researchers and tool makers willing to design detection and refactoring tools for mobile code smells. On top of that, our results opened perspectives for research works about the identification of mobile code smells and development practices in general
Chaabane, Rim. « Analyse et optimisation de patterns de code ». Paris 8, 2011. http://www.theses.fr/2011PA084174.
Texte intégralNotre travail consiste en l’analyse et l’optimisation du code source d’applications de type système hérité (ou legacy system). Nous avons particulièrement travaillé sur un logiciel, appelé GP3, qui est développé et maintenu par la société de finances Sungard. Ce logiciel existe depuis plus d’une vingtaine d’années, il est écrit en un langage propriétaire, procédural et de 4ème génération, appelé ADL (ou Application Development Language). Ce logiciel à été initialement développé sous VMS et accédait à des bases de données d’ancienne génération. Pour des raisons commerciales, il fut porté sous UNIX et s’adresse maintenant à des SGBD-R de nouvelles génération ; Oracle et Sybase. Il a également été étendu de manière à offrir une interface web. Ce système hérité doit maintenant faire face à de nouveaux défis, comme la croissance de la taille des bases de données. Durant ces 20 dernières années, nous avons pu observer la fusion de plusieurs entreprises, ce qui implique la fusion de bases de données. Ces dernières peuvent dépasser les 1 Téra de données et plus encore sont à prévoir à l’avenir. Dans ce nouveau contexte, le langage ADL montre des limites à traiter une aussi importante masse de données. Des patterns de code, désignant des structures d’accès en base, sont suspectés d’être responsables de dégradations des performances. Notre travail consiste à détecter toutes les instances de patterns dans le code source, puis d’identifier les instances les plus consommatrices en temps d’exécution et en nombre d’appels. Nous avons développé un premier outil, nommé Adlmap, basé sur l’analyse statique de code, et qui permet de détecter toutes les accès en base dans le code source. Les accès en base identifiés comme patterns de code sont marqués. Le second outil que nous avons développé, nommé Pmonitor, est basé sur une analyse hybride ; combinaison d’analyses statique et dynamique. Cet outil nous permet de mesurer les performances des patterns de code et ainsi, d’identifier les instances les moins performantes
Livres sur le sujet "Code source (informatique) – Documentation"
Robinson, P. The CALIBRE source term code : Technical documentation for Project-90. Stockholm : Swedish Nuclear Power Inspectorate, 1992.
Trouver le texte intégralC/C++ Treasure Chest : A Developer's Resource Kit of C/C++ Tools and Source Code. CMP Books, 1998.
Trouver le texte intégralAda : 1.2 Gigabytes of Compilers, Documentation, Information, and Source Code, This Is a Valuable Resource for Any Ada Programmer. Walnut Creek, 1994.
Trouver le texte intégralCP/M : Over 18000 Files With Executable Programs, Source Code, Documentation and Other Materials for the CP/m Operating System/Cd Rom in Jewel Box. Walnut Creek, 1994.
Trouver le texte intégralChapitres de livres sur le sujet "Code source (informatique) – Documentation"
Pauzi, Zaki, et Andrea Capiluppi. « Text Similarity Between Concepts Extracted from Source Code and Documentation ». Dans Lecture Notes in Computer Science, 124–35. Cham : Springer International Publishing, 2020. http://dx.doi.org/10.1007/978-3-030-62362-3_12.
Texte intégralXiong, Jay. « NSE Documentation Paradigm : Virtual, Traceable, and Consistent with the Source Code ». Dans New Software Engineering Paradigm Based on Complexity Science, 489–515. New York, NY : Springer New York, 2010. http://dx.doi.org/10.1007/978-1-4419-7326-9_19.
Texte intégralNaus, Nico, Freek Verbeek, Dale Walker et Binoy Ravindran. « A Formal Semantics for P-Code ». Dans Lecture Notes in Computer Science, 111–28. Cham : Springer International Publishing, 2023. http://dx.doi.org/10.1007/978-3-031-25803-9_7.
Texte intégralChardigny, Sylvain, et Abdelhak Seriai. « Software Architecture Recovery Process Based on Object-Oriented Source Code and Documentation ». Dans Software Architecture, 409–16. Berlin, Heidelberg : Springer Berlin Heidelberg, 2010. http://dx.doi.org/10.1007/978-3-642-15114-9_35.
Texte intégralSarre, F., A. Myka et U. Güntzer. « Hypertext for Software Engineering : Automatic Conversion of Source Code and its Documentation into an Integrated Hypertext ». Dans Database and Expert Systems Applications, 463–68. Vienna : Springer Vienna, 1992. http://dx.doi.org/10.1007/978-3-7091-7557-6_79.
Texte intégralGravino, Carmine, Michele Risi, Giuseppe Scanniello et Genoveffa Tortora. « Do Professional Developers Benefit from Design Pattern Documentation ? A Replication in the Context of Source Code Comprehension ». Dans Model Driven Engineering Languages and Systems, 185–201. Berlin, Heidelberg : Springer Berlin Heidelberg, 2012. http://dx.doi.org/10.1007/978-3-642-33666-9_13.
Texte intégralSantos, Geanderson, Amanda Santana, Gustavo Vale et Eduardo Figueiredo. « Yet Another Model ! A Study on Model’s Similarities for Defect and Code Smells ». Dans Fundamental Approaches to Software Engineering, 282–305. Cham : Springer Nature Switzerland, 2023. http://dx.doi.org/10.1007/978-3-031-30826-0_16.
Texte intégralSaxena, Gaurav, Miguel Ponce-de-Leon, Arnau Montagud, David Vicente Dorca et Alfonso Valencia. « BioFVM-X : An MPI+OpenMP 3-D Simulator for Biological Systems ». Dans Computational Methods in Systems Biology, 266–79. Cham : Springer International Publishing, 2021. http://dx.doi.org/10.1007/978-3-030-85633-5_18.
Texte intégralHair, Joseph F., G. Tomas M. Hult, Christian M. Ringle, Marko Sarstedt, Nicholas P. Danks et Soumya Ray. « Overview of R and RStudio ». Dans Classroom Companion : Business, 31–47. Cham : Springer International Publishing, 2021. http://dx.doi.org/10.1007/978-3-030-80519-7_2.
Texte intégralBreitmayer, Marius, Lisa Arnold, Stephan La Rocca et Manfred Reichert. « Deriving Event Logs from Legacy Software Systems ». Dans Lecture Notes in Business Information Processing, 409–21. Cham : Springer Nature Switzerland, 2023. http://dx.doi.org/10.1007/978-3-031-27815-0_30.
Texte intégralActes de conférences sur le sujet "Code source (informatique) – Documentation"
Kramer, Douglas. « API documentation from source code comments ». Dans the 17th annual international conference. New York, New York, USA : ACM Press, 1999. http://dx.doi.org/10.1145/318372.318577.
Texte intégralMcBurney, Paul W. « Automatic Documentation Generation via Source Code Summarization ». Dans 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering (ICSE). IEEE, 2015. http://dx.doi.org/10.1109/icse.2015.288.
Texte intégralXiaofan Chen, J. Hosking et J. Grundy. « Visualizing traceability links between source code and documentation ». Dans 2012 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC 2012). IEEE, 2012. http://dx.doi.org/10.1109/vlhcc.2012.6344496.
Texte intégralLiu, Mingwei, Xin Peng, Xiujie Meng, Huanjun Xu, Shuangshuang Xing, Xin Wang, Yang Liu et Gang Lv. « Source Code based On-demand Class Documentation Generation ». Dans 2020 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE, 2020. http://dx.doi.org/10.1109/icsme46990.2020.00114.
Texte intégralDurelli, Rafael S., Vinicius H. S. Durelli, Raphael W. Bettio, Diego R. C. Dias et Alfredo Goldman. « Divinator : A Visual Studio Code Extension to Source Code Summarization ». Dans Workshop de Visualização, Evolução e Manutenção de Software. Sociedade Brasileira de Computação - SBC, 2022. http://dx.doi.org/10.5753/vem.2022.226187.
Texte intégralMoser, Michael, et Josef Pichler. « Documentation generation from annotated source code of scientific software ». Dans ICSE '16 : 38th International Conference on Software Engineering. New York, NY, USA : ACM, 2016. http://dx.doi.org/10.1145/2897676.2897679.
Texte intégralFavre, Jean-Marie, Ralf Lammel, Martin Leinberger, Thomas Schmorleiz et Andrei Varanovich. « Linking Documentation and Source Code in a Software Chrestomathy ». Dans 2012 19th Working Conference on Reverse Engineering (WCRE). IEEE, 2012. http://dx.doi.org/10.1109/wcre.2012.43.
Texte intégralRebai, Soumaya, Oussama Ben Sghaier, Vahid Alizadeh, Marouane Kessentini et Meriem Chater. « Interactive Refactoring Documentation Bot ». Dans 2019 IEEE 19th International Working Conference on Source Code Analysis and Manipulation (SCAM). IEEE, 2019. http://dx.doi.org/10.1109/scam.2019.00026.
Texte intégralMcBurney, Paul W., et Collin McMillan. « Automatic documentation generation via source code summarization of method context ». Dans the 22nd International Conference. New York, New York, USA : ACM Press, 2014. http://dx.doi.org/10.1145/2597008.2597149.
Texte intégralMcMillan, Collin, Denys Poshyvanyk et Mark Grechanik. « Recommending source code examples via API call usages and documentation ». Dans the 2nd International Workshop. New York, New York, USA : ACM Press, 2010. http://dx.doi.org/10.1145/1808920.1808925.
Texte intégralRapports d'organisations sur le sujet "Code source (informatique) – Documentation"
Gropp, W. Users manual for doctext : Producing documentation from C source code. Office of Scientific and Technical Information (OSTI), mars 1995. http://dx.doi.org/10.2172/70803.
Texte intégral