Relevant bibliographies by topics / Low-code programming

Contents

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

Academic literature on the topic 'Low-code programming'

Author: Grafiati
Published: 24 June 2021
Last updated: 15 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 'Low-code 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 "Low-code programming"

1

Luong, Tran Thanh, and Le My Canh. "JAVASCRIPT ASYNCHRONOUS PROGRAMMING." Hue University Journal of Science: Techniques and Technology 128, no. 2B (July 16, 2019): 5–16. http://dx.doi.org/10.26459/hueuni-jtt.v128i2b.5104.

Full text
Abstract:
JavaScript has become more and more popular in recent years because its wealthy features as being dynamic, interpreted and object-oriented with first-class functions. Furthermore, JavaScript is designed with event-driven and I/O non-blocking model that boosts the performance of overall application especially in the case of Node.js. To take advantage of these characteristics, many design patterns that implement asynchronous programming for JavaScript were proposed. However, choosing a right pattern and implementing a good asynchronous source code is a challenge and thus easily lead into less robust application and low quality source code. Extended from our previous works on exception handling code smells in JavaScript and exception handling code smells in JavaScript asynchronous programming with promise, this research aims at studying the impact of three JavaScript asynchronous programming patterns on quality of source code and application.
APA, Harvard, Vancouver, ISO, and other styles
2

Vazquez-Vilar, Marta, Diego Orzaez, and Nicola Patron. "DNA assembly standards: Setting the low-level programming code for plant biotechnology." Plant Science 273 (August 2018): 33–41. http://dx.doi.org/10.1016/j.plantsci.2018.02.024.

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

Rabbani, Faqih Salban, and Oscar Karnalim. "Detecting Source Code Plagiarism on .NET Programming Languages using Low-level Representation and Adaptive Local Alignment." Journal of information and organizational sciences 41, no. 1 (June 16, 2017): 105–23. http://dx.doi.org/10.31341/jios.41.1.7.

Full text
Abstract:
Even though there are various source code plagiarism detection approaches, only a few works which are focused on low-level representation for deducting similarity. Most of them are only focused on lexical token sequence extracted from source code. In our point of view, low-level representation is more beneficial than lexical token since its form is more compact than the source code itself. It only considers semantic-preserving instructions and ignores many source code delimiter tokens. This paper proposes a source code plagiarism detection which rely on low-level representation. For a case study, we focus our work on .NET programming languages with Common Intermediate Language as its low-level representation. In addition, we also incorporate Adaptive Local Alignment for detecting similarity. According to Lim et al, this algorithm outperforms code similarity state-of-the-art algorithm (i.e. Greedy String Tiling) in term of effectiveness. According to our evaluation which involves various plagiarism attacks, our approach is more effective and efficient when compared with standard lexical-token approach. 
APA, Harvard, Vancouver, ISO, and other styles
4

Wang, Zheng Dong, Kai He, Hai Tao Fang, and Ru Xu Du. "Design of Embedded Controller with Flexible Programming for Industrial Robot." Applied Mechanics and Materials 457-458 (October 2013): 1390–95. http://dx.doi.org/10.4028/www.scientific.net/amm.457-458.1390.

Full text
Abstract:
This paper presents an embedded controller of low cost and high performance for industrial robot. The ARM microprocessor is chosen as the main controller for the processor. Based on the 7-segment cubic spline interpolation algorithm, a real-time control for the robot is implemented. This proposed trajectory method can perfectly generates speed S-curve shape for a start-stop process of the robot. In this article a programming language, G-code, is developped for the robots motion control by using the editing interface we designed specially on PC platform. With all the features for 2-4 degree of freedom robot application, the editing interface has been developed for editing and compiling G-code, which can be downloaded into the microprocessor with the custom communication protocol through communication interface. The programming method of the G-code language is easy to learn and use for the non-professional users. The paper describes the design and implementation in detail for the controller, which was validated on our designed SCARA robot, and it worked reliably.
APA, Harvard, Vancouver, ISO, and other styles
5

De Pra, Yuri, and Federico Fontana. "Programming Real-Time Sound in Python." Applied Sciences 10, no. 12 (June 19, 2020): 4214. http://dx.doi.org/10.3390/app10124214.

Full text
Abstract:
For its versatility, Python has become one of the most popular programming languages. In spite of its possibility to straightforwardly link native code with powerful libraries for scientific computing, the use of Python for real-time sound applications development is often neglected in favor of alternative programming languages, which are tailored to the digital music domain. This article introduces Python as a real-time software programming tool to interested readers, including Python developers who are new to the real time or, conversely, sound programmers who have not yet taken this language into consideration. Cython and Numba are proposed as libraries supporting agile development of efficient software running at machine level. Moreover, it is shown that refactoring few critical parts of the program under these libraries can dramatically improve the performances of a sound algorithm. Such improvements can be directly benchmarked within Python, thanks to the existence of appropriate code parsing resources. After introducing a simple sound processing example, two algorithms that are known from the literature are coded to show how Python can be effectively employed to program sound software. Finally, issues of efficiency are mainly discussed in terms of latency of the resulting applications. Overall, such issues suggest that the use of real-time Python should be limited to the prototyping phase, where the benefits of language flexibility prevail on low latency requirements, for instance, needed during computer music live performances.
APA, Harvard, Vancouver, ISO, and other styles
6

Sandewall, Eric. "Knowledge-based systems, Lisp, and very high level implementation languages." Knowledge Engineering Review 7, no. 2 (June 1992): 147–55. http://dx.doi.org/10.1017/s0269888900006263.

Full text
Abstract:
AbstractIt is usually agreed that programming languages for implementing (other) programming languages, or ‘implementation languages’, should be simple low-level languages which are close to the machine code and to the operating system. In this paper it is argued that a very high level implementation language is a good idea, of particular importance for knowledge-based systems, and that Lisp (as a language and as a system) is very well suited to be a very high level implementation language. The significance of special-purpose programming languages is also discussed, and the requirements that they have for a very high level implementation language are considered.
APA, Harvard, Vancouver, ISO, and other styles
7

Bhatt, Sandeep, Marina Chen, James Cowie, Cheng-Yee Lin, and Pangfeng Liu. "Object-Oriented Support for Adaptive Methods on Paranel Machines." Scientific Programming 2, no. 4 (1993): 179–92. http://dx.doi.org/10.1155/1993/474972.

Full text
Abstract:
This article reports on experiments from our ongoing project whose goal is to develop a C++ library which supports adaptive and irregular data structures on distributed memory supercomputers. We demonstrate the use of our abstractions in implementing "tree codes" for large-scale N-body simulations. These algorithms require dynamically evolving treelike data structures, as well as load-balancing, both of which are widely believed to make the application difficult and cumbersome to program for distributed-memory machines. The ease of writing the application code on top of our C++ library abstractions (which themselves are application independent), and the low overhead of the resulting C++ code (over hand-crafted C code) supports our belief that object-oriented approaches are eminently suited to programming distributed-memory machines in a manner that (to the applications programmer) is architecture-independent. Our contribution in parallel programming methodology is to identify and encapsulate general classes of communication and load-balancing strategies useful across applications and MIMD architectures. This article reports experimental results from simulations of half a million particles using multiple methods.
APA, Harvard, Vancouver, ISO, and other styles
8

Yang, Chang, Hao Li, Peng Gao, and Rong Chun Zhang. "Research on the 3-D Scene Quick Build Method of Virtual City and Implementation Method of Basic GIS Function." Applied Mechanics and Materials 580-583 (July 2014): 2760–64. http://dx.doi.org/10.4028/www.scientific.net/amm.580-583.2760.

Full text
Abstract:
<span><span lang="EN-US">Aiming at the common problems of virtual city modeling,such as low efficiency and large amount of data</span><span lang="EN-US">，</span><span lang="EN-US">this paper proposes a quick method to build a virtual city.The method realizes data read automatically through AutoCAD VBA programming, generated the VRML code automatically, buildthree-dimensional scene by the VRML code integration and realize the Web publishing of virual city via Web.</span>
APA, Harvard, Vancouver, ISO, and other styles
9

Patnaik, Archana, and Neelamdhab Padhy. "A Hybrid Approach to Identify Code Smell Using Machine Learning Algorithms." International Journal of Open Source Software and Processes 12, no. 2 (April 2021): 21–35. http://dx.doi.org/10.4018/ijossp.2021040102.

Full text
Abstract:
Code smell aims to identify bugs that occurred during software development. It is the task of identifying design problems. The significant causes of code smell are complexity in code, violation of programming rules, low modelling, and lack of unit-level testing by the developer. Different open source systems like JEdit, Eclipse, and ArgoUML are evaluated in this work. After collecting the data, the best features are selected using recursive feature elimination (RFE). In this paper, the authors have used different anomaly detection algorithms for efficient recognition of dirty code. The average accuracy value of k-means, GMM, autoencoder, PCA, and Bayesian networks is 98%, 94%, 96%, 89%, and 93%. The k-means clustering algorithm is the most suitable algorithm for code detection. Experimentally, the authors proved that ArgoUML project is having better performance as compared to Eclipse and JEdit projects.
APA, Harvard, Vancouver, ISO, and other styles
10

Alshaye, Ibrahim Abdullah, Nurul Farhana Jumaat, and Zaidatun Tasir. "Programming Skills and the Relation in Fostering Students’ Higher Order Thinking." Asian Social Science 14, no. 11 (October 22, 2018): 76. http://dx.doi.org/10.5539/ass.v14n11p76.

Full text
Abstract:
Programming skills (PS) refer to coding and debugging that are required for those who write a program in any programming language. Coding can be described as the implementation aspect of programming, whereas debugging can broadly be defined as fixing any incorrect code that is found after running the programming test. Higher-order thinking skills (HOTs) refer to the top three levels of Bloom&rsquo;s taxonomy which are Analysis, Synthesis, and Evaluation. This study aims to determine the relationship between PS and HOTs among secondary students. Many studies indicate that students who attend programming courses for first time have low levels of performance in PS. Coding and debugging skills reflect higher-order thinking levels. Therefore, an objective of this study was to investigate the effect of coding and debugging skills on their HOTs. The benefits of having PS among learners are that they are able to achieve HOTs. Indeed, these relationships may be explained by programmers need to apply all these HOTs throughout the three phases of the programming process. Students who have low levels of PS are able to achieve the analysis level, while students who have moderate levels of PS able to achieve the synthesis level, and finally, students with high levels of PS are able to achieve the evaluation level.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "Low-code programming"

1

Bäckström, Madeleine, and Nicklas Silversved. "Digitalizing the workplace: improving internal processes using digital services : A process improvement by digitalization, emphasizing chosen quality factors." Thesis, Linköpings universitet, Institutionen för datavetenskap, 2021. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-177003.

Full text
Abstract:
In recent years, the number of digital services and tools available has increased rapidly. When companies want to digitalize their business, they have the opportunity to browse a large number of existing platforms and applications available on the market to find a good match for their specific needs. However, when a company wishes to digitalize a work task that already has a well-established workflow, problems may arise. Due to this, a tailored digital solution may in some cases be the better suited option, rather than the ones available on the market.  The intention of this work was to investigate the challenges that companies face in relation to digitalization of the workplace in general, and the challenges of a company’s expense management process in particular. As an example of how a workplace digitalization can take place, a collaboration with a forest industry company was conducted. An evaluation of their analog and internal expense management process was done, where the found challenges were assessed with respect to chosen quality factors. The evaluation and the found challenges regarding digitalization constituted the basis for a process mapping and a digital solution aiming to improve the company’s expense management process. The resulting work emphasizes how a digital solution can be tailored with simple means within a limited time frame, taking specific needs and existing challenges into account in order to digitalize the workplace. In addition, the work presents what challenges that exists within the concept of digitalizing the workplace and regarding expense management, and how quality factors can be used in combination with a process improvement in order to relieve and eliminate them.
APA, Harvard, Vancouver, ISO, and other styles
2

Ferreira, António Simões. "Integration of Visual Languages with SCS tools in the Software Development Industry." Master's thesis, 2019. http://hdl.handle.net/10362/92285.

Full text
Abstract:
Source Control Systems (SCS), also known as Version Control Systems (VCS), help teams to organize and track changes in the software development process. These systems have become vital in the software development industry as the increased growth and geographical diversity of teams, forced them to find solutions to deal with multiple people accessing the same pieces of software concurrently. Although for a while SCS seemed to be coping well with the needs of software development, the rise of the low-code platforms and Visual Programming Languages (VPLs) brought a new challenge to version control: how to manage visual artifacts without losing SCS functionalities? The biggest cause of this challenge is the fact that SCS are mostly oriented to work with text-based programming languages. Thus text-oriented SCS are (in general) incapable of dealing with visual artifacts as well as they do with text. So, to cope with the loss of SCS functionalities in VPLs projects, teams either accept and work with this loss or are forced to come up with a solution of their own to tackle a specific version control problem. These issues can be found in the OutSystems platform, which is our case study. To solve this problem, we propose a system, termed OSGit, that acts as a man-in-themiddle between the low-code platform and the designated SCS. The proposed system will translate the requested version control operations from the low-code platform to native operations of the given SCS. In operations that require visual artifacts to be managed - like applying blames - we propose the creation of metadata files. The metadata files contain the needed information about the visual elements used to build applications in the lowcode platform. This information is thus a compacted representation of the visual elements through text. Therefore, using metadata files will allow the SCS to correctly handle the required visual artifacts while integrating this system with a low-code platform or a VPL. The produced system obtained auspicious results in the usability tests that were performed and that featured ten OutSystems developers. They showed great satisfaction when using OSGit and also gave suggestions for future improvements. OSGit bridges the gap between text-based SCS and visual artifacts, which proves the possibility of integrating these systems in the world of VPL with a high-level of user satisfaction.
APA, Harvard, Vancouver, ISO, and other styles
3

Gonçalves, João Ricardo Alpoim. "A model for widget composition in the OutSystems Platform." Master's thesis, 2019. http://hdl.handle.net/10362/125332.

Full text
Abstract:
Developers use visual programming languages for faster development of user interfaces due to better ease of use, readability, component reusability – widgets –, and an instant preview of the desired effects. However, the most common composition models to form user interfaces are black-box: combine existing widgets to form new widgets, but generally do not allow indiscriminate modification of their internal components. The OutSystems platform provides a What You See Is What You Get (WYSIWYG) experience where developers can build user interfaces by assembling user interface elements from predefined building blocks: the more fundamental and native components (widgets) represent HTML elements, and custom-made building blocks (web blocks) represent reusable compositions. However, web blocks and widgets are not uniform. Currently, through some workarounds, creators can define compositions that, after instantiated, their inside components can be customizable by other developers, but they either do not follow OutSystems’ good practices for creating web applications, do not show the user’s customizations – no preview –, or need expertise that citizen developers do not have. Our objectives with this work are to develop a new composition model for user interface components that allows to customize the properties of the inner elements of reusable compositions at the places where they are instantiated, integrate the model with the platform in a visual and interactive way where creators can control what can be modified, and users can customize respectively while getting a consistent preview. Reusable compositions in the OutSystems language are unique and static. Thus, for developers to be able to change internal components of a composition and get a preview of that change, the underlying models must explicitly receive and transmit properties of the components internal state to the composition elements. The work was validated by usability testing and by comparison between our solution with widgets that are specialized by OutSystems for specific use cases. The new presented approach is faster and more intuitive to use than what is currently offered by OutSystems. We also observed it works best in tandem with mechanisms already in place (e.g., input parameters) to offer more complete reusable compositions. In the end, all objectives were met, providing a working solution which enables users to customize their or other’s web blocks. With this work, reusable composition creators and users will get more control, customization possibilities, and user experience more intuitive, increasing productivity and user satisfaction.
Os programadores usam linguagens de programação visual para um desenvolvimento mais rápido das interfaces de utilizador devido à maior facilidade de uso, legibilidade, reutilização de componentes – widgets – e uma visualização instantânea dos efeitos desejados. No entanto, os modelos de composição mais comuns para formar interfaces de utilizador são black-box: combinam os widgets existentes para formar novos widgets, mas geralmente não permitem modificações indiscriminadas dos seus componentes internos. A plataforma OutSystems fornece uma experiência What You See Is What You Get (WYSIWYG), na qual os programadores podem criar interfaces de utilizador ao montar elementos da interface de utilizador a partir de blocos de construção predefinidos: os componentes mais básicos e nativos (widgets) representam elementos HTML e blocos de construção personalizados (web blocks) representam composições reutilizáveis. No entanto, web blocks e widgets não são uniformes. Atualmente, por meio de soluções alternativas, os criadores podem definir composições que, após instanciadas, os componentes internos podem ser customizados por outros programadores, mas estas não seguem as boas práticas da OutSystems para criar aplicações Web, não mostram as customizações do utilizador – sem preview –, ou são necessários conhecimentos que os programadores podem não possuem. Os nossos objetivos com este trabalho são desenvolver um novo modelo de composição para componentes da interfaces de utilizador que permita customizar as propriedades dos elementos internos das composições reutilizáveis nos locais em que são instanciadas, integrar o modelo à plataforma de maneira visual e interativa, onde os criadores podem controlar o que pode ser modificado e os utilizadores podem customizar respectivamente enquanto obtêm uma visualização consistente. As composições reutilizáveis na linguagem OutSystems são únicas e estáticas. Assim, para que os programadores possam alterar os componentes internos de uma composição e obter um preview dessa alteração, os modelos subjacentes devem receber e transmitir explicitamente propriedades do estado interno dos componentes para os elementos da composição. O trabalho foi validado através de testes de usabilidade e comparação entre a nossa solução e com widgets especializados pela OutSystems para casos de uso específicos. A nova abordagem apresentada é mais rápida e mais intuitiva para usar do que o modelo de composição que é atualmente oferecido pela OutSystems. Também observámos que é mais eficiente usar em conjunto com os mecanismos já existentes (e.g., parâmetros de entrada) para oferecer composições reutilizáveis mais completas. No final, todos os objetivos foram alcançados, fornecendo uma solução funcional que permite aos utilizadores customizar os seus web blocks ou os de outros. Com este trabalho criadores e utilizadores de composições reutilizáveis terão mais controlo, possibilidades de customização e experiência do utilizador mais intuitiva, aumentando a produtividade e a satisfação do programador
APA, Harvard, Vancouver, ISO, and other styles

Books on the topic "Low-code programming"

1

Write Great Code: Thinking Low-Level, Writing High-Level. San Francisco, CA: No Starch Press, 2004.

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

Othmer, Konstantin. Debugging Macintosh software with MacsBug: Includes MacsBug 6.2 on disk. Reading, Mass: Addison-Wesley, 1991.

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

Hyde, Randall. Write Great Code: Thinking Low-Level, Writing High-Level. No Starch Press, 2006.

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

Hyde, Randall. Write Great Code: Thinking Low-Level, Writing High-Level. 2nd ed. No Starch Press, Incorporated, 2020.

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

Write Great Code: Thinking Low-Level, Writing High-Level. No Starch Press, 2012.

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

Metcalf, Michael, John Reid, and Malcolm Cohen. Fortran 2018 enhancements to interoperability with C. Oxford University Press, 2018. http://dx.doi.org/10.1093/oso/9780198811893.003.0021.

Full text
Abstract:
Some Fortran features were not available when interoperating with C; in particular, • optional dummy arguments, • assumed-length character dummy arguments, • assumed-shape arrays, • allocatable dummy arguments, and •pointer dummy arguments. Also, the frequent need to pass C pointers for low-level operations can lead to ugly code that is difficult to understand. Fortran 2018 addresses all of these issues. For optional arguments there are already widespread C programming idioms that can be followed, and so this is the simplest deficiency to correct. For all the other advanced Fortran features, the necessary information that needs to be passed to/from the C functions is passed with a C descriptor, and there are mechanisms provided for the C functions to use such descriptors. For more convenient low-level C interoperability, assumed-type dummy arguments are available. Additionally, the new assumed-rank feature can also be used in interoperable procedures.
APA, Harvard, Vancouver, ISO, and other styles

Book chapters on the topic "Low-code programming"

1

Morrisett, Greg. "Achieving Type Safety for Low-Level Code." In Logic Programming, 1–2. Berlin, Heidelberg: Springer Berlin Heidelberg, 2003. http://dx.doi.org/10.1007/978-3-540-24599-5_1.

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

Katsumata, Shin-ya, and Atsushi Ohori. "Proof-Directed De-compilation of Low-Level Code." In Programming Languages and Systems, 352–66. Berlin, Heidelberg: Springer Berlin Heidelberg, 2001. http://dx.doi.org/10.1007/3-540-45309-1_23.

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

Debray, Saumya K., Koen De Bosschere, and David Gudeman. "Call Forwarding: A Simple Low-Level Code Optimization Technique." In Implementations of Logic Programming Systems, 77–88. Boston, MA: Springer US, 1994. http://dx.doi.org/10.1007/978-1-4615-2690-2_6.

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

Navas, Jorge A., Peter Schachte, Harald Søndergaard, and Peter J. Stuckey. "Signedness-Agnostic Program Analysis: Precise Integer Bounds for Low-Level Code." In Programming Languages and Systems, 115–30. Berlin, Heidelberg: Springer Berlin Heidelberg, 2012. http://dx.doi.org/10.1007/978-3-642-35182-2_9.

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

Okur, Semih, Cansu Erdogan, and Danny Dig. "Converting Parallel Code from Low-Level Abstractions to Higher-Level Abstractions." In ECOOP 2014 – Object-Oriented Programming, 515–40. Berlin, Heidelberg: Springer Berlin Heidelberg, 2014. http://dx.doi.org/10.1007/978-3-662-44202-9_21.

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

Morrisett, Greg. "Achieving Type Safety for Low-Level Code." In Advances in Computing Science – ASIAN 2003. Progamming Languages and Distributed Computation Programming Languages and Distributed Computation, 1–2. Berlin, Heidelberg: Springer Berlin Heidelberg, 2003. http://dx.doi.org/10.1007/978-3-540-40965-6_1.

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

Adorni, Giovanni, Stefano Cagnoni, Marco Gori, and Monica Mordonini. "Efficient Low-resolution Character Recognition Using Sub-machine-code Genetic Programming." In Soft Computing Applications, 35–46. Heidelberg: Physica-Verlag HD, 2003. http://dx.doi.org/10.1007/978-3-7908-1768-3_4.

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

Adrian, Benjamin, Sven Hinrichsen, and Alexander Nikolenko. "App Development via Low-Code Programming as Part of Modern Industrial Engineering Education." In Advances in Intelligent Systems and Computing, 45–51. Cham: Springer International Publishing, 2020. http://dx.doi.org/10.1007/978-3-030-51369-6_7.

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

Lebens, Mary, and Roger Finnegan. "Using a Low Code Development Environment to Teach the Agile Methodology." In Lecture Notes in Business Information Processing, 191–99. Cham: Springer International Publishing, 2021. http://dx.doi.org/10.1007/978-3-030-78098-2_12.

Full text
Abstract:
AbstractThe Agile development methodology is soaring in popularity in the business world. Companies are turning to Agile to develop products quickly and to achieve digital transformation of their organization. Because of this push, companies need employees who understand Agile. Therefore, higher education is obligated to provide an understanding of Agile to students as they enter the workplace. Providing Agile experience to students who are new to programming is difficult because they are so worried about the coding aspects of the assignment, they cannot take time to think about the methodology they are using. The coding crowds out the time needed to get an understanding of how Agile actually works. One remedy for this is to use a low or no-code development platform. With this type of platform students spend less time learning to create apps, freeing them to experience the rituals and roles of Agile. This study examines using the Agile methodology along with the Microsoft Power Apps platform to provide an Agile experience to students. Two course sections were surveyed to learn if students perceived that they acquired a better understanding of Agile and to learn their perceptions of a no-code platform experience. The students completed surveys to ascertain their comfort with the Agile methodology and whether the no-code environment increased their comfort level. The results showed students perceived the no-code platform increased their comfort with using the Agile methodology. The implication is that no-code platforms can be used broadly to help students to gain experience with Agile.
APA, Harvard, Vancouver, ISO, and other styles
10

Zhirkov, Igor. "Code Structure." In Low-Level Programming, 181–200. Berkeley, CA: Apress, 2017. http://dx.doi.org/10.1007/978-1-4842-2403-8_10.

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

Conference papers on the topic "Low-code programming"

1

Takashima, Naoki, Hiroki Sakamoto, and Yukiyoshi Kameyama. "Generate and offshore: type-safe and modular code generation for low-level optimization." In ICFP'15: 20th ACM SIGPLAN International Conference on Functional Programming. New York, NY, USA: ACM, 2015. http://dx.doi.org/10.1145/2808091.2808096.

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

Baggia, Alenka, Robert Leskovar, and Blaž Rodič. "LOW CODE PROGRAMMING WITH ORACLE APEX OFFERS NEW OPPORTUNITIES IN HIGHER EDUCATION." In Third International Scientific Conference ITEMA Recent Advances in Information Technology, Tourism, Economics, Management and Agriculture. Association of Economists and Managers of the Balkans, Belgrade, Serbia, 2019. http://dx.doi.org/10.31410/itema.s.p.2019.91.

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

Nikula, Uolevi, Jorma Sajaniemi, Matti Tedre, and Stuart Wray. "Python and Roles of Variables in Introductory Programming: Experiences from Three Educational Institutions." In InSITE 2007: Informing Science + IT Education Conference. Informing Science Institute, 2007. http://dx.doi.org/10.28945/3097.

Full text
Abstract:
Students often find that learning to program is hard. Introductory programming courses have high drop-out rates and students do not learn to program well. This paper presents experiences from three educational institutions where introductory programming courses were improved by adopting Python as the first programming language and roles of variables as an aid in understanding program behavior. As a result of these changes, students were able to write working code from the very beginning, they found programming easy and interesting, they passed exams with good grades, and drop-out rates were low. Students became interested in programming and some of them even changed their personal study plan to include more of programming and computer science.
APA, Harvard, Vancouver, ISO, and other styles
4

G. Cardoso, Victor, Jessica T. Barros, Renata T. Tavares, and Pedro M. G. del Foyo. "A Closed Design Cycle To Embedded Low-Cost Automation Based In Micro-Controllers." In Congresso Brasileiro de Automática - 2020. sbabra, 2020. http://dx.doi.org/10.48011/asba.v2i1.1267.

Full text
Abstract:
In this paper a Discrete Event Systems approach is used to design embedded systems, implemented using a commercial low-cost platform based on a single-board micro-controller. The approach uses Time Petri Nets (TPN) to build the system model and a model-checking tool to perform the formal verication and to support the embedded system code generation. The method was applied to design an automated sorting machine using the Arduino platform as programming device.
APA, Harvard, Vancouver, ISO, and other styles
5

Li, Zijian, Rakesh G. D. Jeyasingh, Jaeho Lee, Mehdi Asheghi, H. S. Philip Wong, and Kenneth E. Goodson. "Electrothermal Modeling and Design Strategies for Multibit Phase Change Memory." In ASME 2012 Third International Conference on Micro/Nanoscale Heat and Mass Transfer. American Society of Mechanical Engineers, 2012. http://dx.doi.org/10.1115/mnhmt2012-75129.

Full text
Abstract:
Electrothermal transport and crystallization dynamics govern the speed and reliability of multibit phase change memory (PCM). This work develops a transient simulation code incorporating the nanoscale electrical, thermal, and crystalline growth models to investigate various cell structures and programming strategies. The simulation evaluates the multibit performances of two standard PCM structures, the “mushroom” cell and the “confined pillar” cell, with feature sizes smaller than 40nm. This paper implements the simulation code to explore a more compact and reliable architecture, the stacked vertical cell, for precise control of the Joule heating and the intermediate resistance states. For an electrode area of 10nm × 20nm, very low programming current of 60μA – 90μA generates sufficient heating power to amorphize the phase change elements sequentially, resulting four distinct resistance levels for multibit applications.
APA, Harvard, Vancouver, ISO, and other styles
6

Small, Evan, Sadegh M. Sadeghipour, and Mehdi Asheghi. "Numerical Modeling of Heat Transfer and Phase Transition in Programming the Ovonic Unified Memory Cells." In ASME 2005 Pacific Rim Technical Conference and Exhibition on Integration and Packaging of MEMS, NEMS, and Electronic Systems collocated with the ASME 2005 Heat Transfer Summer Conference. ASMEDC, 2005. http://dx.doi.org/10.1115/ipack2005-73188.

Full text
Abstract:
An Ovonic Unified Memory (OUM) cell is a semiconductor device that stores data by a thermally induced phase transition between polycrystalline (set) and amorphous (reset) states in a thin film of chalcogenide alloy. The small volume of active media acts as a programmable resistor switching between a high (amorphous) and low (crystalline) resistance state. The change in the film resistivity (>40X dynamic range) caused by this rapid, reversible structural change is measured to detect the state of the cell (set or reset) for read out. OUM can benefit from a simulator capable of predicting the electrical, thermal, and crystallization behavior for design and optimization, particularly at the present stage of the development. This paper reports on the efforts being made to prepare such a numerical simulator, using an existing finite element computer code as the source for thermal and electrical modeling, and a custom crystallization code for phase prediction. Heat generation in the device is by Joule heating and is achieved by passage of the electric current, which is obtained from the electrical simulation. This result appears in the heat source term of the heat transfer equation that is solved for thermal modeling. As the first attempt the Ohmic current-voltage relation was implemented successfully to simulate set and reset in a two dimensional model of OUM. Solution of the drift-diffusion equation is now underway to capture the semiconductor behavior of the I-V curve. A good progress is made however, still more works needs to be done to fully implement the drift diffusion equation.
APA, Harvard, Vancouver, ISO, and other styles
7

Shah, Aditya A., Christiaan J. J. Paredis, Roger Burkhart, and Dirk Schaefer. "Combining Mathematical Programming and SysML for Automated Component Sizing of Hydraulic Systems." In ASME 2010 International Design Engineering Technical Conferences and Computers and Information in Engineering Conference. ASMEDC, 2010. http://dx.doi.org/10.1115/detc2010-28960.

Full text
Abstract:
In this paper, we present a framework that improves a designer’s capability to determine near-optimal sizes of components for a given system architecture. Component sizing is a hard problem to solve because of competing objectives, requirements from multiple disciplines, and the need for finding a solution quickly for the architecture being considered. In current approaches, designers rely on heuristics and iterate over the multiple objectives and requirements until a satisfactory solution is found. To improve on this state of practice, we introduce advances in the following two areas: a) Formulating a component sizing problem in a manner that is convenient to designers and b) Solving the problem efficiently so that all of the imposed requirements are satisfied simultaneously and the solution obtained is mathematically optimal. An acausal, algebraic, equation-based, declarative modeling approach using mathematical programming (GAMS) is taken to solve these problems more efficiently. In addition the Systems Modeling Language (OMG SysML™) is used to formulate component sizing problems to facilitate problem formulation, model reuse and the automatic generation of low-level code that can be solved using GAMS and its solvers (BARON). This framework is demonstrated by applying it to an example of a hydraulic log splitter.
APA, Harvard, Vancouver, ISO, and other styles
8

Pramuanjaroenkij, Anchasa, Amarin Tongkratoke, and Sadık Kakaç. "Numerical Study of Turbulence Nanofluid Flow to Distinguish Multiphase Flow Models for In-House Programming." In ASME 2016 International Mechanical Engineering Congress and Exposition. American Society of Mechanical Engineers, 2016. http://dx.doi.org/10.1115/imece2016-66606.

Full text
Abstract:
Fluid flow with particles are found in many engineering applications such as flows inside lab-on-a-chips and heat exchangers. In heat exchangers, nanofluids or base fluids mixed with nanoparticles are applied to be used as the working fluid instead of the traditional base fluids which have low thermal-physical properties. The nanoparticle diameters are in the range from 1 to 100 nanometers are mixed with the traditional base fluids before they are applied inside the heat exchangers and the nanofluids have been proved continually that they enhance heat transfer rates of the heat exchangers. Turbulent and laminar nanofluid flows have shown different enhancements in different conditions. This work focused on comparing different turbulent nanofluid simulations which used the computational fluid dynamics, CFD, with different multiphase models. The Realizable k-ε turbulence model coupled with three multiphase models; Volume of Fluid (VOF) model, Mixture model and Eulerian model, were considered and compared. The heat exchanger geometry in the work was rectangular as in the electrical device application and the nanofluid was a mixture between Al2O3 and water. All simulated results, then, were compared with experimental results. The comparisons showed that numerical results did not deviate from each other but their delivered-time consumptions and complications were different. If one develops his own code, Eulerian model was the most complicated while Mixture model and Eulerian model consumed longer performing times. Although the Eulerian model delivered-time consumption was long but it provided the best results, so the Eulerian model should be chosen when time consumption and errors play important roles. From this ordinary study, the first significant step of in-house program developments has started. The time consumption still indicated that the high performance computers should be selected, and properties obtained from the experimental studies should be imported to the simulation to increase the result accuracy.
APA, Harvard, Vancouver, ISO, and other styles
9

Olson, Eric, Mohsin Rizwan, Panos S. Shiakolas, and Amit Thanekar. "Analysis and Design of a Two-Wheeled Robot With Multiple User Interface Inputs and Vision Feedback Control." In ASME 2012 International Mechanical Engineering Congress and Exposition. American Society of Mechanical Engineers, 2012. http://dx.doi.org/10.1115/imece2012-87987.

Full text
Abstract:
Environments for robotics research and education are usually based on open source code or use proprietary software tools. Open source usually requires a user to know a low level programming language and proprietary software does not provide the environment needed for research and educational activities. In addition to the software, the hardware must be inexpensively and easily fabricated and assembled for teaching and experimentation purposes. In this manuscript, we will present the design and fabrication of a small size two-wheel mobile robotic platform developed for research and education purposes. Subsequently, the software environment for controlling the robot which is based on LabVIEW will be presented. LabVIEW was chosen because it provides many built-in toolboxes, and it is characterized by expandability and ease of interface with external devices. The software allows experienced as well as novice users to develop control code with ease. The robot communicates with control software in LabVIEW through a Bluetooth device. The developed environment is used to control the robot through multiple interfaces, to implement obstacle avoidance algorithms with ease, to implement open and closed loop control algorithms, to easily incorporate and use an inexpensive web camera for vision calibration, and is currently used to implement image processing and voice processing algorithms for robot localization and control both for research and education in both undergraduate and graduate courses.
APA, Harvard, Vancouver, ISO, and other styles
10

Nascimento, Romulo, Eduardo Figueiredo, and Andre Hora. "Assessing JavaScript API Deprecation." In XI Congresso Brasileiro de Software: Teoria e Prática. Sociedade Brasileira de Computação - SBC, 2020. http://dx.doi.org/10.5753/cbsoft_estendido.2020.14616.

Full text
Abstract:
Building an application using third-party libraries is a common practice in software development. As any other software system, code libraries and their APIs evolve over time. In order to help version migration and ensure backward compatibility, a recommended practice during development is to deprecate API. Although studies have been conducted to investigate deprecation in some programming languages, such as Java and C#, there are no detailed studies on API deprecation in the JavaScript ecosystem. The goal of this master research work is to investigate deprecation of JavaScript APIs. In a first assessment, we analyzed popular software projects to identify API deprecation occurrences and classify them. We are now conducting a survey study with developers to understand their thoughts and experiences on JavaScript API deprecation. Lastly, we plan to develop a set of JavaScript API deprecation guidelines based on this master research result. Initial results suggest that the use of deprecation mechanisms in JavaScript packages is low. However, we were able to identify five different approaches that developers primarily use to deprecate APIs in the studied projects. Among these solutions, deprecation utility (i.e., any sort of function specially written to aid deprecation) and code comments are the most common practices in JavaScript. Finally, we found that the rate of helpful message is high: 67% of the deprecation occurrences have replacement messages to support developers when migrating APIs.
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'Low-code 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