Chapter 4: Beyond the Console
The morning sun had just begun to creep through the frosted windowpanes of Room 201 when Professor Dumlao entered, his gait brisk and slightly hurried. His tie was loosened, and a manila envelope peeked out from beneath his arm. The students straightened up in their chairs as he stepped in, a silent tension spreading through the room like ripples on still water.
"Alright, listen up," Dumlao said, placing the envelope on the desk with a soft thud. "I've got a department meeting this morning. Budget review. Thrilling stuff."
A soft chuckle passed through the room. Lester gave Emil a playful nudge, while Cabs was already doodling on the edge of his scratch paper.
"But," Dumlao continued, raising a finger, "this doesn't mean you get to slack off."
Groans rumbled from a few corners of the room. Elias remained silent, flipping his pen through his fingers.
"There will be a performance task this quarter—an individual project," Dumlao said, his tone sharpening. "You'll have four days to develop a functioning system based on the fundamentals we've covered—loops, conditionals, arrays, data handling. You may use any structure you're comfortable with, but your solution must be executable, presentable, and complete."
He paced slowly in front of the whiteboard. The room grew quieter.
"On the 5th day which is on friday this week, each of you will present your system to the class—alongside a panel of instructors from this department. Possibly even the department head, if his schedule allows."
A few gasps and awkward shuffles spread through the rows.
"This isn't just a graded project," Dumlao continued. "It's your chance to prove that you understand what we've been doing—not just writing syntax, but building something that works. Something that solves a problem. Clean structure, proper logic, clear user interaction. I want more than just output—I want intent."
He paused, letting the words sink in.
"And for the top scorer—there will be a reward. A direct exemption from the midterm exam."
That got their attention.
Even Jayson, who had spent the past week barely staying awake, sat up straighter. Emil whispered to Lester, "Bro, this is it. I'm gonna do the cleanest loop-based menu system ever."
"Today's a self-study session," Dumlao added, collecting his laptop bag. "Use the time wisely—or don't. Just remember: the challenge will test not only correctness but your understanding, organization, and presentation. Impress me."
He paused at the door, gave one final glance, and added, "Dismissed until after lunch. I'll be checking on progress then."
As soon as the door closed, a buzz of conversation broke out.
Most of the class opened their laptops and began reviewing their notes, sticking to what they knew: loops, conditionals, maybe a switch statement or two. For the rest, it was a casual morning—watch a YouTube tutorial here, drink a coffee there.
But Elias quietly packed his bag.
The university library was vast and mostly empty. Morning light poured through the tall windows, catching dust motes in its golden beam. Elias made his way to the second floor, away from the scattered groups whispering over textbooks.
He found an isolated desk nestled between shelves on software engineering and data systems. The perfect place.
He sat, powered on his laptop, and opened a fresh notebook beside it.
The foundational programming they'd covered—the "console app" world—was something he had already mastered. Arrays, conditionals, for-loops. It was all predictable. But the world beyond that? That intrigued him.
"What if I could build a system—a real student record application?"
One part would allow users to add and view student data. But what if he could also calculate GPAs dynamically? And what if, instead of being stuck in the console, the system had an actual interface—a web page, even a standalone desktop app?
He cracked his knuckles.
First step: research.
He opened a browser and began scouring articles on ASP.NET MVC. The Model-View-Controller pattern sounded daunting, but as he read, he began seeing the elegance in its structure.
The Model represented the data—what the system knew.
The View handled how things looked—what the user saw.
The Controller was the bridge between them—deciding what to do based on input.
I need a real data layer," he muttered, eyes narrowing as he opened the Package Manager Console.
He decided to use Entity Framework Core, the most accessible ORM (Object-Relational Mapper) for C# development. He installed EF Core through NuGet, choosing a SQLite provider for simplicity—lightweight, local, and perfect for a solo project without external dependencies.
He scribbled diagrams in his notebook—arrows between boxes, pages linked with action flows. A student management page. An add-form view. A GPA calculator function.
As he read more, he stumbled across something intriguing: the possibility of integrating Windows Forms with an ASP.NET MVC project—not directly embedded, but functioning alongside. A hybrid. Web for data entry and display; desktop for focused calculation.
"What if I could trigger a Windows Form from the web app?"
This was beyond anything covered in class—but it wasn't beyond him.
The system was quiet today—no glowing pop-ups or audible alerts—but Elias still felt the effects. His comprehension was heightened, his recall sharper, his ability to parse examples fluid.
Understanding the Architecture
Model-View-Controller.
The articles broke it down like a well-oiled machine. He drew diagrams in his notebook:
Model: Represents the data — in this case, student records.
View: The UI — HTML pages with forms, lists, and Bootstrap styling.
Controller: Logic that binds them — receives inputs, passes models, returns views.
Then, he opened Visual Studio and created a new ASP.NET MVC project using the "Empty" template. It felt barebones, but Elias preferred it that way. More control.
He scaffolded a models using EF Core:
public class Student
{
public int Id { get; set; }
public string FullName { get; set; }
public string Course { get; set; }
}
Next, Elias created a SchoolDbContext class that inherited from DbContext. He carefully configured the DbSet
Once the model was ready, he added the connection string in the appsettings.json, pointing to a local SQLite file. Then he ran:
Add-Migration InitialCreateUpdate-Database
Watching the output in the console, he felt a rush as the database was created, tables initialized, and everything synced perfectly.
Now, his project was no longer just a UI and logic—it had a heartbeat. Real, persistent data would now flow through his system.
He created a controller, StudentController.cs, and added a static list to simulate a database:
private static List
In Index(), he returned the full list to the view. In Add(), he created a form to add new entries.
Then came the Views. HTML mixed with Razor syntax. He pulled in Bootstrap to ensure responsiveness. Text fields had input validation, dropdowns snapped into place, and form groups aligned neatly.
The Windows Forms Bridge
In a separate solution, he booted up a Windows Forms App.
This part would host a GPA Calculator.
A dark-themed form. Two columns: Subject and Grade. Below it, a "Calculate GPA" button. And finally, a result label.
He added a DataGridView for input, a button for execution, and styled the form with a modern UI pack. Not flashy, but it felt professional.
The logic?
private void btnCalculate_Click(object sender, EventArgs e)
{
var grades = new List
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if
(row.Cells[1].Value != null && double.TryParse(row.Cells[1].Value.ToString(), out double grade))
{
grades.Add(grade); } } double gpa = grades.Average(); lblResult.Text = $"GPA: {gpa:F2}";
}
He compiled it to an executable: StudentGpaForm.exe.
Back in the MVC project, he wired a controller method:
public IActionResult LaunchCalculator()
{
Process.Start("StudentGpaForm.exe");
return RedirectToAction("Index");
}
With his development environment open, Elias began by creating a clean ASP.NET MVC project in Visual Studio.
He spent time organizing folders carefully: separating models, views, and controllers. He added Bootstrap to the layout for responsiveness—no plain white screens. He envisioned a sharp, dark-accented UI with crisp form elements and feedback messages. Something that looked like it belonged in a real business system.
As he laid out the structure, his thoughts were precise.
"Students should be able to view a list of records."
"They should be able to add new entries with full name and course."
"The data should persist for the session."
Next, he focused on the Add Student page. Instead of simple text boxes, he used dropdowns for course selection and added live input validation through Bootstrap classes. Small details, but they made the form feel alive.
As he wired up the Add functionality, he tested repeatedly, watching how his system behaved. Every input field was considered. He added confirmation messages, styled alerts, and clean navigation between views. It wasn't just working—it felt polished.
A single button on the web app would launch the GPA calculator for local use.
A bridge. Two interfaces. One system.
Testing and Tweaking
The entire system took form like a symphony.
He checked flow: Adding students on the web worked flawlessly. The GPA calculator launched smoothly.
The UI was intuitive: A welcome page, a list of current students, an "Add Student" form, and a "Launch GPA Tool" button.
He took screenshots, saved his work, and pushed the project to a USB stick and GitHub repo just to be safe.
Before closing his laptop, he paused—then smiled.
Ding![+1 Web Application Development][+1 Windows Forms Integration][Skill Tree Unlocked: UI Layering]Your designs begin to show polish beyond your level. Interfaces matter.
Walking Forward
He stood up, stretched, and packed his things.
It was almost noon.
His classmates were still in Room 201. Some had barely figured out how to get while(true) loops to break cleanly. Others were still writing basic menu systems.
And on friday, they would present.
Most would show functional, if basic, programs.
But Elias?
He would bring a system—two integrated apps, clean UI, data flow, and real interaction.
He descended the steps of the library slowly, the sunlight bouncing off his ID lanyard. He wasn't just playing the same game anymore.
He was building something different.