In Computer Science, functional programming is a programming paradigm which uses functions to describe the logic of what the program has to achieve. These are mathematical function-like constructs (e.g., lambda functions) that are evaluated in expression contexts. Google Trends currently ranks functional programming as more popular than object-oriented programming. Also, functional programming is very important in existing popular platforms like Hadoop and Apache Spark. Many students may ask what are the benefits and why should they use functional programming in Java. From its beginnings, best practices in Java have encouraged object-oriented programming, which is an extension of procedural programming type of imperative programming. Since version 8 Java introduced Java developers to functional programming with lambda expressions, method references and predefined functional interfaces. This Java release effectively notified developers that it's no longer sufficient to think about Java programming only from the imperative, object-oriented perspective. The first purpose of this paper is to present the benefits of adopting a functional paradigm to students which worked with the older versions of Java (6, 7 or earlier) and to the ones working with legacy code or using newer versions but without switching to functional paradigm. Secondly, we present some improvements to existing interactive system for online learning of functional programming in programming language Java, supporting automatic grading of given assessments. These improvements are aimed at students who already have basic knowledge of Java programming languages, and want to switch to functional programming. Finally, we analyzed our solution by comparing its content to multiple commercially available solutions and point out the advantages and disadvantages of each.
Functional programming, a paradigm at the heart of computer science, has seen a resurgence in popularity and practical application in recent years. Unlike imperative programming, which focuses on how a program operates (through statements and instructions), functional programming emphasizes what the program should accomplish, using pure functions and immutable data.
At its core, functional programming is about building software by composing pure functions. A pure
function is one that, given the same input, will always return the same output and does not cause any
observable side effects. This concept is not only central to functional programming but also to the
mathematical notion of a function, making the paradigm highly expressive and predictable [
One of the key principles of functional programming is immutability. Immutability in this context
refers to the idea that once a data structure is created, it cannot be altered. This principle reduces
complexity and improves the predictability of code. Side-effect-free functions, another cornerstone of
functional programming, contribute to the reliability and maintainability of software, as they do not
alter the state outside their scope [
In recent years, functional programming has gained traction in the software development industry,
particularly in the development of large-scale, concurrent applications. Languages like Haskell and
Scala, and features in Java 8 such as lambda expressions, have brought functional programming
concepts to the forefront of software design [
Functional programming's emphasis on immutability and stateless functions makes it particularly
well-suited for concurrent and distributed systems. In these systems, managing state and dealing with
mutable data can lead to complex issues. Functional programming alleviates these challenges, making
it easier to write safe and efficient concurrent code [
In the rapidly evolving landscape of software development and data processing, functional
programming has emerged as a key paradigm, not just in theory but also in practical applications. This
paradigm shift is particularly evident in the realm of big data and distributed computing, where
functional programming principles have become integral to the design and operation of major
platforms. A prime example of this trend is the significant role functional programming plays in existing
popular platforms like Hadoop and Apache Spark. These platforms, which are at the forefront of
handling large-scale data processing, leverage functional programming concepts to enhance efficiency,
scalability, and fault tolerance. This integration of functional programming into such platforms is not
incidental but stems from several core advantages that this programming style offers in dealing with
complex data processing tasks [
Functional programming promotes the use of immutable data, which is crucial for efficient parallel
execution of operations. In the context of distributed systems like Hadoop and Apache Spark,
immutability allows data operations to be executed in parallel without the risk of state conflicts or the
need for complex locking mechanisms. This is particularly important in big data processing, where
parallelism plays a key role in achieving high performance [
Hadoop utilizes the MapReduce paradigm, deeply rooted in functional programming. MapReduce
consists of map and reduce functions, which are concepts taken from functional programming. The map
function processes input data and transforms it into intermediate results, while the reduce function
aggregates these results into the final output. This model is naturally suited to the functional style of
programming, where functions are first-class citizens and shared state is avoided [
Apache Spark, often used for big data processing, provides an API that is strongly inspired by
functional programming, especially in its Scala interface. Spark uses concepts like RDD (Resilient
Distributed Dataset) and Datasets, which enable functional operations such as map, filter, reduce, and
aggregate on distributed data sets. These operations allow developers to write code that is both
expressive and efficient for parallel execution [
The functional approach in Spark and Hadoop contributes to better scalability and resilience of the
systems. Side-effect-free functions are easier to test and understand, which is crucial in complex
distributed systems. Also, the functional approach facilitates the re-execution of operations in case of
failures, important for system resilience [
Functional programming plays a key role in the design and implementation of modern distributed data processing systems, such as Hadoop and Apache Spark. The principles of functional programming, such as immutability, problem decomposition into functions, and avoidance of shared state, are essential for the efficiency, scalability, and resilience of these systems.
This curriculum is meticulously crafted to guide learners through the intricacies of functional
programming in Java, particularly emphasizing the transformative features introduced in Java 8 and
further refined in subsequent versions. As Goetz [
This curriculum is ideally suited for individuals who have a foundational understanding of Java and are keen to explore the realm of functional programming, which has become increasingly relevant in modern software development. In this journey, learners will delve into the essence of functional programming as conceptualized in Java, starting from the basic principles and gradually progressing to more advanced features and concepts. The curriculum not only covers the theoretical aspects but also provides practical insights and applications, ensuring a holistic understanding of functional programming in the context of Java's ongoing evolution.
Autograders are software tools that assist educators, including professors and teaching assistants, by
automating the grading process of student assignments. This not only reduces the workload of manually
evaluating each submission but also eliminates potential biases from the grading process. This
technology is particularly beneficial for students in Computer Science (CS) and Electrical Engineering
(EE), where assignments predominantly involve coding tasks. The concept of autograders in these fields
has a history spanning over fifty years [
Initially, autograders were basic, capable of assessing only straightforward programming tasks and
primarily supporting procedural programming. These early systems typically provided binary feedback,
labeling student work as either "correct" or "incorrect" based on a rigid set of criteria. The latest
generation of autograders has developed alongside advancements in high-speed internet and web
technologies [
Despite the availability of various autograder tools, as noted in the literature [17], many are customdesigned for specific languages and requirements. Besides tools created for higher education institutions, there are also specialized autograders in Massive Open Online Courses (MOOCs) and commercial platforms, often tailored for particular courses or programming language basics. Autograders face two primary challenges: technical and pedagogical [20]. Technical challenges involve ensuring security against potentially harmful code in assignments and integrating with the Learning Management Systems (LMS) of educational institutions. Pedagogically, the inconsistency in grading systems is a concern. While some autograders still rely on the basic correct/incorrect feedback model, more advanced systems use a detailed step-by-step test case evaluation. However, there is no standardized model or widely accepted grading recommendation for these systems. 4.2.
We have proposed a system that was primarily developed for learning basic and object-oriented programming, and in this paper, it has been expanded to include support for functional programming. The system we propose is built upon an existing autograder system, originally developed for teaching fundamental programming concepts and object-oriented programming [15-18]. As depicted in Figure 1 on the following page, this system includes: • • • • •
Initial Assessment: Students begin by taking a self-assessment on data structures to establish a starting point. This could be a brief quiz or a set of multiple-choice questions..
Learning Module: Students are introduced to advanced data structure topics through lessons provided in written, video, and animated formats.
Assessment type 1: Students are tasked with a relatively easy to moderately challenging exercise. They write code in a browser-based text editor, where a Java compiler operates server-side. The exercise includes some pre-written code.
Assessment type 2: More challenging exercises are presented, requiring students to write code from scratch in a text editor without any pre-written code.
Progress Tracking: After completing the assessments for each topic, the autograder system notifies students of their success in the current topic. Progression to subsequent topics is contingent on successful completion of previous ones. At the course's conclusion, students retake the initial assessment (or a similar one) to gauge their learning progress.
After each of the topics’ assessments, an autograder system informs the student if they have passed the current topic successfully, and can only continue with the next topic if the previous is passed. At the end of the whole course, the student completes the same (or similar) baseline test to self-assess their progress.
Within the framework of our developed autograder system, a variety of tasks are designed to enhance the learning experience of students. One such task is as follows:
The system presents students with a specific challenge: Convert the code shown in Figure 2 into code that effectively utilizes functional programming, leveraging the Java Stream API, and employing the methods filter() and collect(). Figure 2 serves as a practical illustration, demonstrating how a particular programming task can be approached in two distinct ways in Java: the traditional imperative approach and the modern functional approach. This task, specifically, involves filtering a list of numbers, retaining only those that are greater than 10. The imperative method is shown as a starting point, and students are tasked with transforming this into a more streamlined, functional version using Java 8 features.
This exercise not only reinforces their understanding of functional programming concepts but also allows them to directly compare and contrast different programming paradigms within Java, thereby deepening their comprehension and skill in the language. This task is representative of the kind of practical, hands-on challenges that are integral to our autograder system, designed to provide students with real-world programming scenarios that enhance their coding skills and theoretical knowledge." In the functional approach, we use the Java Stream API. The stream() method converts the list into a stream, the filter() method applies a lambda expression that specifies the filtering condition, and the collect() method gathers the results and returns them in a list. Figure 3 shows how the same task can be solved using a functional approach with Java 8.
In this paper, we have explored the characteristics of functional programming and proposed a comprehensive curriculum for functional programming in Java 8 and its subsequent versions. We have also presented significant enhancements to an existing interactive system for the online learning of functional programming in Java, emphasizing support for automatic grading of assessments. These improvements are meticulously designed for students who have a foundational understanding of Java programming and are keen to transition to functional programming paradigms. The introduction of an automatic grading system has streamlined the learning process, offering immediate and personalized feedback, which is vital for effective learning. The updated curriculum, encompassing comprehensive modules on key functional programming concepts in Java, such as lambda expressions and the Stream API, ensures that learners are thoroughly prepared to comprehend and implement these advanced programming techniques.
Moreover, the integration of an interactive coding environment within the system fosters hands-on learning and experimentation, which is crucial for a deep understanding of functional programming nuances. The system's provision of personalized learning paths addresses the varied needs of students, accommodating different learning styles and paces.
In conclusion, the enhancements made to the interactive system mark a significant progression in the realm of programming education. By aligning the system with the latest trends in Java programming and concentrating on the practical application of functional programming concepts, we have developed a robust educational platform. This platform not only imparts knowledge but also readies students for the evolving demands of the software development industry. Our approach effectively bridges the gap between traditional Java programming and the contemporary functional programming paradigm, equipping learners with the necessary skills and knowledge to thrive in today's technological landscape.
This paper was supported by the Ministry of Education, Science and Technological Development, Republic of Serbia (Project III44006).
[15]J. C. Caiza and J. M. del Alamo, “Programming assignments automatic grading: review of tools and implementations,” In Proc. of the 7th international technology, education and development conference (INTED2013), pp. 5691, 2013. [16]G. Haldeman, M. Babeş-Vroman, A. Tjang, and T. D. Nguyen. “CSF: Formative Feedback in Autograding,” ACM Transactions on Computing Education, vol. 21, no. 3, 2021. [17]S. Krusche and A. Seitz, “ArTEMiS: An automatic assessment management system for interactive learning,” in Proc. of the 49th ACM Technical Symposium on Computer Science Education, pp. 284-289, 2018. [18]Fangohr, H., O'Brien, N., Prabhakar, A. and Kashyap, A., 2015. “Teaching Python programming with automatic assessment and feedback provision,” arXiv preprint arXiv:1509.03556. [19]D. Radošević, T. Orehovački, and A. Lovrenčić, “Verificator: educational tool for learning programming,” Informatics in Education, vol. 8, no. 2, pp. 261-280, 2009. [20]G. E. Forsythe, and N. Wirth, “Automatic grading programs,” Communications of the ACM, vol. 8, no. 5, pp. 275-278, 1965.