ASP.Net for dating software

The cursor blinked on the screen, a smug, pulsating little bastard, mocking me from within the bowels of Visual Studio. I was Mark, a soldier in the trenches of corporate software development, and my weapon of choice—or rather, the weapon forced into my hands—was ASP.NET. My current task was to extend the CustomerRelationshipManagementModule for a monolithic, soul-crushing enterprise application. The file I was in was called CustomerRelationshipManagementModuleViewPresenterController.cs. I am not joking. It was over five thousand lines of pure, uncut architectural astronautics.

My fingers hovered over the keyboard. I had to add a new field to a form: "Preferred Contact Method." A simple task. In any sane world, this would be a few lines of HTML and a corresponding model property. But here, in the Kingdom of Microsoft, it was a ritualistic pilgrimage through a labyrinth of abstraction.

First, I couldn't just add the property to the model. No. The model was a mere DataTransferObject, a hollow shell. The real business logic lived in a Domain Entity, which was accessed through a Repository interface, whose implementation was tied to an Object-Relational Mapper that translated everything into stored procedures in SQL Server. To add a single string property, I had to:

  1. Update the CustomerDomainEntity class.
  2. Update the ICustomerRepository interface.
  3. Update the SqlCustomerRepository implementation.
  4. Update the CustomerDataTransferObject class.
  5. Update the CustomerToCustomerDtoMapper class.
  6. Update the stored procedure sp_UpdateCustomer in the database project.
  7. Finally, and only then, could I touch the CustomerRelationshipManagementModuleViewPresenterController to pass the damn thing to the view.

The syntax was a study in verbosity. Everything was explicit, everything was sealed, everything was wrapped in a suffocating blanket of type safety that felt less like protection and more like imprisonment.

Look at this abomination for a simple property:

private string _preferredContactMethod;
public string PreferredContactMethod
{
    get { return _preferredContactMethod; }
    set
    {
        if (_preferredContactMethod != value)
        {
            _preferredContactMethod = value;
            OnPropertyChanged(nameof(PreferredContactMethod));
        }
    }
}

All that ceremony. All that boilerplate. Just to say "this object has a string." And God help you if you needed a collection. You'd be knee-deep in ObservableCollection<T> and INotifyPropertyChanged events, writing fifty lines of code to bind a dropdown list. The development stack was a gilded cage. You needed Windows Server. You needed IIS configured just so. You needed SQL Server, a behemoth that cost a fortune in licensing and demanded its own dedicated admin. You were chained to the Microsoft ecosystem, and every link was forged in gold-plated, enterprise-grade steel.

I was building castles in the sand for people who only understood how to pour concrete. My bosses, the "architects," spoke in tongues of "scalability" and "maintainability," all while the codebase became a terrifying, over-engineered Jenga tower that only a handful of high-priests could understand. I was a plumber, but instead of fixing leaks, I was designing ever-more-complex systems to pass a single drop of water from one end of a mansion to the other.

This hatred festered for years. It was a cold, professional loathing. But it was a stable loathing. It paid my mortgage.

Then, the idea came. It wasn't a bolt of lightning, but a slow, simmering realization born from my own frustration with the digital dating world. The apps were terrible. They were either superficial swipe-fests or, ironically, built on clunky, old-fashioned platforms. I knew about connection pools, state management, and database design. I could build something better. Something smarter. A place for people who didn't want to be reduced to a picture and a bio. I would call it "The Connectory." A place for genuine intellectual and emotional connection.

I fired up Visual Studio with a renewed sense of purpose. I would build my dream project with my familiar, if despised, tools. I created a new ASP.NET MVC project. The template generated a mountain of files: Web.config, Global.asax, packages.config, a Views folder with Web.config files inside it, an App_Start folder with BundleConfig.cs, FilterConfig.cs, RouteConfig.cs. It was like wanting to build a simple treehouse and being handed the blueprints for the Burj Khalifa.

I spent a week setting up the basic infrastructure. Entity Framework with a code-first approach. Identity for user management. I was making progress, but every step felt heavy, burdened by the sheer weight of the framework. I wanted to move fast, break things, iterate. But ASP.NET demanded deliberation, planning, and configuration. It was a supertanker; I wanted a speedboat.

The first major crack appeared when I considered deployment. To run my site, even in its infancy, I'd need a Windows VPS. They were significantly more expensive than their Linux counterparts. I'd need a license for SQL Server, or use the hobbled Express version. The cost, before I even had a single user, was already intimidating. This was my project, my dream, and Microsoft was standing at the door with its hand out, demanding tribute before I could even open for business.

One night, staring at a particularly gnarly LINQ query that was struggling to translate into efficient SQL, I snapped. I was trying to perform a simple join and filter operation. In my mind, I could see the clean, logical SQL it should produce. But Entity Framework, in its infinite "wisdom," was generating a monstrosity with OUTER APPLYs and a dozen nested subqueries. The performance was abysmal.

This was it. The shackles had to break.

With a grimace, I typed a new query into Google: "PHP MySQL simple user registration."

The results were a culture shock. Forum posts from 2005. W3Schools tutorials. It was the wild west compared to the sterile, policed state of the Microsoft Developer Network (MSDN). It was messy, it was chaotic, and it was… free.

I downloaded XAMPP, a single package that gave me Apache, PHP, and MySQL. It installed in minutes. I opened a simple text editor, Notepad++. No IDE, no solution files, no project structures. I created a file called register.php.

And I wrote:

$servername = "localhost";
$username = "root";
$password = "";
$dbname = "connectory";

// Create connection
$conn = new mysqli($servername, $username, $password, $dbname);

// Check connection
if ($conn->connect_error) {
    die("Connection failed: " . $conn->connect_error);
}
echo "Connected successfully";

I ran it. The browser displayed "Connected successfully." I was stunned. No Web.config connection strings. No Entity Framework context. No repository layer. Just… a connection. A direct line to the database. It was terrifying and exhilarating, like being handed the keys to a race car after years of driving a tank.

The hatred for ASP.NET now found a perfect counterpoint: the elegant simplicity of PHP. Every hurdle I faced in .NET had a seemingly trivial solution in PHP.

The Syntax War:

In C#, to read a value from a form, you'd use model binding, a powerful but sometimes opaque magic. In PHP, it was just $_POST['username']. Direct. Unapologetic. It felt dirty, like working with raw materials instead of pre-fabricated components. I loved it.

In ASP.NET, to loop through a list of users and display them, you'd use a GridView or a Repeater control, configuring data sources and templates, fighting with the page lifecycle.

In PHP, it was:

$sql = "SELECT id, username FROM users";
$result = $conn->query($sql);

if ($result->num_rows > 0) {
    // output data of each row
    while($row = $result->fetch_assoc()) {
        echo "id: " . $row["id"]. " - Name: " . $row["username"]. "<br>";
    }
} else {
    echo "0 results";
}

It was just… logic. HTML and logic, woven together. No postbacks, no viewstate, no page lifecycle. The page was a script. It started at the top and ended at the bottom. The sheer blasphemy of it was liberating.

My ASP.NET-conditioned brain screamed about SQL injection. So I learned about prepared statements.

$stmt = $conn->prepare("INSERT INTO users (username, email) VALUES (?, ?)");
$stmt->bind_param("ss", $username, $email);
$stmt->execute();

It was clean! It was safe! And it was still closer to the metal than Entity Framework would ever be. I felt like I was actually programming, not just wiring up components designed by a committee at Microsoft.

The more I built, the more the contrast became a source of dark, joyous humor. I'd imagine how my old team would implement a feature, and then I'd implement it in PHP in a fraction of the time and code.

Feature: User Login

It was crude. It was basic. But for my purposes, it was perfect. I wasn't building a banking application for ten million users; I was building a niche dating site that might, if I was lucky, have a few thousand.

The hatred for ASP.NET's infrastructure melted away as I embraced the LAMP stack. My entire operating cost was a $5/month DigitalOcean droplet running Ubuntu. I could deploy by zipping my PHP files and SCP-ing them to the server. No complex CI/CD pipelines, no IIS reset, no dealing with Windows Update rebooting my server at 3 AM.

I began to see the beauty in PHP's flaws. Its loose typing, which I had been taught to despise, allowed for rapid prototyping. A variable could be a string, then an integer, then an array, and it just… worked. In C#, I'd be drowning in type casting and conversion exceptions.

The $ symbol for variables, which I initially found ugly, became a badge of honor. It was a constant reminder that I was no longer in the land of strongly-typed, corporate-approved code. I was in the frontier.

I spent months in this state of euphoric rebellion. My dating site, "The Connectory," took shape. I built a sophisticated matching algorithm not based on silly questions, but on an analysis of a user's writing style. I'd have them write a short essay about something they were passionate about. My PHP script would then parse the text, counting word complexity, sentence length, use of punctuation, and vocabulary diversity. It was a complex piece of logic, involving arrays, string functions, and custom scoring.

Trying to implement this in C# would have involved creating a dozen new classes, interfaces for the text analyzers, dependency injection to wire it all up, and probably a whole new project in my solution just for the "TextAnalysisDomain."

In PHP, I wrote a single file called analyze_writing_style.php. It contained a few functions: calculate_lexical_density(), get_average_sentence_length(), find_favorite_punctuation(). It was all there, in one place. It was messy, it was procedural, and it was gloriously effective.

The day I quit my job was one of the most satisfying of my life. I didn't have a triumphant "I'm leaving to start my own business" speech. I simply walked into my manager's office, a man who loved to talk about "leverage" and "paradigms," and slid my resignation across his desk.

"I'm done," I said, my voice calm. "The abstractions have become unbearable."

He looked confused. "Abstractions? Mark, are you talking about the new ServiceLayerFacadeFactory? We can reassign that if it's too complex."

I just smiled. "No. It's not that one. It's all of them."

I walked out, leaving behind my dual monitors, my ergonomic keyboard, and my access card to the kingdom of concrete.

Now, I sit in my home office. The hum is not from a powerful desktop running Visual Studio, but from a quiet laptop. My IDE is VS Code, a lightweight editor that doesn't presume to understand my entire project structure. My server is a terminal window SSH'd into my Ubuntu droplet.

I am the master of my own stack. If there's a performance issue, I look at my SQL queries. If there's a logic error, I trace it through my PHP scripts. There is no black box, no magical framework doing things I don't understand. The chain of responsibility begins and ends with me.

The Connectory has a few hundred active users now. It's not making me rich, but it's growing. Every time I add a new feature—a real-time chat using WebSockets, a new filter for the matching algorithm—I do a little dance of triumph, a middle finger raised in the general direction of Redmond, Washington.

I recently had to look at some old ASP.NET code to help a friend. Opening Visual Studio felt like putting on a suit of armor I'd worn for a decade. The solution loaded, and I was immediately bombarded with using Microsoft.Framework.DependencyInjection.Abstractions; and namespace MyApp.BusinessLogic.DomainServices.Repositories.Interfaces.

I felt a physical wave of nausea. The verbosity, the layers, the sheer, oppressive weight of it all. I closed it after five minutes.

My friend asked, "So, can you see the issue?"

I replied, "The issue is that it's written in ASP.NET. Rewrite it in PHP."

I was only half-joking. The hatred hasn't faded; it has solidified into a core tenet of my programming philosophy. Life is too short for ICustomerRepositoryFactory. Life is too short for the ConfigureServices method in Startup.cs. Life is too short for the endless, soul-crushing ceremony of a platform that mistakes complexity for power.

Give me the raw, unadulterated chaos of PHP any day. Give me my $_POST and my $conn->query(). Give me my <?php and ?>. It’s not elegant, but it’s honest. And after years of building castles of abstraction for fools, honesty feels like the most powerful feature of all. I am Mark, an apostate of the Church of Microsoft, and I have never been more free. The server is light, the code is mine, and the syntax, for all its perceived flaws, is a beautiful, beautiful thing.

Back to ChameleonSoftwareOnline.com