I had a program like that once. It was
sophomore year, and I was in
Software Engineering at
WPI. We designed a distributed networking
protocol, with the correct
routing algorithms and such. It worked great on the small scale tests. Two clients, one router, one master
domain authority. It all worked great.
Now we had to add more clients.
I had a horrid
revelation at that moment.
It just can't work. The system is no where NEAR scalable. It would grow exponentially in size until it ate and destroyed all of the
WPI network. We thought about it with only two nodes in mind, but 50 interlinked nodes would cripple the hardware and make it
impossible to use. The beast of a software tracking program would be grossly inefficient even if we had all the memory in the
world.
So the next day in class, where we had to release a
beta of our "product" to the rest of the class, I, as the leader of the group got to inform the class that "the
program does not run within the constraints of the
school network", and that it still needed "
Some performance work". It was a mixed moment in my life, filled with the pride that a
tank engineer has when his or her baby first demolishes a
bus, but also filled with shame as I could not control the code I was writing.
To this day, I will always remember to include
scalability in my designs.