Search

Machine translation (MT) is an emerging research as well as application area in the contemporary world. It is receiving significant attention from academia, industry and corporate houses. A wide range of translation techniques are being applied either individually or in combination for machine translation of different languages across the globe. However, there are still many languages that are either completely missing or poorly visible on the machine translation map. The Kashmiri language is one such language where very little or negligible work has been done related to its machine translation. This paper aims to present a Kashmiri-to-English Machine Translation System and highlight various features of the Kashmiri language. The system is based on machine intelligence having the ability to learn various translation rules from the translated set of input sentences, using Long Short-term Memory (LSTM) architecture for deep sequence learning. The paper also discusses various challenges related to machine translation from Kashmiri to English or other languages. The work presented in this paper is the first of its nature and can serve as a bedrock for research community interested to work on machine translation of Kashmiri language. [ABSTRACT FROM AUTHOR]

The universal unfolding of a normal form can be employed to reveal the general behaviors of a specific local bifurcation, while the computation of the normal form for high codimensional bifurcation still remains unsolved. This paper focuses on a vector field with codimension-3 triple Hopf bifurcation. Besides 1:1 internal resonance for two frequencies in semi-simple form, two cases are considered, corresponding to internal resonance and noninternal resonance between the first two frequencies and the third frequency, respectively. Based on a combination of center manifold and normal theory, all the coefficients in the normal form and the nonlinear transformation are derived explicitly in terms of the coefficients of the original vector field. Upon the recursive procedure established, a user friendly computer program can be easily developed using a symbolic computation language Maple to compute the coefficients up to an arbitrary order for a specific vector field with triple Hopf bifurcation. Furthermore, universal unfolding of the normal form is obtained, which can be used to display the topological structure in the neighborhood of bifurcation point. It is pointed out that different choices of the remaining terms in the nonlinear transformation may lead to different expressions of the normal form and the unfolding, which are qualitatively equivalent to each other. [ABSTRACT FROM AUTHOR]

In this paper, we present an Intelligent Tutoring System (ITS), for use in teaching the logic of computer programming and the programming language 'C'. The aim of the ITS is to adapt the delivered learning material and the lesson sequence to the knowledge level and learning needs of each individual student. The adaptation of the presented ITS is based on fuzzy logic and a machine learning technique. Particularly, the system uses the distance weighted k-nearest neighbor algorithm to detect the learner's knowledge level and abilities concerning computer programming during her/ his first interaction with the system. Next and during subsequent interactions of the learner with the system, fuzzy logic is used to identify the learner's current knowledge level and potential misconceptions. The system takes into consideration the knowledge dependencies that exist among the domain concepts of the learning material and, applying fuzzy rules, decides about the learning material that has to be delivered to the learner as well as the lesson sequence. The system has been fully implemented and evaluated through t-tests. The evaluation results show that the combination of machine learning (for initially identifying the student's learning abilities and needs) with fuzzy logic (for the continuous identification of the learner's current knowledge level and misconceptions) provides more personalized learning experience, promotes the active participation of students in the learning process and results in decrease in the number of dropouts. [ABSTRACT FROM AUTHOR]

Python is a popular typical dynamic programming language. In Python, dynamic typing is one of the most critical dynamic features. The lack of type information is likely to hinder the maintenance of Python projects. However, existing work has seldom focused on studying the impact of Python dynamic typing on project maintenance. This paper focuses on the two most common practices of Python dynamic typing, i.e. inconsistent-type assignments (ITA) and inconsistent variable types (IVT). Two approaches are proposed to identify ITA and IVT, i.e. identifying ITA by analyzing Abstract Syntax Trees and comparing identifiers types and identifying IVT by constructing a type dependency graph. In empirical experiments, we first locate the usage of ITA and IVT in 10 open-source Python projects. Then, we investigate the relations between the occurrence of ITA and IVT and the results of maintenance tasks. The study results show that projects are more prone to change as the number of dynamic typing identifiers increases. There is a weak connection between change-proneness and variable dynamic typing. There is a high probability that maintenance time and the acceptance of commits decrease as dynamic typing identifiers increase in projects. These results implicate that dynamic and static variables should be divided while developing new programming languages. Dynamic typing identifiers may not be the direct root causes for most software bugs. The categories of these bugs are worth exploring. [ABSTRACT FROM AUTHOR]

Background: The current primary focus of programming language benchmarking studies in the literature is performance with less attention on safety. However, this context has a research gap because the software industry has focused more on software safety than performance to safeguard clients. This paper attempts to address this research gap by benchmarking languages in both safety and performance. Furthermore, this study includes Rust, a relatively new language with promising safety and performance features. Methods: This paper compares six prominent programming languages (in alphabetical order: C, C + + , Go, Java, Python and Rust) to determine which is the best in terms of safety and performance using quantitative and qualitative methods through actual testing of code and analysis of existing information. Results: The comparisons show that Rust was the safest language, outperforming all the other languages. Regarding performance, Rust, C and C + + performed comparably to each other and generally outperformed Go, Java and Python. Conclusion: It is possible to achieve a superior balance of software safety and performance with, at worst, a minimal performance drop; as Rust clearly demonstrates. [ABSTRACT FROM AUTHOR]

Individuals use language in a wide range of contexts. It is a major part of the culture. Teaching students how to speak English in a different manner requires adopting cultural attitudes and behaviors. This learning style has a tremendous sense of belonging, community, and intent. In addition, it motivates learners to create a difference in their neighborhoods and communities around the world. A simple way to incorporate culture into the curriculum is to use the abilities and narratives of the wider community. Multilingual classrooms present an incredible task for English teachers because of the students' wide range of linguistic backgrounds. Because they are afraid of committing mistakes, the students in multilingual classrooms lack self-confidence to communicate in English. Therefore, in this paper, Robot Interaction for Social Cultural Education (RI-SCE) method is proposed to overcome the challenges mentioned above. It uses Deep Machine language and Artificial Intelligence to interact with robots-based computer vision for cultural psychology of English cultural education. As a result, the simulation shows the importance of robot translation in performance, accuracy, efficiency, security, and flexibility compared to the other available models. The model proposed here achieves standard accuracy of 95.2%. [ABSTRACT FROM AUTHOR]

Kotlin is a modern JVM language, gaining adoption rapidly and becoming Android official programming language. With its wide usage, the need for code analysis of Kotlin is increasing. Exposing code semantics explicitly with a properly structured format is the first step in code analysis and the construction of such representation is the foundation for downstream tasks. Recently, graph-based approaches became a promising way of encoding source code semantics. However, this work mainly focuses on representation learning with limited interpretability and shallow domain knowledge. The known evolvements of code semantics in new-generation programming languages have been overlooked. How to establish an effective mapping between naturally concise Kotlin source code with graph-based representation needs to be studied by analyzing known language features. Moreover, the feasibility of enhancing the mapping with code semantics automatically learned from the program needs to be explored. In this paper, we first propose a first-sight, rule-based mapping method, using composite representation with AST, CFG, DFG and language features. To examine the possibility of exposing code semantics in the mapped graph, we use Latent Semantic Indexing-based source code summarization to learn more features of each method, and then enrich the attributes of the corresponding node in the graph. We evaluate these mapping strategies with comparative experiments by simulating a code search solution as a downstream task. The experiment result shows that the graph-based method with built-in language features outperforms the text-based way without introducing greater complexity. Comparative experiments also prove that adding code semantics to the graph benefits the capacity of downstream tasks. When exploring the whole mapping process, our study explicitly revealed the practical barriers to extracting and exposing the hidden semantics from Kotlin source code, which may help enlighten source code representations for other modern languages. [ABSTRACT FROM AUTHOR]

In a broad spectrum, software metrics play a vital role in attribute assessment, which successively moves software projects. The metrics measure gives many crucial facets of the system, enhancing the system quality of software developed. Moreover, maintenance is the correction process that works out in the software system once the software is initially made. The noteworthy characteristic of any software is 'change,' and as a result, additional concern ought to be taken in developing software. So, the software is expected to be modified effortlessly (maintainable). Predicting software maintainability is still challenging, and accurate prediction models with low error rates are required. Since there are so many modern programming languages on the horizon. To accurately measure software maintainability, new techniques have to been introduced. This paper proposes a maintainability index (MI) by considering various software metrics by which the error gets minimized. It also intends to adopt a renowned optimization algorithm, namely Firefly (FF), for the optimum result. The proposed Base Model-FF is compared to other traditional models like BM-Differential Evolution (BM-DE), BM-Artificial Bee Colony (BM-ABC), BM-Particle Swarm Optimization (BM-PSO), and BM-Genetic Algorithm (BM- GA) in terms of performance metrics like Differential ratio, correlation coefficient, and Random Mean Square Error (RMSE). [ABSTRACT FROM AUTHOR]

GitHub and Stack Overflow are often used together for software development. GH-SO users, who use both GitHub and Stack Overflow, contribute to the development of various software projects in GitHub and share their knowledge and experience on software development in Stack Overflow. To widely understand the interests and working habits of GH-SO users on software development, it is important to investigate how GH-SO users utilize GitHub and Stack Overflow. In this paper, we present an exploratory study on GitHub commit and Stack Overflow post activities of GH-SO users. Specifically, we investigate the working habits of GH-SO users on GitHub commit and Stack Overflow post activities. We randomly selected 19,756 of GH-SO users as our target sample and collected 2,819,483 and 2,147,317 of commit activity data and post activity data of the GH-SO users. We then categorized the collected commit and post activity datasets into specific categories on programming languages and statistically analyzed the categorized commit and post activity datasets. As the results of our analysis, we found the following: (1) The overall commit and post activities of the GH-SO users share some similarity. (2) The commit activities gradually change while the post activities drastically change over time. (3) The commit activities of the GH-SO users are broadly distributed while the post activities are narrowly distributed and the commit activity can be better predictor for post activity. (4) The commit activity of the GH-SO users tends to be performed prior post activity. We believe that our findings can contribute to finding the ways to better support commit and post activities of GitHub and Stack Overflow users. [ABSTRACT FROM AUTHOR]

Program online judge (POJ) systems allow students to view questions, submit solution code, and receive scores automatically via the web. Most POJs use test cases for scoring. When a POJ is scored by test case pass rate or a problem that has only one test case, students can usually score by providing the direct output of the test cases (direct output cheating). Currently, there is only one work on detecting such cheating. However, its precision is very low. To solve this problem, three novel approaches are proposed to detect direct output cheating: (i) Line Statistics, which computes the proportion of output calls against other statements; (ii) the control flow graph (CFG) Search computes the maximum similarity between the CFG of a program and that of known samples; (iii) abstract syntax tree (AST) Search identifies cheating by matching rules that are summarized from ASTs of previously detected cheating attempts. A student's code is marked as cheating if the similarity exceeds a predefined threshold; and a program is detected as cheating if the proportion exceeds a predefined threshold. The proposed approaches and three well-known code plagiarism detection tools (JPlag, Sherlock, and SIM) were evaluated using 100,000 submissions for 1153 problems from a POJ based on the C programming language. The F1 scores of these approaches were determined as 0.9752 (AST Search), 0.9440 (CFG Search), 0.7405 (Line Statistics), 0.6446 (JPlag), 0.1587 (Sherlock), and 0.0076 (SIM), respectively. The result indicates that (i) AST Search is most suitable for the detection of direct output cheating; (ii) traditional code search or plagiarism detection methods based on similarity calculations are not effective for complex cheat detection because these cheats are highly similar to normal code. [ABSTRACT FROM AUTHOR]

Recently, Python is the most-widely used language in artificial intelligence (AI) projects requiring huge amount of CPU and memory resources, and long execution time for training. For saving the project duration and making AI software systems more reliable, it is inevitable to handle exceptions appropriately at the code level. However, handling exceptions highly relies on developer's experience. This is because, as an interpreter-based programming language, it does not force a developer to catch exceptions during development. In order to resolve this issue, we propose an approach to suggesting appropriate exceptions for the AI code segments during development after training exceptions from the existing handling statements in the AI projects. This approach learns the appropriate token units for the exception code and pretrains the embedding model to capture the semantic features of the code. Additionally, the attention mechanism learns to catch the salient features of the exception code. For evaluating our approach, we collected 32,771 AI projects using two popular AI frameworks (i.e. Pytorch and Tensorflow) and we obtained the 0.94 of Area under the Precision-Recall Curve (AUPRC) on average. Experimental results show that the proposed method can support the developer's exception handling with better exception proposal performance than the compared models. [ABSTRACT FROM AUTHOR]

Missing data are encountered in many researches and they are also found in well-conducted and controlled studies. Missing data can reduce the statistical strength of a study and may produce biased estimates, leading to invalid conclusions. This study is focused on the problems and types of missing data, together with the techniques for their approach. The mechanisms by which the missing data are obtained and the methods to study these data are illustrated. We have dealt with the multiple imputations as a very efficient method of imputing the missing data and applying these methods in some simulation cases and in real data time series. We have also prepared and adapted the scripts in the programming language R to conduct the simulations. The proposed mice and Amelia packages for imputing the missing values provide fairly good approximations even in the case of real data. [ABSTRACT FROM AUTHOR]

Corrosion and metal degradation are inevitable phenomena in various industries, and using Standards that provide detailed assessment to evaluate the structural integrity of an in-service damaged component is absolutely essential. Among all existing Standards, API 579-1/ASME FFS-1 is a well-known assessment standard recognized as Fitness-For-Service (FFS) assessment and is employed in various industries to assess the structural integrity of in-service pressure vessels and storage tanks that may contain a flaw or damage. In this study, software for the FFS evaluation was developed according to Part 7 of the third edition of the AP1579-1/ASME FFS-1 and was written using C# programming language. This software is developed for low-strength ferritic steel pressurized components with hydrogen blistering (HB) damage, in order to facilitate decision making on run-repair-replace of an in-service damaged component. [ABSTRACT FROM AUTHOR]

In this study, besides the software metrics, the environmental metrics such as experience of software engineer, similar project experience, size of the project, programming language, time spent on analysis and development are also explored to see whether they also affect the results of software fault prediction and what would be the success rates. The dataset for this study was generated from combining various data from 10 projects. A total of 36 metrics and 6676 test cases were evaluated. The errors occurred in the test cases are not just considered as an error, their priority and cases that cannot be tested are also taken into consideration. Nine fault levels are employed in models. Models are created with four different algorithms which have achieved a success rate of; 76% by the decision tree algorithm, 94% by the nearest neighbors algorithm, 90% by the random forests algorithm and 73% by the Adaboost Classifier Algorithm. It was observed that environmental metrics are indeed effective in software fault prediction and when applied with machine learning algorithms a high rate of success can be achieved. [ABSTRACT FROM AUTHOR]

Bootstrap is becoming a useful and very popular tool for obtaining estimations and confidence intervals for coefficients in many researches in different scientific fields without making assumptions about the population. Our goal is to apply bootstrap technique in parameter estimation and confidence intervals for the coefficients in Multiple Logistic Regression model in a study using medical records. We will use R programming language and SPSS software to obtain the coefficients of the model and the estimations using non-parametric bootstrap and we will also make a comparison of the results emphasizing the importance of using resampling methods even in a study with real data. [ABSTRACT FROM AUTHOR]

Search is one of the more common strategies used by problem-solving agents. For many hard problems, a backtracking search can be the most effective approach for finding a solution. Logic programming languages provide, as a core feature of the language, the mechanics for the search behind the scenes without requiring the user to specify the algorithm. However, this functionality has been generally left out of the core features of imperative programming languages. In this work, we propose integrating a search agent into an imperative programming language through a search construct in the syntax. By doing so, our intention is that the user may apply a declarative approach to problem solving. We extend the Go programming language with this search construct and develop an agent to perform the search. The algorithm behind the search is implicitly handled by the agent. We demonstrate the effectiveness of this search construct through solutions to an exhaustive search over a file-system, the NQueens problem, and the monkey and the bananas problem. To evaluate the performance of our agent, we compare its runtime performance against two of the common Prolog implementations, SWI-Prolog and GNU Prolog. [ABSTRACT FROM AUTHOR]