Text mining final project

Introduction

Educators today are increasingly required to adapt to rapid technological advancements while maintaining effective teaching practices. In the context of computer science education, many educators turn to online forums for self-directed learning, sharing challenges, seeking advice, and exploring emerging pedagogical tools. This study focuses on understanding how computer science educators navigate professional growth and self-learning in a dynamic educational landscape.

Purpose and Data Sources

This study examines how computer science educators engage in self-directed learning by analyzing discussions from the Computer Science Educator Stack Exchange forums. Posts tagged with themes such as “self-learning” were collected to explore how educators express their learning goals, share challenges and successes, and seek resources for professional growth. To capture broader community patterns, the most viewed and commented posts were also included. Only publicly available posts were used, and no personal identifiers were collected, ensuring ethical research practices.

Research Questions

• What are the most prevalent themes or discussion topics within self-learning–related posts in CS educator forums?

• How do educators describe their motivation for ongoing self-learning and professional development

• What sentiments, challenges, and support needs are expressed by educators around fostering self-regulated learning (SRL)—either for themselves or for their students?

Load library

library(tidyverse)

── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
✔ dplyr     1.1.4     ✔ readr     2.1.5
✔ forcats   1.0.0     ✔ stringr   1.5.1
✔ ggplot2   3.5.2     ✔ tibble    3.2.1
✔ lubridate 1.9.3     ✔ tidyr     1.3.1
✔ purrr     1.0.2     
── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
✖ dplyr::filter() masks stats::filter()
✖ dplyr::lag()    masks stats::lag()
ℹ Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors

library(readxl)
library(tidytext)
library(textdata)
library(stm)

stm v1.3.7 successfully loaded. See ?stm for help. 
 Papers, resources, and other materials at structuraltopicmodel.com

library(textclean)

df <- read_excel("~/Desktop/Final text mining project/Copy of Posts cs.xlsx", col_types = "text")

Data wrangling

Before tidying the data for tokenization, I will first explore the most viewed and commented posts to gain a general understanding of the topics that teachers in this forum tend to focus on

df_filter <- df |> filter(
    grepl("<self-learning>", Tag, ignore.case = TRUE) )

text_data <- df_filter |>
  select(Text, CreationDate,ViewCount,CommentCount,Tag,Id)  

text_data

# A tibble: 156 × 6
   Text                          CreationDate ViewCount CommentCount Tag   Id   
   <chr>                         <chr>        <chr>     <chr>        <chr> <chr>
 1 "<p>One common concern many … 42958.65512… 402       2            <sel… 3208 
 2 "<p>I'm a student in an unde… 43229.17235… 2305      3            <sel… 4734 
 3 "<p>A big problem of learnin… 42967.75230… 2341      1            <sel… 3266 
 4 "<p>What is the best way to … 42931.81961… 3688      2            <sel… 2687 
 5 "<p>I'm reading quite a bit … 42930.96541… 108       1            <cur… 2658 
 6 "<p>I am learning  various t… 42938.80774… 76        0            <sel… 2844 
 7 "<p>A student studying Compu… 43124.89000… 345       2            <res… 4252 
 8 "<p>I was reading Ben Frankl… 43068.97645… 458       0            <sel… 4002 
 9 "<p>I am looking to start a … 43050.66617… 112       0            <sel… 3953 
10 "<p>Tl;dr - the subject is e… 44194.66877… 274       4            <sel… 6707 
# ℹ 146 more rows

top_viewed <- text_data |>
  arrange(desc(ViewCount)) |>
  slice_head(n = 3)


top_viewed

# A tibble: 3 × 6
  Text                           CreationDate ViewCount CommentCount Tag   Id   
  <chr>                          <chr>        <chr>     <chr>        <chr> <chr>
1 "<p>I am self learning operat… 45601.18196… 99        4            <sel… 8156 
2 "<p>One thing that I am very … 44511.30764… 98        8            <sel… 7113 
3 "<p>This question is botherin… 44718.46668… 9266      9            <sel… 7437 

top_commented <- text_data |>
  arrange(desc(CommentCount)) |>
  slice_head(n = 3)

top_commented

# A tibble: 3 × 6
  Text                           CreationDate ViewCount CommentCount Tag   Id   
  <chr>                          <chr>        <chr>     <chr>        <chr> <chr>
1 "<p>I'm still student in univ… 44032.48089… 68        9            <sel… 6434 
2 "<p>I constantly have to stru… 42903.56203… 572       9            <bes… 754  
3 "<p>I'm a programmer, and I w… 43410.55323… 212       9            <sel… 5198 

This highly viewed and commented post clearly reflects a self-learning orientation, as the author expresses a dual learning goal—to both master Git for personal use and identify tools intuitive enough to support students aged 11–18 in learning version control systems.

Despite his extensive experience with other revision control tools (e.g., CVS, RCS, Subversion), the author underscores a desire to relearn Git, but only through more accessible, user-friendly, and consistent tooling.

Tidy data for Tokenization and sentiment analysis

text_clean <- text_data |>
  mutate(text = Text |>
           replace_html() |>                                
           tolower() |>                                     
           str_replace_all("[^a-z\\s]", " ") |>           
           str_squish()) 

afinn <- get_sentiments("afinn")
sentiment_afinn <- text_clean |>
  unnest_tokens (output=word, input=text) |>
  anti_join(stop_words, by="word") |>
  inner_join (afinn, by="word")

sentiment_afinn

# A tibble: 687 × 8
   Text              CreationDate ViewCount CommentCount Tag   Id    word  value
   <chr>             <chr>        <chr>     <chr>        <chr> <chr> <chr> <dbl>
 1 "<p>One common c… 42958.65512… 402       2            <sel… 3208  blind    -1
 2 "<p>One common c… 42958.65512… 402       2            <sel… 3208  stru…    -2
 3 "<p>One common c… 42958.65512… 402       2            <sel… 3208  comp…     2
 4 "<p>One common c… 42958.65512… 402       2            <sel… 3208  effe…     2
 5 "<p>One common c… 42958.65512… 402       2            <sel… 3208  hopi…     2
 6 "<p>I'm a studen… 43229.17235… 2305      3            <sel… 4734  stuck    -2
 7 "<p>I'm a studen… 43229.17235… 2305      3            <sel… 4734  fort…     2
 8 "<p>I'm a studen… 43229.17235… 2305      3            <sel… 4734  disc…    -2
 9 "<p>I'm a studen… 43229.17235… 2305      3            <sel… 4734  puni…    -2
10 "<p>I'm a studen… 43229.17235… 2305      3            <sel… 4734  ensu…     1
# ℹ 677 more rows

summary_afinn <- sentiment_afinn |> filter(value !=0) |>
  mutate(sentiment=if_else(value < 0, "negative", "positive")) |> 
  count(sentiment, sort = TRUE) |> 
  mutate(method = "AFINN") |>  mutate(total = sum(n)) |>  mutate(percent = n/total * 100)   

bing <- get_sentiments("bing")
sentiment_bing <- text_clean |>
  unnest_tokens (output=word, input=text) |>
  anti_join(stop_words, by="word") |>
  inner_join (bing, by="word")

summary_bing <- sentiment_bing|> 
  count(sentiment, sort = TRUE) |> 
  mutate(method = "bing") |>  mutate(total = sum(n)) |>  mutate(percent = n/total * 100) 

summary_sentiment <- bind_rows(summary_afinn,
                               summary_bing,)

summary_sentiment 

# A tibble: 4 × 5
  sentiment     n method total percent
  <chr>     <int> <chr>  <int>   <dbl>
1 positive    433 AFINN    687    63.0
2 negative    254 AFINN    687    37.0
3 positive    510 bing     915    55.7
4 negative    405 bing     915    44.3

ggplot(summary_sentiment, aes(x= method, y = percent, fill=sentiment)) +
  geom_bar(width = .8, stat = "identity", position ="dodge") +
  labs(title = "Public Sentiment", 
       y = "Percentage of Words") 

Sentiment analysis showed a predominantly positive tone, with 63% of words scored by AFINN and 56% by Bing classified as positive. Users expressed hope, persistence, and gratitude toward learning communities. However, a significant portion of negative sentiment (37% AFINN, 44% Bing) pointed to frustration with slow progress, lack of guidance, or difficulty transitioning from theory to practice—especially around complex topics like React, synchronization, and systems architecture.

Most negative and positive comments

post_sentiment <- sentiment_afinn |>
  group_by(Id,Text) |>
  summarise(sentiment_score = sum(value)) |>
  arrange(desc(sentiment_score)) 

`summarise()` has grouped output by 'Id'. You can override using the `.groups`
argument.

head (post_sentiment)

# A tibble: 6 × 3
# Groups:   Id [6]
  Id    Text                                                     sentiment_score
  <chr> <chr>                                                              <dbl>
1 7536  "<p>I have some students who will major in CS next year…              22
2 7827  "<p>I've to get FE exam to get licensed as an engineer …              17
3 6715  "<p>I am about to start my second semester of community…              13
4 6406  "<p>I am a student from CS background. I am currently g…              12
5 6542  "<p>I am involved in a website project, where main impl…              11
6 7621  "<p>How do you learn problem solving. Programming is al…              11

tail(post_sentiment)

# A tibble: 6 × 3
# Groups:   Id [6]
  Id    Text                                                     sentiment_score
  <chr> <chr>                                                              <dbl>
1 8169  "<p>This is how I plan to study:</p>\r\n<ul>\r\n<li><p>…              -6
2 3925  "<p>I'm a computer engineering student. I definitely ha…              -7
3 754   "<p>I constantly have to struggle with freeing myself f…              -9
4 7674  "<p>I have been learning rust since 2021. I followed di…              -9
5 7296  "<h2>Videos tutorials</h2>\r\n<p>When I start learning …             -10
6 6897  "<p>I am currently following the red dragon book:</p>\r…             -20

In the most positive comments, the author shares practical teaching strategies, curated links, and in-depth book recommendations to guide students pursuing computer science. The tone is definitely constructive, optimistic, and pedagogically reflective.

In the lowest-scoring negative post, the author expresses deep frustration with the Compilers textbook, citing its inaccessibility and ineffective writing style for self-learners. They even reference a strongly worded Goodreads review to support their perspective. The post clearly reflects personal struggle, but the use of phrases like “shoddy writing” and “doing a disservice” introduces a harsh tone, amplified by the frequent use of passive voice.

Preparing data for STM

temp <- textProcessor(documents = text_data$Text,
                           metadata = text_data,
                           lowercase = TRUE,
                           removestopwords = TRUE,
                           removenumbers = TRUE,
                           removepunctuation = TRUE,
                           stem = TRUE,
                           striphtml=TRUE)

Building corpus... 
Converting to Lower Case... 
Removing punctuation... 
Removing stopwords... 
Removing numbers... 
Stemming... 
Creating Output... 

Model

Finding K

Since it is difficult to determine the optimal number of topics for this dataset, it is better to use searchK, which specifies a range of values for k and outputs multiple goodness-of-fit measures. These measures are very useful for identifying a range of k values that provide the best fit for the data.

docs <- temp$documents 
meta <- temp$meta 
vocab <- temp$vocab 

set.seed(123) 

k_results <- searchK(documents = docs,
                     vocab = vocab,
                     data = meta,
                     K = c(5, 10, 15),
                     init.type = "Spectral",verbose = FALSE)

plot(k_results)

While the held-out likelihood continued improving up to k = 10, the semantic coherence peaked at k = 6 and declined sharply afterward. Additionally, residuals were lowest at k = 6 and increased with more topics, suggesting that adding more topics would overcomplicate the model without meaningful gains.

stm_model <- stm(documents = docs,
                 vocab = vocab,
                 K = 6,
                 data = meta,
                 init.type = "Spectral",,verbose = FALSE)

plot.STM(stm_model, n = 5)

After running the initial topic model with only standard stopword removal, the outputs still contained high-frequency but semantically uninformative words such as “will” and “can.” These words, although not common stopwords in general English, offer little value in distinguishing topics in the context of educators’ discussions. Therefore, a customized stopword list was developed to remove these additional filler words, improving the coherence and interpretability of the topic modeling results.

custom_stopwords <- c("can", "will", "like", "want", "learn", "one", "book")


text_data <- text_data |>
  mutate(Text_clean_2 = Text |>
           str_remove_all(paste0("\\b(", paste(custom_stopwords, collapse = "|"), ")\\b")) |>  
           str_remove_all("<[^>]+>")|>         
           str_remove_all("http[s]?://\\S+")        
         )

temp_2 <- textProcessor(documents = text_data$Text_clean_2,
                        metadata = text_data,
                        lowercase = TRUE,
                        removestopwords = TRUE,
                        removenumbers = TRUE,
                        removepunctuation = TRUE,
                        stem = TRUE,
                        striphtml = TRUE)  

Building corpus... 
Converting to Lower Case... 
Removing punctuation... 
Removing stopwords... 
Removing numbers... 
Stemming... 
Creating Output... 

Explore

docs <- temp_2$documents 
meta<- temp_2$meta 
vocab<- temp_2$vocab 

stm_model_2 <- stm(documents = docs,
                 vocab = vocab,
                 K = 6,
                 data = meta,
         verbose = FALSE)

plot.STM(stm_model_2, n = 8)

labelTopics(stm_model_2, n = 10)

Topic 1 Top Words:
     Highest Prob: question, read, problem, time, text, use, find, comput, exampl, paper 
     FREX: macro, paper, graph, page, text, address, cach, color, vulkan, focus 
     Lift: alias, confer, incomprehens, lucki, macro, min, opengl, shoddi, signific, -encompass 
     Score: macro, quantum, text, mnemon, graph, vulkan, cach, color, address, distract 
Topic 2 Top Words:
     Highest Prob: learn, program, python, start, know, basic, cours, java, data, read 
     FREX: python, deitel, java, start, learn, basic, program, object, structur, rust 
     Lift: mix, ’ve, account, algo, antisens, apolog, arduino, aris, asynchroni, attach 
     Score: handl, deitel, rust, taocp, excel, subqueri, object, orient, undergrad, right 
Topic 3 Top Words:
     Highest Prob: comput, edit, read, use, text, quit, understand, now, concept, book 
     FREX: edit, gpu, architectur, dragon, seri, hardwar, ullman, dec, quantum, quit 
     Lift: aho, bulki, feb, hardcor, hardwar, hardwaresoftwar, recal, rough, ullman, window 
     Score: quantum, dragon, text, dec, prerequisit, ullman, gpu, hardwar, gnulinux, portion 
Topic 4 Top Words:
     Highest Prob: system, comput, know, scienc, cours, studi, databas, oper, network, concept 
     FREX: system, distribut, network, databas, oper, secur, ive, design, manag, sql 
     Lift: linux, statist, titl, “get, ada, admin, affili, aggreg, andor, ant 
     Score: distribut, network, system, ast, secur, databas, strategi, purchas, titl, oper 
Topic 5 Top Words:
     Highest Prob: student, comput, program, develop, scienc, need, problem, skill, code, year 
     FREX: student, gtgt, variabl, skill, improv, develop, record, array, function, order 
     Lift: “cs”, “cys”, affect, alumini, analyz, android, argument, asker, attribut, bash 
     Score: gtgt, record, variabl, array, bright, int, letter, struct, display, definit 
Topic 6 Top Words:
     Highest Prob: program, languag, comput, scienc, book, resourc, use, tutori, good, recommend 
     FREX: site, tutori, resourc, languag, css, javascript, tri, recommend, standard, concurr 
     Lift: academia, -call, -tier, absolut, achiev, action, alan, anniversari, ansi, approv 
     Score: demo, concurr, comparison, css, react, quotth, carv, bootstrap, academia, compet 

tidy_stm <- tidy(stm_model_2) 


top_terms <- tidy_stm |>
  group_by(topic) |>
  slice_max(beta, n = 10, with_ties = FALSE) |>
  ungroup() |>
  arrange(topic, -beta)


top_terms %>%
  mutate(term = reorder_within(term, beta, topic)) |>
  ggplot(aes(beta, term, fill = as.factor(topic))) +
  geom_col(show.legend = FALSE) +
  scale_y_reordered() +
  facet_wrap(~ topic, scales = "free_y", ncol = 3) +
  labs(
    title = "Top 10 Words in Each STM Topic",
    x = expression(beta ~ " (Word Probability in Topic)"),
    y = NULL
  ) +
  theme_minimal(base_size = 12)

findThoughts(model = stm_model_2, texts = text_data$Text_clean_2, topics = c(1:6), n = 1)

 Topic 1: 
     (Note: related question here, not duplicate.)

I'm reading quite a bit about quantum computing, especially optical quantum computing. Part of the problem is even the all-encompassing bible of quantum computing (Nielsen and Chuang, Quantum Computing and Quantum Information) has only 10 pages on this particular physical realization. Other textbooks, by the time they're published, are already out of date. Hello, reading scientific papers!

Of course, there's a problem associated with that - results are retracted, new ones encompass and expand upon old, and papers are rather notorious for being difficult to slog through. Having slogged through a few myself, I  tell you that notoriety is well-deserved. Worse (for the self-learner), most papers are focused on only a specific problem.

As in, I've read 10 pages of incomprehensible text before (think half an hour for the 10 pages, if I'm really, really lucky) just to figure out  fact, and then looked at another paper that casts doubt on that fact. Add the whole issue of paywalls to the business, and it only gets worse. (I'm not a university student, though I am lucky enough to be within driving distance of a decently sized university, but not everyone is.)

Papers often lead me down rabbit holes as well - tracing citations (I could tell a few entertaining stories about that alone), looking up terms ("oh, that's what you meant...well, why didn't you say that?"), and going down that oh-so-fun Wikipedia trail. You know, look up word, read third word on page, click on that, then continue until somehow you end up at philosophy (ironically, the previous page doesn't end up at philosophy, if I did it correctly).

How  learning from papers be made a little less painful? Things :


What tips do you have to get the most bang for your buck reading a paper and retaining that understanding? 
How do you help restrain the rabbit hole?
How do you know when a paper's trustworthy?


Answers don't need to cover all of the above, but be along those lines. 
 Topic 2: 
     At first I  say, I known some basics Python and Haskell. For now I decided to follow my programming road with Python. I have chosen a few issues and their learning path, hence I would  to know if they  be a good way to get to know Python programming language better, with the implementation of algorithms including languages, with the implementation and knowledge of data structures and modules and frameworks. 

Also I would  to ask what should I add to my list or delete? Of course, the issues  be mixed up so that you do not  only data structures all day long and maybe it is a good idea? Additionally, I would  to know if additional projects or exercises are needed in all situations? I know that some issues are very easy and after reading I am able to notice the problems, advantages, disadvantages or exemplary implementation that arise.

If I have mistaken the forum, I am sorry and I am asking for appropriate redirection.

So the list looks :

Programming and some other derivatives


Object-oriented


Classes
Objects
Interfaces
Abstraction
Encapsulation
Polymorphism
Inheritance


Duck Typing

SOLID rules


 responsibility
open + closed
substitutions Liskov
segregation of interfaces
reversing dependencies

Tests


Unitary
Functional
Integration


Monkey Patching
REST


HATEOAS

PEP8
MOCKS
VirtualENV
Asynchrony
Python Idioms


Decorators
Gneratory
Mapping
Meta class

Any other things from Python


Mutable and immutable objects
__init__
__str__
iteration
self

MVC


MVT



Frameworks


flask
pandas
tornado
django (basics)


Patterns
ORM



Modules


NumPy


Database


NoSQL


MongoDB

SQL


MySQL



Additional items


Git
Docker


Project patterns


Observer
Builder
Facade
Factory
Singleton antisense


Data structures


Basics


Stack
Queue
List


One directional
Two-directional
With the sentry

Trees


Binary
Binary searches
BSP
AVL
T
B

Graphs



Algorithms


Operating principles


divide and conquer
greedily
dynamic
linear

Techniques


procedural
recursive
object-oriented

Sorting


Bubble
Insertion
Quick
Merge

Search


Linear
Binary

Graphs


Dijkstra
DFS
BFS
Kruskal
Prim

Data mining


C4.5
k-means

 
 Topic 3: 
     Whenever I searched for "best  for computer architecture" in google, the first result to come up was this  "Computer Architecture : A quantitative approach"(3rd Edition) by Henessy and Patterson.



The said  seems to be quite popular and is followed as the text  in many colleges throughout the world. Even the amazon reviews of the said  is quite good. Now many people said me that the 3rd edition is better than the 4th edition and though the 5th edition of the said  is out now, I could get hold of a cheap used copy of the 3rd edition. 

There is an introductory text pertaining to "Computer Organization" by the said authors, which is quite easy (and not bulky) and   easily go through it without much effort as this very organization  starts from the very basics.

Now coming to my question. How should I read this , Computer Architecture: A Quantitative Approach for the first time ? There are quite a few things I  to add, the  is quite bulky and the language and terminology (till the end of first chapter) is not quite easy as in the very first chapter of the  the author talks about things such as trace driven simulation,embedded benchmarks and so on, and I feel that the author assumes  is quite familiar with concepts,as is evident from the way the text is written in the first chapter. I have not yet started reading the second chapter. There are few more things, in each chapter the author talks about real life examples of the processors or the other hardware and gives a case study of the same. Though it is good for better understanding, but might be of more importance in the subsequent reads, after  has gone through the basics or the core sections in each and every chapter.

Now I  to know how  I read this very  for the first time, to build my concepts,(I  to sort of  only the necessary and sufficient concepts of each and every chapter, in depth though in the first reading) and after having a more or less rough but deep idea of the content of the entire , I  to read the  again in totality, reading the portions which I might have skipped in the first read. The above  is quite bulky (I am not afraid of that, had it been so, I would not even bought it) and chances are there that I might get lost till I read the  entirely. 

So  a schedule be suggested to me, which I shall follow to read the , I  a schedule or a routine, which I shall follow in a hardcore manner while my first read, with selected but important necessary and sufficient topics from each chapter and a well ordering of the same.( Sort of programming the playback of old video compact discs on VCD players,such that out of the many tracks only those are played and in the order in which I program my player).

I did not face such a problem while reading a textbook before, I have read many texts  Ullman's Automata, Tenenbaum's Data Structure, even Morris Mano's Computer System Architecture... I have even gone through the lecture series by Prof.  Rajeev Balasubramonian to build the foundations which uses the 5th edition of the said text

Now I  to focus on reading the text. Any help shall be highly appreciable.
If any part of my post is not correct or my tags are incorrect, do rectify me. 
 Topic 4: 
     I've to get FE exam to get licensed as an engineer in Nepal. I  to  everything properly because I feel I didn't  to the extent that I could in college. My first hitlist is operating system and Database Management System as these two are also little bit used in my job(Linuxadmin job that requires some bit of sql)
What's the best  about operating system? In college I read tanenbaum and hated every pages of it because it didn't go to much handholding that I wanted. I am weird because I  handholding in  that assumes I've no preriquisites while teaching. I don't need to make an operating system. Just clear my fundamentals and become an operating system knowledgeable person. Likewise I read computer networks by stallings and I was quite meh about it. The  was good in pieces and definitely better writing than tanenbaum but I'm not exactly impressed.
I've tried the  "Linux with Operating system concepts" and didn't find it good. I'm a hands on person nowadays so would love a  that has good exercises. When I say hands on, I don't  books that teach Linux. I already know Linux commands. I explicitly  to study the operating system fundamentals  process synchronization, memory management, secondary storage working etc.
The other  is by Galvin. But silber something also wrote this and I didn't  his DBMS .
​There was 1 good  when I was in college I don't remember. If it was 3 easy pieces or something. It had dinosaurs in it. Probably galvin .
Anyway, recommend me? I  also purchase a competitive exam practice questions  for GATE which is the toughest exam for engineering computer science.
About courses, I found NPTEL courses from top IITs too tough to understand. Are there any new online courses in the market at the moment. I studied operating system in college in around 2020.
Please recommend and help me in my journey. I also have purchased a course from Prateek jain academy which is well over 50+ hrs but I am failing to see any value in it.

These are the concepts that I  to study.
Although I'm studying for competitive exams, I explictly  to improve my knowlege in operating systems. Because I've found concepts of subjects  operating systems, computer networks, database management systems, distributed systems etc are very important in software and IT industry. Having basics of those strong is important. That's why I am studying all of operating systems(more than required in competitive exam)
PS I've already started learning  about Operating Systems from an online course that I said I bought. I am starting from synchronization and I'd be honest, it's tricky. Are there any tips to  this tricky concepts  this? I have had a hard time learning about tricky concepts  serializability in database as well. Any guidance  be extremely valuable. 
 Topic 5: 
     At my university, my fellow students and I cannot apply practical subjects well... For example, when we are asked to do a software project, we cannot analyze its requirements to know the steps that must be followed to do so, and we cannot translate what we learned in theoretical subjects into practical application easily... How  I develop? My skills are in the practical aspect of programming...and what are the best ways to raise my skills in practical applications of computer skills in general?
The project requirements were:

Computer Programming 2: Final Project
Make a C++ program to manage students records and grades. Every student record must have:

id >> a variable of type: int.
first_name >> a variable of type: string, this variable should contain letters only [shouldn’t contain any numbers and special
characters], and the first letter should be capitalized.
last_name >> a variable of type: string, this variable should contain letters only [shouldn’t contain any numbers and special
characters], and the first letter should be capitalized.
major >> a variable of type: string, this variable should contain  of the following values (“IT”, “IS”, “CS”, “CYS”) all letters
should be capitalized.
level >> a variable of type: int, should be from 1 to 4 only.
marks[] >> an array of type: int, the content of each index in the array  represent the marks of  subject which  be between 0
– 100.
size >> a const variable of type: int, should be 6 [ no need to ask the user ] this would be the size of the marks[] array.
total_marks >> a variable of type: int, which is the sum of all the subjects in the marks[] array. This means that the number in this
variable should be between 0 – 600.
grade >> a variable of type: float, this variable contains the result of dividing total_marks and size.
student >> an array of type: Student, the type you  create as a struct.

Software Requirements Specifications (SRS) :

The program should contain:

Functions: all of the program’s main operations should be done using functions.
Structs: the student  be created not as a single variable, but as a struct.
Arrays: as mentioned in the previous section, the marks  be an array. And you  also have an array of the student struct.
Files: the data in the program  be stored/restored from a file.
Header file: this is a library that you  create and make all of the functions and structs inside of it. Then you  include it in your project as well as some of the main built-in header files you   include such as iostream, … etc.


The Main Menu of your program should look something  this:

Add a new Student Record.
Edit a Student Record.
Delete a Student Record.
Search for a Student Record.
o Search by the student’s id
o Search by the student’s name
Display All of the Students Records.
o Display the students ordered by id.
o Display the students ordered by name.
o Display the students ordered by grade.
Exit.



 
 Topic 6: 
     I'm in the verge of giving up programming and wondering what could I do before I give up to make sure I did what everyone did.
I've a bachelors degree in computer science. I didn't do it as well as I'd have liked to do, but that degree has gave me familiarity with most terms used in basic programming.
I spent last 2.5 months working on web development(I'm learning MERN). I learnt html,css,bootstrap, javascript and react till date(In bootcamp), but I failed to  React. Even javascript, i'm no expert at. Even css, I learnt the basics but I'm not an expert when it comes to building half decent sites. Same for bootstrap. I  carve a site using html,css,bootstrap but it won't look good. I was completely  impossible to  when it came to react. Whenever I saw usage of useEffect and useState hooks and we start making changes in 10 different files for it, it confused me and I understood nothing.
I had access to world's best resources to  books, tutorials, blogs, youtube, udemy etc. I had access to forums  this to get help and support but still this was tough for me.
I feel unlucky, sad and hopeless atm. Friends who were weaker than me in conventional college studies and academia have done jobs and internships but I'm failing to even  something properly. I'm not jealous of them but just feel trash about myself.
People say do projects to  but I really don't know how that works. For eg:  This project. I make stupid stuffs  these and 't produce a good output that is playable. It's too hard for me.
These are some of my projects.





I did all these projects without looking any tutorials.
I keep forgetting how I built something time and again. I nowadays try my best to add documentation though.
I'm 70% sure to give up programming but still I"d  to make sure I follow advices from fellow forum users about it who've spent their life around programming.
In 3 months, I am seeing no progress, except few days :

When I carved a site on my own using html,css without looking tutorials.

When I carved a site on my own using bootstrap without looking tutorials.


My problems:

I've not break through'ed in programming. If I  make anything with javascript that's over 500 lines of code, I'd consider that a breakthrough. I'm aware LOC aren't a good metric but please try to understand what I'm trying to say. A big application using programming.

Even in css, I failed to make presentable sites. The coding bootcamp I feel is going too fast as well. Same for bootstrap, I made sites but I failed ot create beautiful sites. People recommend me frontendmentor.io but IDK what to do there? It looks sketchy to me. If there is something that  teach me css, I'd be so grateful.

After watching tutorials, I 't repeat what they've done in tutorial without watching the tutorial of project even though I understand each and every step they do in project.

I still am not fluent in ES6. I 't think in ES6. Arrow functions, map, reduce etc. I Understand them, but using them is different ballgame.


If you understand my situation, please guide me. I don't need roadmaps, any more tutorials but plain old guidance and advice on what to do by people who went through this situation

Communicate:

key findings and implications

1. What are the most prevalent themes or discussion topics across posts?

The STM analysis revealed several distinct themes among the self-learning discussions:

• Topic 2 centered around self-directed learning plans and technical mastery, particularly related to Python and frameworks such as Flask and Django. This reflects a strong focus on structured self-improvement through technology-specific pathways.

  Topic 4 emphasized foundational computer science topics like operating systems, databases, and system architecture, often in preparation for certification exams (e.g., FE). These posts express a clear intent to reinforce fundamental knowledge as a form of career development.

  Topic 5 highlighted a recurring challenge in bridging theory and practice—many learners expressed difficulty translating academic knowledge into hands-on software development skills.

2. How do educators describe their motivation for ongoing self-learning and professional development?

Motivations emerged most clearly in Topics 2 and 4, where users discussed self-learning as a way to stay competitive, fill gaps in prior formal education, or prepare for credentialing. Posts emphasized the importance of mastering not just tools (e.g., Python, Git, Docker) but underlying concepts (e.g., algorithms, object-oriented programming, SOLID principles), suggesting intrinsic motivation tied to deeper understanding.