Master Any Language Vocabulary with Flashy

21CSS101J – PROGRAMMING FOR PROBLEM-SOLVING

Mini Project Report

Submitted by

ISHITA SINGH [Reg. No.: RA2311003011452]

B.Tech. CSE - CORE
DHIRITI MAHAJAN [Reg. No.: RA231003011466]
B.Tech. CSE - CORE

SCHOOL OF COMPUTING
COLLEGE OF ENGINEERING AND TECHNOLOGY
SRM INSTITUTE OF SCIENCE AND TECHNOLOGY
(Under Section 3 of UGC Act, 1956)
S.R.M. NAGAR, KATTANKULATHUR – 603 203
CHENGALPATTU DISTRICT

November 2023

1|Page
 TABLE OF CONTENTS

S No. Title Page No.

1 Problem Statement 3

2 Methodology / Procedure/ Algorithm 4

3 Flowchart 5

6
4 Coding (C/Python)

7
5 Front-end code (HTML, CSS, Javascript) [Optional]

8
6 Modules of the proposed work

9
7 Results/Screenshots

11
8 Conclusion

12
9 References

2|Page
 1. Problem Statement

Problem: Language learners often encounter challenges in effectively acquiring and

retaining vocabulary, leading to suboptimal language proficiency and reduced
motivation for continued learning. Traditional language learning methods lack
interactivity and fail to provide a personalized and engaging experience, hindering
learners' ability to master the vocabulary of a new language.

Context and Background: In a globalized world where multilingualism is

increasingly valuable, the need for innovative language learning tools is evident.
Existing applications often fall short in delivering an enjoyable and efficient
vocabulary acquisition experience, prompting the development of a solution that
addresses these shortcomings.

Scope and Limitations: The project aims to develop "Flashy," a Python-based

language learning application focused on vocabulary mastery. The application will
have a scope encompassing a variety of languages with a comprehensive vocabulary
database. Limitations include dependencies on language datasets, potential
constraints in audio resources, and the need for cross-platform compatibility.

Impact and Consequences: Inefficient vocabulary learning can impede effective

communication and limit individuals in their personal and professional pursuits.
Addressing this problem has the potential to empower language learners, enhancing
their linguistic capabilities and contributing to a more connected and communicative
global community.

Stakeholders: Stakeholders in this project include language learners, educators,

developers, and designers. Users seeking an interactive and effective language
learning experience are directly impacted, while educators and language professionals
benefit from a tool that supports their teaching efforts.

Goals and Objectives: The primary goal is to create "Flashy," an application that
revolutionizes language learning by providing an interactive, personalized, and
efficient platform for mastering vocabulary. Objectives include implementing features
such as a spaced repetition algorithm, interactive quizzes, audio integration for
pronunciation practice, and user account management.

Constraints and Challenges: Budget constraints, time limitations, and potential

difficulties in accessing high-quality language datasets are anticipated challenges. The
development team must navigate these constraints to deliver a robust and effective
language learning solution.

Motivation for Solving the Problem: Efficient language learning is a key enabler
for personal and professional growth, fostering cultural understanding and breaking
down communication barriers. "Flashy" is motivated by the desire to empower
language learners, making the journey to language proficiency enjoyable and
effective.

3|Page
 2. Methodology / Procedure/ Algorithm

Developing "Master Any Language Vocabulary with Flashy" involves several steps,
methodologies, and algorithms to create an effective and engaging language learning
application. Below is a high-level outline of the methodology and procedures we are
following:

1. Define Requirements:
• Clearly define the functional and non-functional requirements based on
the problem statement. Identify the features, user interactions, and
system behaviour expected from Flashy.
2. Language Selection and Database Setup:
• Allow users to choose the target language.
• Set up a comprehensive vocabulary database for each selected language,
including words, phrases, translations, and audio pronunciations.
3. User Interface Design:
• Design an intuitive and visually appealing user interface using a suitable
GUI framework (e.g., Tkinter, PyQt, or Kivy).
• Include interactive elements for flashcards, buttons for quizzes, and
options for customization.
4. Flashcard Generation System:
• Implement a system to randomly select flashcards from the vocabulary
database.
• Provide options for customizing flashcards based on difficulty levels,
topics, or specific categories.
5. Spaced Repetition Algorithm:
• Integrate a spaced repetition algorithm to optimize the timing of flashcard
reviews. This algorithm should schedule reviews based on the user's
performance, reinforcing memory retention.
6. Audio Integration:
• Incorporate audio capabilities for pronunciation practice.
• Allow users to listen to correct pronunciations and record their own to
compare.
7. Interactive Learning Features:
• Enable users to flip flashcards to reveal translations, pronunciations, and
usage examples.
• Implement interactive elements such as drag-and-drop, voice recognition,
or typing exercises.
8. User Progress Tracking:
• Create a system to track and display the user's learning progress.
• Include visual indicators, statistics, and achievements to motivate users.
9. Quizzes and Assessments:
• Develop quizzes and assessments to reinforce learning.
• Provide instant feedback on quiz results and highlight areas that need
improvement.
10.Testing:
• Conduct thorough testing, including unit tests, integration tests, and user
acceptance testing.
4|Page
 3. Flow chart

Start

|
v
Collect words to learn
|
v
Create Flashy cards
|
v
Review cards regularly
|
v
Move cards to "Easy" pile when mastered
|
v
Remove cards from "Easy" pile when no longer needed
|
v
Continue reviewing cards until all words are mastered
|
v
End

5|Page
 4. Coding (C/Python)

from tkinter import *

import pandas
import random

BACKGROUND_COLOR = "light green"

data = pandas.read_csv("data/french_words.csv")
to_learn = data.to_dict(orient="records")
current_card = {}

def next_card():
global current_card, flip_timer
window.after_cancel(flip_timer)
current_card = random.choice(to_learn)
canvas.itemconfig(card_title, text="French", fill="black")
canvas.itemconfig(card_word, text=current_card["French"], fill="black")
canvas.itemconfig(card_background, image=card_front_img)
flip_timer = window.after(3000, func=flip_card)

def flip_card():
canvas.itemconfig(card_title, text="English", fill="white")
canvas.itemconfig(card_word, text=current_card["English"], fill="white")
canvas.itemconfig(card_background, image=card_back_img)

window = Tk()
window.title("Flashy")
window.config(padx=50, pady=50, bg=BACKGROUND_COLOR)

flip_timer = window.after(3000, func=flip_card)

canvas = Canvas(width=800, height=526)

card_front_img = PhotoImage(file="images/card_front.png")
card_back_img = PhotoImage(file="images/card_back.png")
card_background = canvas.create_image(400, 263, image=card_front_img)
card_title = canvas.create_text(400, 150, text="Title", fill="black", font=("Ariel", 40,
"italic"))

6|Page
card_word = canvas.create_text(400, 263, text="Word", fill="black", font=("Ariel", 60,
"bold"))
canvas.config(bg=BACKGROUND_COLOR, highlightthickness=0)
canvas.grid(row=0, column=0, columnspan=2)

cross_image = PhotoImage(file="images/wrong.png")
unknown_button = Button(image=cross_image, highlightthickness=0, command=next_card)
unknown_button.grid(row=1, column=0)

check_image = PhotoImage(file="images/right.png")
known_button = Button(image=check_image, highlightthickness=0, command=next_card)
known_button.grid(row=1, column=1)

next_card()

window.mainloop()

5. Modules of the proposed work

1. tkinter:
• Tkinter is the standard GUI toolkit that comes with Python.

2. pandas:
• Pandas is a powerful data manipulation and analysis library for

Python. In this code, it is used to read data from a CSV file.

3. random:
• The random module is used for generating random choices,

which is used here to select a random French word from the

dataset.
4. PhotoImage:
• PhotoImage is a class in the Tkinter library used to display

images on a Tkinter canvas.

5. Tk:
• Tk is the main class representing the Tkinter application.

6. Canvas:
• Canvas is a Tkinter widget used for drawing shapes, images,

and other graphical elements.

7. Button:
• Button is a Tkinter widget used to create buttons that can

trigger actions when clicked.

7|Page
6. Results/Screenshots

8|Page
9|Page
 7. Conclusion

1. Graphical User Interface (GUI):

• The code demonstrates the creation of a simple GUI using

Tkinter, showcasing the use of canvas, buttons, and images to

create an interactive flashcard interface.
2. Data Handling with Pandas:
• The pandas library is utilized to read data from a CSV file

containing French-English word pairs. This allows for easy

manipulation and organization of language data.
3. Random Word Selection:
• The 'random' module is employed to select a random French

word from the dataset for each flashcard, enhancing the

variety and unpredictability of the learning experience.
4. Image Handling with PhotoImage:
• The PhotoImage class is used to handle and display images on

the flashcards, adding a visual element to the learning

process.
5. User Interaction:
• Users can interact with the flashcards by clicking on buttons to

indicate their knowledge of the English translation. This

provides a simple mechanism for users to participate actively
in the learning process.
6. Scheduled Card Flipping:
• The application uses the after method to schedule the
automatic flipping of the flashcard after a certain time interval,
simulating a self-paced learning experience.
7. Limited Vocabulary Scope:
• The code focuses on a specific vocabulary dataset, and its

functionality is tailored to a simple "know/don't know" feedback

mechanism. Expanding the vocabulary or adding more
advanced features could enhance the application's capabilities.

10 | P a g e
 8. References
1. Tkinter Documentation:
• The official Tkinter documentation is an excellent resource for learning
how to create graphical user interfaces in Python. You can find it on the
Python official website.
2. Pandas Documentation:
• For understanding how to use Pandas for data manipulation and analysis,
refer to the official Pandas documentation.
3. Random Module Documentation:
• Information about the random module can be found in the official Python
documentation.
4. Educational Platforms and Forums:
• Websites like Stack Overflow, GitHub, and educational platforms like
Udacity, Coursera, or edX often have similar projects and code examples
shared by the community.
5. Online Python Communities:
• Explore Python communities such as Reddit's r/learnpython or the Python
Discord server, where developers share their projects and code for
learning and feedback.

11 | P a g e