Abstract

Abstract
Courses in computer programming combine a number of different concepts, from general problem-solving to mathematical precepts such as algorithms and computational intelligence. Due to the complex nature of computer science education, teaching the novice programmer can be a challenge. Innovative Teaching Strategies and New Learning Paradigms in Computer Programming brings together pedagogical and technological methods to address the recent challenges that have developed in computer programming courses. Focusing on educational tools, computer science concepts, and educational design, this book is an essential reference source for teachers, practitioners, and scholars interested in improving the success rate of students.

Abstract
The two largest causes for battery consumption on mobile devices are related with the display and network operations. Since most application need to share data and communicate with remote servers, communications should be as lightweight and efficient as possible. In network communication, serialization plays a central role as the process of converting an object into a stream of bytes. One of the most popular data-interchange format is JSON (JavaScript Object Notation). This paper presents a survey on JSON parsers in mobile scenarios. The aim of the survey is to find the most efficient JSON parser in mobile communications characterised by high transfer rate of small amounts of data. In the performance benchmark we compare the time required to read and write data with several popular JSON parser implementations such as Gson, Jackson, org.json and others. The results of this survey are important for others that need to select an efficient parser for mobile communication. © Ricardo Queirós.

Abstract
Teaching and learning computer programming is as challenging as it is difficult. Assessing the work of students and providing individualised feedback is time-consuming and error prone for teachers and frequently involves a time delay. The existent tools prove to be insufficient in domains where there is a greater need to practice. At the same time, Massive Open Online Courses (MOOC) are appearing, revealing a new way of learning. However, this paradigm raises serious questions regarding the monitoring of student progress and its timely feedback. This chapter provides a conceptual design model for a computer programming learning environment. It uses the portal interface design model, gathering information from a network of services such as repositories, program evaluators, and learning management systems, a central piece in the MOOC realm. This model is not limited to the domain of computer programming and can be adapted to any area that requires evaluation with immediate feedback. © 2015, IGI Global.

Abstract
In this article we discuss three different notions of linearity: syntactical, operational and denotational. We briefly define each notion of linearity, pointing out some of the main results in the area, and describe applications of linear languages and type systems.

Abstract
Bugs in multithreaded application can be elusive. They are often hard to trace and replicate, given the usual non-determinism and irreproducibility of scheduling decisions at runtime. We present Cooperari, a tool for deterministic testing of multithreaded Java code based on cooperative execution. In a cooperative execution, threads voluntarily suspend (yield) at interference points (e.g., lock acquisition), and code between two consecutive yield points of each thread always executes serially as a transaction. A cooperative scheduler takes over control at yield points and deterministically selects the next thread to run. An application test runs multiple times, until it either fails or the state-space of schedules is deemed as covered by a configurable policy that is responsible for the scheduling decisions. Beyond failed assertions in software tests, deadlocks and races are also detected as soon as they are exposed in the cooperative execution. Cooperari effectively finds, characterizes, and deterministically reproduces bugs that are not detected under unconstrained preemptive semantics, as illustrated by standard benchmark examples.