Designing an Intuitive Android Based m-Learning to Support Students in Learning Fundamental Java Programming

Jeff Magee and Jeff Kramer John Wiley and Sons, New York, NY, 1999, 374 pp. ISBN 0471987107, $64.99 The book is an introductory text to the ideas, concepts, and topics of concurrency. The text focuses on understanding concepts and techniques, and problems of concurrency, not on the implementation or language. The author's overall goal is that by a combination of learning and doing using Java should make the process of acquiring the skills relating to concurrency interesting, enjoyable, and challenging. The Java language is thus used only for illustration and programming experience of the reader. The book is intended for a computer science student or software developer. A background in programming is expected, as well as some familiarity with the essential concepts of object-oriented programming. Knowledge of the Java programming language and operating systems concepts is beneficial but not required. After reading the text, a reader can expect to have a broad understanding of the concepts of concurrency, the problems that arise, methods to emphasis desirable properties in a concurrent system, and ways to avoid the undesirable ones. The text provides a systematic treatment of concepts, as means to rigorously specify and model concurrent systems, with Java examples to animate and illustrate the concepts discussed. The book is organized into twelve chapters, with three appendices. The first eight chapters provide a concise and comprehensive foundation of concurrency, with the remaining four chapters focusing on more advanced concepts. The latter four chapters are somewhat supplemental and can be read at the discretion of the reader. The content of the text is self-contained, with no reliance upon external references. The authors provide a concluding set of notes and further topics which reference external works, but these are not used in the chapter contents. The introduction provides the foundation for the book, and an idea of what will follow in the rest of the text. The basics of modeling and Java are covered. Authors follow with the concepts of processes, threads and with the idea of concurrency. The emphasis is on using Java, and on the notation used to define a concurrent process or thread. The discussion continues covering interleaving and asynchronous concurrency. Various details about composition of parallel processes and finite state processing modeling are presented. The programming of concurrent execution using Java is then examined via the concept of multiple threads. Here, sharing objects among Java threads is also discussed. The concept of conditional synchronization is covered next, and is used to construct a monitor. The methods of the base object in Java is used, and a waiting queue associated with a Java object is discussed and implemented. This discussion is followed by introduction of deadlock. Authors show the conditions necessary for a deadlock to occur and present an analysis of a concurrent system establishing that such a system is deadlock-free. The classic Dining Philosopher's problem is used to illustrate the distinction between finding deadlocks in models and in programs. The presentation continues with the safety property (that asserts that nothing bad happens), and the liveliness property (that asserts that nothing good happens). Here, authors use the material on model-based design to consolidate many of the concepts previously discussed. No one modeling method or design methodology is emphasized. Then creation and elimination of threads in a running program is covered next. The dynamic starting and stopping of Java threads is presented. The discussion moves then to messaging passing. Asynchronous and synchronous messaging is presented with Java programming examples. The concept of a rendezvous, allowing for interaction in a messaging system, is also presented. Based on the concepts developed so far filter-pipeline, supervisor-worker, and announcer-listener concurrent architectures are examined. Java programs demonstrating how the elements of each model interact at runtime are developed. The presentation completes with modeling and implementing of timed systems. Time is signaled by the passage of successive time ticks. The authors then elaborate on a system that is event-based rather than thread-based. Java programs are used to illustrate in implementation the concepts discussed. The three appendices provide a reference, specification, and listing of semantics for the finite-state modeling algebra used by the authors throughout the book. The text is ideal for teaching in a classroom environment, or for a motivated reader to use for self-paced learning. Its organization follows a logical train of discussion and thought, with each chapter building successively on the other, with the more difficult concepts and topics withheld until later. This gradual approach makes the material flow smoothly and cohesively from the beginning to the end. The book is intended as a textbook, so does organize the material and discussion as one, but does not become too dry or bland to stifle the reader's interest in the material. The examples are inter-mixed with the discussion to highlight and emphasize essential points the authors make in each chapter. The text illustrates concepts well under discussion, and does not become a long-winded recital of theory. The topics examined are fundamental to concurrency, and are well illustrated and discussed, but no one topic is examined extensively. The code examples are well written concerning the programming style, indentation and comments. A CD is provided, containing the codes from the book. In addition supplementary material consisting of presentation slides and an errata is provided on the author's WWW site, as well as on the CD. The book is up to date both on the topics of concurrency, and with the Java applets, code, and programs used to illustrate them. Later, as the Java language evolves, the examples may need to be updated, but for the time being the text well represents that state of the Java language. William F. Gilreath, Micron Technology, Inc., Boise Idaho

The object-oriented theory has been widely used in software design and development and Java programming language is a popular object-oriented programming language for computer science related majors in higher education. With the huge demand for intelligent manufacturing employees in the work market, more and more universities have listed Java programming language in their curriculum for non-CS undergraduates. However, learning object-oriented programming languages, such as Java, is tough even for CS students. This paper presents how to improve non-CS undergraduate students’ learning outcomes of java language by adopting industry standard professional integrated development tool Eclipse and interactive visual educational tool BlueJ. Our Java programming language course is an alternative 8-week course including 16 h lecture and 16 h lab. Forty-seven junior students from mechanical engineering major were divided into two groups, 23 in the control group (CG) and 24 in the experimental group (EG). Students in both groups used Eclipse to write and run programs during the course while BlueJ was adopted to demonstrate the object-oriented concepts during the fifth and sixth weeks only for students in the EG. A pre-test, which was taken by students from both groups, shows no statistical differences in programming knowledge between the two groups. Results from the post-test at the end of the sixth week show students in EG achieved better performance than students in CG. Results of the survey for the EG reveal that students thought BlueJ was helpful for mastering the concepts of object-oriented programming.KeywordsJava programmingLearning outputHigher educationInteractiveVisualBlueJEclipse

This paper describes the structure of two, self-paced, language-translation tutorials that integrate nicely into a principles-based undergraduate programming languages course, thus bringing material normally covered in a compiler course down into the context of a traditional programming languages course. The primary goal of the tutorials is to provide students with useful models for programming language principles as well as a very basic introduction to compiling techniques, including tokenizing, parsing, static semantic checking, and code generation. The paper also exposes a pedagogic technique of repeated exposure that drives the success of these tutorials.

In order to facilitate problem-based learning in our Programming Languages course, we developed a tutor on static and dynamic scope. Static scope includes the scope of variables, the referencing environment of procedures and the scope of procedure names in a language that permits nesting of procedure definitions (e.g., Pascal, Ada). Dynamic scope includes the scope of variables, and the referencing environment of procedures. In this paper, we will describe the design of our tutor, and present the results of evaluating it for two semesters in our Programming Languages course.

Java programming is a lot of colleges and universities have set up a computer programming language courses, programming capability is a measure of the level of expertise of a computer, Java language is a tool to measure the ability of how to improve students' ability to grasp the Java language is a lot of a subject teacher research paper task-driven approach to an object, the task-driven teaching how to introduce Java programming course.

While the programming languages course played a key role in Curricula '68, '78, and '91, Curriculum 2001 replaced most of the content in programming languages with sections on learning to program. We argue that the need for a programming languages course has not diminished, but instead increased, especially as we move into an era of many-core computing.

This paper aims to study the new changes in higher education in the post COVID-19 era and proposed an innovative Online-to-Offline (O2O) blending teaching model, named BOPPPS-SPOC by tracking a C programming language course. BOPPPS-SPOC indicates implementing BOPPPS mode for SPOC (Small Private Online Course). BOPPPS is an acronym for 6 components: Bridge in, Objective, Preassessment, Participatory learning, Post-assessment and Summary and it makes the classroom teaching arrangement more logic and rationality. The new changes are: (1) Teaching Methods: From separated online and offline teaching to an online-offline blending teaching. By adopting the new BOPPPS-SPOC method, the traditional offline and online independent teaching, implemented in a serial way, is optimized into offline and online blending teaching, implemented in a cross-parallel way, and it effectively expand the time and space scope of classroom teaching; (2) Course Evaluation: From single-dimensional evaluation to multi-dimensional evaluation. It focuses on the construction of a fusion evaluation system, mainly including the formative evaluation of teaching process and the sum. Finally, a survey from an authoritative research institution is conducted to 334 universities in China. It shows about 95% of students are able to adapt to an O2O blending teaching.

With the advent of mobile learning, educational systems are changing. Mobile learning, also known as m-learning, is an educational system which enable learning process through mobile devices, such as handheld and tablet computers, smart phones, and mobile phones. In this paper we design a mobile application using gamification to learn algorithms and programming, specifically in Java programming language. The objective of the application is to improve learning motivation of students in a private university majoring in computer science. The design of the application is applying a model for e-Learning, in order to enhance students’ motivation and understanding for topic: introduction to Java programming. The application is developed because the need of fast-paced informatics competencies. In addition, Java programming is a subject which considered as attractive yet a difficult subject to learn. Therefore, approaches and methods to teach in this subject should be designed and delivered carefully. The usability testing result shows that the application considered as a usable application for each usability element. It is indicate that the application is potential to be used as learning alternatives in programming language. However there are some issues still remain related to the application’s features which are very important to enhance students’ motivation for learning algorithms and programming.

In this paper, we describe the use of the BURKS 2 CD-ROM in a principles of programming languages course. The CD-ROM contains compilers and documentation for many programming languages. The course described in this paper emphasises principles and paradigms of languages rather than the details of one or two specific languages.

The programming language concepts which ought to be presented in the comparative programming languages course (either graduate or undergraduate) are all covered by choosing C++, Java, Perl, and Python as the languages to be compared. These include dynamic typing, object orientation, multiple inheritance, interpreters and compilers, keyword and default parameters, generics, operator overloading, complex numbers, universal hierarchies, exceptions, and garbage collection. We describe such a course, which we have given.

In the present decade, education is entering to the world of online learning and focusing to a learner as the center of education. To manage learning system successfully, the education courses: Learning management system (LMS) based on the online learning has been developed. In this study, LMS was developed for Programming Language course for the students of Rajamangala University of Technology Phra Nakhon by using the principle of software development life cycle (SDLC) process. Additionally, the development of the program was done via important major phases of planning analysis, design, implement and evaluated by experts in this field. From 60 randomly selected students of the Faculty of Science and Technology, online Programming Language course providing modules based on LMS model via the Internet showed higher efficiency of 85% than the control in the standard usual instruction procedure. All these aspects of system performance evaluated by the students were also at high level and satisfied with the developed lesson described on the web. Therefore, this online learning system is helpful for all learners in the present information technology world. This system would be further applied for other courses with other additional interactive systems.

Hundreds of programming languages are in use todayscripting languages for Internet commerce, user interface programming tools, spreadsheet macros, page format specification languages, and many others. Designing a programming language is a metaprogramming activity that bears certain similarities to programming in a regular language, with clarity and simplicity even more important than in ordinary programming. This comprehensive text uses a simple and concise framework to teach key ideas in programming language design and implementation. The book's unique approach is based on a family of syntactically simple pedagogical languages that allow students to explore programming language concepts systematically. It takes as its premise and starting point the idea that when language behaviors become incredibly complex, the description of the behaviors must be incredibly simple. The book presents a set of tools (a mathematical metalanguage, abstract syntax, operational and denotational semantics) and uses it to explore a comprehensive set of programming language design dimensions, including dynamic semantics (naming, state, control, data), static semantics (types, type reconstruction, polymporphism, effects), and pragmatics (compilation, garbage collection). The many examples and exercises offer students opportunities to apply the foundational ideas explained in the text. Specialized topics and code that implements many of the algorithms and compilation methods in the book can be found on the book's Web site, along with such additional material as a section on concurrency and proofs of the theorems in the text. The book is suitable as a text for an introductory graduate or advanced undergraduate programming languages course; it can also serve as a reference for researchers and practitioners.

Self-assessment capabilities, that enables the student to have an insight on his own learning process, are a very desirable skill on any higher education student. It is even more important for transnational students as it allows them to successfully adapt to their new international learning environment. Present work proposes an online tool to help computer science students to develop their self-assessment skills while learning Java programming. It consists on a plug-in for the widely popular Moodle learning management system to work with source code for the Java programming language. The developed plug-in lets students to upload source files, analyzes the code and presents a report to the student using industry standard tools. The report includes both errors, points of improvement and a general comparison with the rest of his classmates, from the software quality standpoint. This way, the student is provided with a framework against to which compare the correctness of the solution he/she has programmed before it is delivered to the teacher for evaluation. The teacher is able to access all this information too, facilitating an insight of how the class, as well as individual students, is progressing. It is expected that the shortening on the classical loop of the student problem solution and teacher feedback will enhance the student self-awareness and will improve his overall performance in programming courses.

: There is an increasing interest in recent years to use the Java(trade mark) programming language for implementing real-time systems. Recent advances in the Real-Time Specification for Java (RTSJ) have resulted in the introduction of new means for creating predictable real-time environments for Java programs. However, these new features also make the Java semantics more complex and the run-time behaviors of the Java programs more difficult to analyze. In this technical report, we describe a number of preliminary experiments we performed to study the features of the Sun Java Real-Time System (RTJ 1.0). We designed these experiments to verify the viability of the Real-Time Java language for the implementation of the Global Integrated Fire Control System (GIFC)-a component of the C2BMC element of the Ballistic Missile Defense System (BMDS). Our preliminary experiment shows that it is preferable to use only the Real-Time Java threads that use the heap memory and not the no-heap real-time threads for the GIFC software. However, such architecture cannot be implemented by using RTJ 1.0. Further experiments are needed to determine if the preferred architecture can be implemented with the upcoming RTJ 2.0, which will give programmers more control over the priority of the garbage collection.

JaamSim is a free, open-source simulation package written in the Java programming language. A modern graphical user interface is provided that is comparable to commercial software, including drag-and-drop model building, an Input Editor, Output Viewer, and 3D graphics. Users are able to create their own palettes of high-level objects using standard Java and modern programming tools such as Eclipse. If you are writing hundreds or thousands of lines of code in the proprietary programming language provided with your commercial software, you would be far better off to write your code in Java and use JaamSim.