Search

Advanced programming skills are required for computing courses on merging topics, and students often struggle to develop these skills to solve complex problems. To address this challenge, faculty members provide additional lectures, practice sessions, and educational technology tools. This paper discusses the challenges faced by computer science students in developing advanced programming skills and explores the use of AI chatbots, specifically ChatGPT, as a support tool for learning. We study the engagement and effectiveness of ChatGPT in helping students learn advanced programming skills using two engagement learning frameworks (CIE and MELT) for evaluation. The study involves designing a computing lab exercise (design and code questions) for students to complete using ChatGPT and collecting data through surveys. The findings provide initial evidence that ChatGPT can be an effective tool for supporting student learning in advanced programming courses. [ABSTRACT FROM AUTHOR]

Computer programming is a fundamental, transferable, rudimentary skill, which is an essential component across many University level programmes including Computer Games Development/Technology, Computer Science and Software Engineering. Programming has a reputation for being a difficult subject requiring 10 years of education, study and training to transfer from novice to expert level with computer programming courses having a high dropout rate. This indicates that traditional teaching approaches may be insufficient in terms of engaging learners for a sufficient amount of time or may not prove to be educationally effective. Serious games have been empirically evaluated in a variety of educational and training areas and there are many examples of the application of serious games in programming education. It has however been noted by researchers that there is a lack of research performed in terms of how computer games are utilised in teaching with focus on acceptance by learners and the integration of the appropriate pedagogical content. This paper presents the first step in the development of a game to teach rudimentary programming concepts at Higher Education (HE) level. The paper will report on a survey of participants performed to investigate whether a computer game will be accepted by learners to teach rudimentary programming, what particular pedagogical content can be effectively incorporated into the game and what particular type of game is most preferred in terms of genre, graphical fidelity and format. The questionnaire will be utilised as a tool to produce a basic requirements specification for a computer game to teach programming concepts in a Computer Games Development/Technology programme in Higher Education at the University of the West of Scotland (UWS). Sixty-one participants in a Higher Education Computer Games Development/Technology programme completed the survey with some of the following interesting results: 75% of participants believed that a computer game to teach rudimentary programming would be a good idea. Participants stated that medium fidelity would be preferable and that it did not matter if the game was 2D or 3D. Some of the most difficult programming concepts were pointers and classes and a game could be most applicable in some of the following areas: objects, scope, functions, methods, conditional statements, while loops and switch statements. [ABSTRACT FROM AUTHOR]

Software engineering is a team activity yet the programmer's key tool, the IDE, is still largely that of a soloist. This paper describes the vision, implementation and initial evaluation of CoffeeTable - a fully featured research prototype resulting from our reflections on the software design process. CoffeeTable exchanges the traditional IDE for one built around a shared interactive desk. The proposed solution encourages smooth transitions between agile and traditional modes of working whilst helping to create a shared vision and common reference frame - key to sustaining a good design. This paper also presents early results from the evaluation of CoffeeTable and offers some insights from the lessons learned. In particular, it highlights the role of developer tools and the software constructions that are shaped by them. [ABSTRACT FROM AUTHOR]

Recruiting professional programmers in sufficient numbers for research studies can be challenging because they often cannot spare the time, or due to their geographical distribution and potentially the cost involved. Online platforms such as Clickworker or Qualtrics do provide options to recruit participants with programming skill; however, misunderstandings and fraud can be an issue. This can result in participants without programming skill taking part in studies and surveys. If these participants are not detected, they can cause detrimental noise in the survey data. In this paper, we develop screener questions that are easy and quick to answer for people with programming skill but difficult to answer correctly for those without. In order to evaluate our questionnaire for efficacy and efficiency, we recruited several batches of participants with and without programming skill and tested the questions. In our batch 42% of Clickworkers stating that they have programming skill did not meet our criteria and we would recommend filtering these from studies. We also evaluated the questions in an adversarial setting. We conclude with a set of recommended questions which researchers can use to recruit participants with programming skill from online platforms. [ABSTRACT FROM AUTHOR]

TensorFlow is an open source deep learning framework developed at Google that enables developers to conceive a wide variety of applications based on artificial intelligence principles. In this paper, we employ such software resources towards the development of a computer vision system for people with visual impairments. We propose a wearable assistive technology solution consisting of a single board computer connected to a camera mounted on the user's glasses. A TensorFlow based software runs on the board in order to real time classify the images captured by the camera, while a text to speech process vocalizes the still's content for the blind person. In this way, the system provides an audio description of the objects in the user's surrounding environment and it may help these people to better detect the things around them. [ABSTRACT FROM AUTHOR]

Code repurposing is often used for system development and to learn both APIs and programming techniques. Repurposing code typically requires that you understand the code first. This makes it an excellent candidate as an assessment tool in computer science and software engineering education. This strategy might also have a special application in combatting plagiarism. This paper discusses experiences using code repurposing as an assessment tool in different courses and with different sections. [ABSTRACT FROM AUTHOR]

This paper describe the relationship between C++ templates and partial evaluation. In C++, templates were designed to support generic programming, but not deliberately provided the ability to perform compile-time computations and code generation. These features are completely deliberate, and as a result their syntax is ill at ease. After a review, these features in terms of partial evaluation, a much simpler syntax can be achieved. In C++, it may be regarded as a two-level language in which types are first-class values. Template instantiation resembles an offline partial assessor. In this paper, we explain groundwork in the direction of a single mechanism based on Partial Evaluation which unifies generic programming, compile-time computation and code generation. The language Catat is introduced to demonstrate these ideas. [ABSTRACT FROM AUTHOR]

This work paper represents an extending approach for SCORM Content Model Components and Content Packaging with the scope of building a strong foundation for the future of eLearning platform, by elucidation the mystery behind SCORM building packages. In the final of the paper we can see a set of best practices that can be applied with success during the building of the packages for the learners. [ABSTRACT FROM AUTHOR]

Scientific programmers strive constantly to meet performance demands. Tuning is often done manually, despite the significant development time and effort required. One example is lookup table (LUT) optimization, a technique that is generally applied by hand due to a lack of methodology and tools. LUT methods reduce execution time by replacing computations with memory accesses to precomputed tables of results. LUT optimizations improve performance when the memory access is faster than the original computation, and the level of reuse is sufficient to amortize LUT initialization. Current practice requires programmers to inspect program source to identify candidate expressions, then develop specific LUT code for each optimization. Measurement of LUT accuracy is usually ad hoc, and the interaction with multicore parallelization has not been explored. In this paper we present Mesa, a standalone tool that implements error analysis and code generation to improve the process of LUT optimization. We evaluate Mesa on a multicore system using a molecular biology application and other scientific expressions. Our LUT optimizations realize a performance improvement of 5X for the application and up to 45X for the expressions, while tightly controlling error. We also show that the serial optimization is just as effective on a parallel version of the application. Our research provides a methodology and tool for incorporating LUT optimizations into existing scientific code [ABSTRACT FROM AUTHOR]

A process model, namely a formal definition of the coordination of agents performing activities using resources and artifacts, can aid understanding of the real-world process it models. Moreover, analysis of the model can suggest improvements to the real-world process. Complex real-world processes, however, exhibit considerable amounts of variation that can be difficult or impossible to represent with a single process model. Such processes can often be modeled better, within the restrictions of a given modeling notation, by a family of models. This paper presents an approach to the formal characterization of some of these process families. A variety of needs for process variation are identified, and suggestions are made about how to meet some of these needs using different approaches. Some mappings of different needs for variability to approaches for meeting them are presented as case studies. [ABSTRACT FROM AUTHOR]

Software engineering is referred to as application of computer science methodologies and techniques to create computer software adopting related software engineering discipline. Research based software engineering project for undergraduate students is looking into development of project with relation to systematic investigation at formal processes related to software engineering discipline. This paper is focusing on the proposal of evaluation scheme for Software Engineering (SE) undergraduate students' projects. It demonstrates general guidelines, evaluation scheme and stresses the importance and benefits of introducing research based project (RBP) to undergraduate students. [ABSTRACT FROM AUTHOR]

This paper presents a hybrid Water Flow-like Algorithm with Tabu Search for solving travelling salesman problem (WFA-TS-TSP).WFA has been proven its outstanding performances in solving TSP meanwhile TS is a conventional algorithm which has been used since decades to solve various combinatorial optimization problem including TSP. Hybridization between WFA with TS provides a better balance of exploration and exploitation criteria which are the key elements in determining the performance of one metaheuristic. TS use two different local search namely, 2opt and 3opt separately. The proposed WFA-TSTSP is tested on 23 sets on the well-known benchmarked symmetric TSP instances. The result shows that the proposed WFA-TSTSP has significant better quality solutions compared to WFA. The result also shows that the WFA-TS-TSP with 3-opt obtained the best quality solution. With the result obtained, it could be concluded that WFA has potential to be further improved by using hybrid technique or using better local search technique. [ABSTRACT FROM AUTHOR]

In this paper the new coloring of planar graphs, vertex-edge-face coloring, will be introduced. A vertex-edge-face coloring of a simple planar graph G is a proper coloring of all elements, including vertices, edges and faces of G. We will give two conjectures for the upper bound of vertex-edge-face and list vertex-edge-face coloring of a simple planar graph. However, we will prove these conjectures for planar graphs with a maximum degree of at least 12. [ABSTRACT FROM AUTHOR]

WebIDE is a framework that enables instructors to develop and deliver online lab content with interactive feedback. The ability to create lock-step labs enables the instructor to guide students through learning experiences, demonstrating mastery as they proceed. Feedback is provided through automated evaluators that vary from simple regular expression evaluation to syntactic parsers to applications that compile and run programs and unit tests. This paper describes WebIDE and its use in a CS0 course that taught introductory Java and Android programming using a test-driven learning approach. We report results from a controlled experiment that compared the use of dynamic WebIDE labs with more traditional static programming labs. Despite weaker performance on pre-study assessments, students who used WebIDE performed two to twelve percent better on all assessments than the students who used traditional labs. In addition, WebIDE students were consistently more positive about their experience in CS0. [ABSTRACT FROM AUTHOR]

Computer science is gradually changing, evolving and adapting according to the needs of each time period by incorporating the technological developments available. However, despite the occurring changes and the current progress in the domain, computer programming is still a vital chapter within computer science, and its teaching remains a difficult endeavour. On the other hand, students have changed the way with which they learn, interact with and search for knowledge. They spend significant amounts of their everyday lives from a very young age interacting with the computers by playing games. Thus, they are used to environments with impressive special effects and graphical interfaces where they have full control of the situation and interact with the environment's elements. Therefore, today's teachers are trying to connect computer programming learning with students' everyday usage of the computer, which does not include simple textual editors for programming lines of code with no other interaction functionalities. Hence, teachers face the challenge of incorporating environments that are similar to students' existing mentality and of creating tasks and assignments that can be executed within these environments and can provide students with the necessary programming knowledge and skills. A number of software solutions were developed towards facing the aforementioned difficulties. They can be classified into three main categories, namely educational programming environments, microworlds and educational games. Educational games used in computer programming courses are considered to present added value, due to their ability to motivate students towards actively participating in the learning process and to support high levels of interaction, group work and critical thinking. Thus, we have developed an educational game that aims to further enhance computer programming education by addressing occurring problems. This paper aims to introduce and elaborate on a holistic framework that has been constructed as a guide towards the development of this game. To this end, we collect documented difficulties identified in computer programming learning and teaching and study existing frameworks that have been proposed for the development of software solutions for computer programming courses and for the development of successful serious games that do not however focus on computer programming education. This information is thoroughly studied and refined and results in the proposed framework that could also be employed for the design and development of other future educational games focusing on computer programming education. [ABSTRACT FROM AUTHOR]

Modern software systems need to be continuously available under varying conditions. Their ability to dynamically adapt to their execution context is thus increasingly seen as a key to their success. Recently, many approaches were proposed to design and support the execution of Dynamically Adaptive Systems (DAS). However, the ability of a DAS to evolve is limited to the addition, update or removal of adaptation rules or reconfiguration scripts. These artifacts are very specific to the control loop managing such a DAS and runtime evolution of the DAS requirements may affect other parts of the DAS. In this paper, we argue to evolve all parts of the loop. We suggest leveraging recent advances in model-driven techniques to offer an approach that supports the evolution of both systems and their adaptation capabilities. The basic idea is to consider the control loop itself as an adaptive system. [ABSTRACT FROM AUTHOR]

Recent IT research casts computer workarounds as nominal and aggregate phenomena analyzing their antecedent conditions and their impact. This paper focuses on the content and processes of computer workarounds as situated work practices using negotiated order as a conceptual framework. We propose that some workarounds are based on an alternate negotiated order and may entail coordinated action that goes beyond prior formulations of workarounds as "hacks" or "tweaks" by individual computer users. [ABSTRACT FROM AUTHOR]

Many programming tools require information to be associated with source locations. Current tools do this in different ways with different degrees of effectiveness. This paper is an investigation into the various approaches to maintaining source locations. It is based on an experiment that attempts to track a variety of locations over the evolution of a source file. The results demonstrate that relatively simple techniques can be very effective. [ABSTRACT FROM AUTHOR]

This paper presents a system for self-plagiarism detection, SPLAT. The system uses a WebL web spider that crawls through the web sites of the top fifty Computer Science departments, downloading research papers and grouping them by author. Next a text -comparison algorithm is used to search for instances of textual reuse. Instances of potential selfplagiarism for each author are reported in an HTML document so that they can be considered in more detail, in order to determine if they are truly self-plagiarized papers. The system discovered a number of pairs of papers of questionable originality. [ABSTRACT FROM AUTHOR]

Plagiarism and collusion are problems that educators have to deal with in the design, implementation and marking of any assignments. It is particularly difficult when the deliverable for an assignment is computer code - which can be easily copied and its origins obfuscated. This is compounded when there are a large number of submissions marked by different people - similarities between assignments are then easily missed, making the detection of collusion in particular very difficult. This paper describes a process of identifying similarity between different pieces of computer code based on techniques used in bioinformatics. It was able to measure the "degree" of relationship between different assignments, providing a visual diagram of the similarity between various submissions. This was then used to preselect assignments for closer inspection and comparison. [ABSTRACT FROM AUTHOR]

During the past decade, multitasking has become a symbol for productivity. Taken from computer science and parallel processing in machines, humans have tried to imitate that behavior, to work on several things at the same time or sequentially with frequent switches between tasks in order to accomplish more during the same period of time. This paper attempts to offer a wide literature overview, including research from various fields, such as psychology, education, management and neuroscience in order to gain extensive understanding of the multitasking concept. Introducing a nuanced view of multitasking might lead to better understanding of its effects on productivity in various settings. In addition, multitasking is discussed through two dimensions, which are time and task. Changes in one or both of these dimensions, as well as their mutual interplay could have an effect on one's productivity. [ABSTRACT FROM AUTHOR]

This paper reports on research into how two stakeholder groups - systems developers and the business client enact a systems development methodology (SDM). Our focus is on understanding how enactment is constrained by everyday social and organisational structures. The study develops a conceptual framework informed by institutional theory that integrates elements of Lamb and Kling's social actor model, and Scott's 3-pillars framework, concentrating on the relationships among systems developers, the business client, the SDM, and the context surrounding its use. The framework demonstrates that institutional structures such as authority, norms, symbolic values, and routines embedded within the methodology are active forces in the systems development process. In terms of theoretical contribution, the user as social actor model enables us to draw out the power concepts, and institutional theory explains how the SDM acts as a carrier of power, but not why developers are compliant with an unequal power arrangement. [ABSTRACT FROM AUTHOR]

Inline assembly is still a common practice in low-level C programming, typically for efficiency reasons or for accessing specific hardware resources. Such embedded assembly codes in the GNU syntax (supported by major compilers such as GCC, Clang and ICC) have an interface specifying how the assembly codes interact with the C environment. For simplicity reasons, the compiler treats GNU inline assembly codes as blackboxes and relies only on their interface to correctly glue them into the compiled C code. Therefore, the adequacy between the assembly chunk and its interface (named compliance) is of primary importance, as such compliance issues can lead to subtle and hard-to-find bugs. We propose RUSTINA, the first automated technique for formally checking inline assembly compliance, with the extra ability to propose (proven) patches and (optimization) refinements in certain cases. RUSTINA is based on an original formalization of the inline assembly compliance problem together with novel dedicated algorithms. Our prototype has been evaluated on 202 Debian packages with inline assembly (2656 chunks), finding 2183 issues in 85 packages -- 986 significant issues in 54 packages (including major projects such as ffmpeg or ALSA), and proposing patches for 92% of them. Currently, 38 patches have already been accepted (solving 156 significant issues), with positive feedback from development teams. [ABSTRACT FROM AUTHOR]

Background: Researchers and practitioners have been using code complexity metrics for decades to predict how developers comprehend a program. While it is plausible and tempting to use code metrics for this purpose, their validity is debated, since they rely on simple code properties and rarely consider particularities of human cognition. Aims: We investigate whether and how code complexity metrics reflect difficulty of program comprehension. Method: We have conducted a functional magnetic resonance imaging (fMRI) study with 19 participants observing program comprehension of short code snippets at varying complexity levels. We dissected four classes of code complexity metrics and their relationship to neuronal, behavioral, and subjective correlates of program comprehension, overall analyzing more than 41 metrics. Results: While our data corroborate that complexity metrics can--to a limited degree--explain programmers' cognition in program comprehension, fMRI allowed us to gain insights into why some code properties are difficult to process. In particular, a code's textual size drives programmers' attention, and vocabulary size burdens programmers' working memory. Conclusion: Our results provide neuro-scientific evidence supporting warnings of prior research questioning the validity of code complexity metrics and pin down factors relevant to program comprehension. Future Work: We outline several follow-up experiments investigating fine-grained effects of code complexity and describe possible refinements to code complexity metrics. [ABSTRACT FROM AUTHOR]

Teaching emerging technologies with a student-centered learning approach in Computer Science Department is generally perceived as a challenging task. This is mainly due to the fact that students usually lack the knowledge for getting involved in dialogues about the course subjects. This paper introduces the pedagogical approach of using incremental lab projects for promoting student-centered learning in teaching Web Technologies and Java Programming II. In this paper, the concepts of web applications, JavaServer Faces, and NetBeans Integrated Development Environment (IDE) are introduced. Then the approach of using incremental JSF projects is described. In the future, the assessment for the effectiveness of using incremental projects in teaching will be reported based on hypothesis tests with the t statistic. [ABSTRACT FROM AUTHOR]

Stack Overflow (SO) is the most popular online Q&A site for developers to share their expertise in solving programming issues. Given multiple answers to a certain question, developers may take the accepted answer, the answer from a person with high reputation, or the one frequently suggested. However, researchers recently observed that SO contains exploitable security vulnerabilities in the suggested code of popular answers, which found their way into security-sensitive highprofile applications that millions of users install every day. This observation inspires us to explore the following questions: How much can we trust the security implementation suggestions on SO? If suggested answers are vulnerable, can developers rely on the community's dynamics to infer the vulnerability and identify a secure counterpart? To answer these highly important questions, we conducted a comprehensive study on security-related SO posts by contrasting secure and insecure advice with the community-given content evaluation. Thereby, we investigated whether SO's gamification approach on incentivizing users is effective in improving security properties of distributed code examples. Moreover, we traced the distribution of duplicated samples over given answers to test whether the community behavior facilitates or prevents propagation of secure and insecure code suggestions within SO. We compiled 953 different groups of similar security-related code examples and labeled their security, identifying 785 secure answer posts and 644 insecure answer posts. Compared with secure suggestions, insecure ones had higher view counts (36,508 vs. 18,713), received a higher score (14 vs. 5), and had significantly more duplicates (3.8 vs. 3.0) on average. 34% of the posts provided by highly reputable so-called trusted users were insecure. Our findings show that based on the distribution of secure and insecure code on SO, users being laymen in security rely on additional advice and guidance. However, the communitygiven feedback does not allow differentiating secure from insecure choices. The reputation mechanism fails in indicating trustworthy users with respect to security questions, ultimately leaving other users wandering around alone in a software security minefield. [ABSTRACT FROM AUTHOR]

Current state-of-the-art automatic software repair (ASR) techniques rely heavily on incomplete specifications, or test suites, to generate repairs. This, however, may cause ASR tools to generate repairs that are incorrect and hard to generalize. To assess patch correctness, researchers have been following two methods separately: (1) Automated annotation, wherein patches are automatically labeled by an independent test suite (ITS) -- a patch passing the ITS is regarded as correct or generalizable, and incorrect otherwise, (2) Author annotation, wherein authors of ASR techniques manually annotate the correctness labels of patches generated by their and competing tools. While automated annotation cannot ascertain that a patch is actually correct, author annotation is prone to subjectivity. This concern has caused an on-going debate on the appropriate ways to assess the effectiveness of numerous ASR techniques proposed recently. In this work, we propose to assess reliability of author and automated annotations on patch correctness assessment. We do this by first constructing a gold set of correctness labels for 189 randomly selected patches generated by 8 state-of-the-art ASR techniques through a user study involving 35 professional developers as independent annotators. By measuring inter-rater agreement as a proxy for annotation quality -- as commonly done in the literature -- we demonstrate that our constructed gold set is on par with other high-quality gold sets. We then compare labels generated by author and automated annotations with this gold set to assess reliability of the patch assessment methodologies. We subsequently report several findings and highlight implications for future studies. [ABSTRACT FROM AUTHOR]

Unit tests are a tenant of agile programming methodologies, and are widely used to improve code quality and prevent code regression. A green (passing) test is usually taken as a robust sign that the code under test is valid. However, some green tests contain assertions that are never executed. We call such tests Rotten Green Tests. Rotten Green Tests represent a case worse than a broken test: they report that the code under test is valid, but in fact do not test that validity. We describe an approach to identify rotten green tests by combining simple static and dynamic call-site analyses. Our approach takes into account test helper methods, inherited helpers, and trait compositions, and has been implemented in a tool called DrTest. DrTest reports no false negatives, yet it still reports some false positives due to conditional use or multiple test contexts. Using DrTest we conducted an empirical evaluation of 19,905 real test cases in mature projects of the Pharo ecosystem. The results of the evaluation show that the tool is effective; it detected 294 tests as rotten--green tests that contain assertions that are not executed. Some rotten tests have been "sleeping" in Pharo for at least 5 years. [ABSTRACT FROM AUTHOR]

Automated Program Repair (APR) faces a key challenge in efficiently generating correct patches from a potentially infinite solution space. Existing approaches, which attempt to reason about the entire solution space, can be ineffective (by often producing no plausible patches at all) and imprecise (by often producing plausible but incorrect patches). We present VFIX, a new value-flow-guided APR approach, to fix null pointer exception (NPE) bugs by considering a substantially reduced solution space in order to greatly increase the number of correct patches generated. By reasoning about the data and control dependences in the program, VFIX can identify bug-relevant repair statements more accurately and generate more correct repairs than before. VFIX outperforms a set of 8 state-of-the-art APR tools in fixing the NPE bugs in Defects4j in terms of both precision (by correctly fixing 3 times as many bugs as the most precise one and 50% more than all the bugs correctly fixed by these 8 tools altogether) and efficiency (by producing a correct patch in minutes instead of hours). [ABSTRACT FROM AUTHOR]

In order to build efficient tools that support complex programming tasks, it is imperative that we understand how developers program. We know that developers create a context around their programming task by gathering relevant information. We also know that developers decompose their tasks recursively into smaller units. However, important gaps exist in our knowledge about: (1) the role that context plays in supporting smaller units of tasks, (2) the relationship that exists among these smaller units, and (3) how context flows across them. The goal of this research is to gain a better understanding of how developers structure their tasks and manage context through a field study of ten professional developers in an industrial setting. Our analysis reveals that developers decompose their tasks into smaller units with distinct goals, that specific patterns exist in how they sequence these smaller units, and that developers may maintain context between those smaller units with related goals. Index Terms--context, task decomposition, field study [ABSTRACT FROM AUTHOR]

This research aims to understand the impact of Hour of Code in consecutive 5 year since it was first launched in 2013. College students in an introductory computing course were surveyed about their attitude toward programming and their programming knowledge. We found evidence of positive impact of Hour of Code on student attitude toward programming as well as their understanding of programming knowledge. This study provides a foundation upon which further investigation into gender differences in computing can be based as well as improving attitude, knowledge, and interest in computer programming. [ABSTRACT FROM AUTHOR]

Research continues to demonstrate gender-based differences related to computer programming confidence and STEM-related educational and career choices: Girls and women, we well know by now, are under-represented in computer science and engineering programs and the tech-industry in general (Hill, Corbet & Rose, 2010). A factor contributing to women's under-representation in undergraduate computer science and engineering programs has been seen as being their 'choice' not to take these courses or being 'unaware' of programming and other courses in high school (Howe, Berenson & Vouk, 2007). Meanwhile, girls and women continue to self-report that they feel less confident when it comes to programming and general IT related skills than their male peers (NSF, 2011; Wang, Eccles & Kenny, 2013). This study sought to use game design as a pathway for supporting the acquisition of programming skills in young students. We examined whether factors such as the learning community (instruction in mixed or same gender groups; teacher supervision), and children's preexisting biases and previous experiences related to computer science and programming, were associated with change in computational knowledge following participation in an intensive, 1-week game design program. A 15-hour instructional game design unit was given to two separate cohorts of grade 6 students (ages 11 to 12) at the same school (N = 119). Cohort 1 was comprised of 3 mixed gender groups (girls: n = 30, boys: n = 30), and Cohort 2 was comprised of 4 single gender groups (girls: n = 32, boys: n = 27). The two cohorts received the same instruction and curriculum, led by a female facilitator with support by a team of near-peer, mixed gender mentors, and supervision by female classroom teachers. In general, we found that all students performed better from pre- to post, and that prior programming knowledge had a significant effect on learning outcomes. We argue that more opportunities early on in school-based settings are necessary if we would like to support all learners to acquire STEM-related skills and competencies. [ABSTRACT FROM AUTHOR]

Individuals who are visually impaired encounter a number of challenges when attempting to orientate their own position or the position of others in relation to them within an unfamiliar indoor environment. To design an orientation assistive technology, it is crucial to understand the factors that reduce the user's sense of orientation. In this work, we discuss the disorientation factors that resulted from three user studies, which were conducted to formulate the basic requirements for an orientation assistive technology to assist visually impaired individuals in unfamiliar indoor areas. Using the feedback we elicited from one survey and two interview studies, we shed light on the factors that reduce the user's sense of orientation in unfamiliar buildings such as noise and traffic levels. [ABSTRACT FROM AUTHOR]

End-user programmers, those who write code but lack formal training in computer science, are often reliant on various tools such as API documentation or searching the Web for information in order to complete a specific task. This study examines the information foraging behaviors of a group of web and graphic designers engaged in a series of code modification tasks. We find that users were largely unsuccessful in their foraging activities, with few information seeking events resulting in noticeable changes to participants' source code. Participants viewed remarkably few results generated by their queries and rarely refined queries multiple times. However, these kinds of activities were positively correlated with task success metrics. We conclude with a discussion of the study's results and their implications on the design of future programming environments and search tools for end-user programmers. [ABSTRACT FROM AUTHOR]

Saint-Petersburg State University seems to be the only university in the world where the Astronomy belongs to the Mathematical department. The origin of this tradition is traced backward to the XVIII century. The description of astronomical educational activity of Astronomical Department in Saint-Petersburg State University is presented. This educational system was created many years ago, but due to modern up-grate it works rather successful. The historical review is given. The present system of education is shown. The general courses, specific programs and modern lectures, seminars and observations what a student is getting during 5-years educational program are described. The aim of the general courses is to describe the problems the astronomers met in various branches of modern astronomy. It is necessary to mention that background of all knowledge is of high level mathematics, programming and computer sciences. The faculty of the Astronomical Department is in charge to provide the general astronomical courses, whereas the special courses are provided mainly by leading scientists from astronomical institutions of Saint-Petersburg. Research is an integral part of the graduate program. The post graduate programs aiming at the award of the highest degrees (candidate and doctor of science) are described. [ABSTRACT FROM AUTHOR]

As commercial off-the-shelf components starts used effectively, in building Component based Systems and new methodologies and processes not only for development and maintenance, but also for other lifecycle phases that are strongly affected. For example, some software vendors have begun to successfully sell and license commercial off-the-shelf (COTS) components, and this fact leads to a considerable number of components being available for use. Thus, requirements engineering techniques have to change to deal with more flexible requirements to provide a match between stakeholder requirements and COTS component’s services. In addition to changes in activities such as composition and component specification, that are specific to Component-Based Software Engineering (CBSE), there are also a number of managerial issues that require change. Many of these issues are not yet established in practice or even developed. The main goal of this article is to present some characteristics of a CBSD and discuss some of the current issues associated with applying CBSE. [ABSTRACT FROM AUTHOR]

Components are widely used for managing distributed applications because they not only capture the software architecture of managed applications as an assembly of components but also permit to dynamically adapt these applications to changing environments. Following this approach, our practical experience in the Jade environment about developing an autonomic repair management service with a self-healing behavior shows novel requirements on reflective component models for architecture-based management systems. First, we have identified five essential runtime abstractions that a component model must include in order to efficiently support an autonomic repair service. Second, our experience suggests that traditional reflective component models should be extended to allow specializing meta-operations. Third, our experience also shows that a meta-data check pointing capability is best-suited for meta-data recovery after failures. We demonstrate the soundness of these findings in several ways. We applied the difficult problem of autonomic repair to both J2EE and JMS middleware. We further stressed our algorithms and mechanisms by applying them recursively towards gaining a self-healing property for the repair service itself. Although our experience was done in the Jade context, using the Fractal component model, we believe our findings to be general to architecture-based management systems using reflective component models. [ABSTRACT FROM AUTHOR]

The Hilbert curve has previously been constructed recursively, using p levels of recursion of n-bit Gray codes to attain a precision of p bits in n dimensions. Implementations have reflected the awkwardness of aligning the recursive steps to preserve geometrical adjacency. We point out that a single global Gray code can instead be applied to all np bits of a Hilbert length. Although this “over-transforms” the length, the excess work can be undone in a single pass over the bits, leading to compact and efficient computer code. © 2004 American Institute of Physics [ABSTRACT FROM AUTHOR]

Polymorphism means one thing exists in many forms of its own with each form having different implementation of its own. Polymorphism can be compile time or runtime. It is concern of lifetime of object. The lifetime can be determined at compile time or runtime. The compiler has a such knowledge to determine static analysis of source code. [ABSTRACT FROM AUTHOR]