Every once in a while, something from the early days of my software development journey resurfaces and brings with it a flood of memories. Recently, I came across a PlanetSourceCode.com archived GitHub page that lists some old code submissions I contributed more than 20 years ago.
Seeing my name there, attached to Visual Basic 6 and early .NET samples from 2002 and 2003, is a fun little time capsule.
The page lists a handful of submissions I posted under my name, including things like:
- Add Checkbox to MSFlexGrid Control
- VB6 Package and Deployment Wizard Notes
- Make Form Transparent on Move and Resize
- TextBox - Only Accept Numbers
- HTTP File Download using Winsock
These were small pieces of code. Utilities. Examples. Tips. The kind of thing you wrote because you had just solved a problem, and you figured someone else might eventually run into the same problem too.
Looking back now, what strikes me most is not necessarily the code itself. Some of it may have been interesting for the time. Some of it was probably rough. Some of it might make modern developers laugh a bit. But what really stands out is the era those submissions came from.
This was before GitHub.
This was before Stack Overflow.
This was before NuGet, npm, modern package managers, ubiquitous blogs, YouTube tutorials, Discord communities, GitHub Discussions, and all the other places we now take for granted when looking for programming help.
It was a different time.
Sharing Code Before GitHub
Today, sharing code is almost frictionless. You create a GitHub repository, push your project, add a README, attach a license, and share a link. Someone else can clone it, fork it, open an issue, submit a pull request, or star it. Search engines index it. AI tools can analyze it. Documentation can be generated. CI/CD can validate it. Package registries can distribute it.
None of that was normal back then.
In the early 2000s, if you wanted to share code, you had fewer options. You might post it on your personal website. You might attach a ZIP file to a forum post. You might paste snippets into a message board. You might email it to someone. Or, if you wanted it to be discoverable by other developers, you submitted it to a site like Planet Source Code.
Planet Source Code was one of those developer community sites that mattered a lot at the time. It was a place where programmers could upload code snippets, small applications, controls, samples, and tutorials. Other developers could browse categories, download code, rate submissions, and leave comments.
For many of us, it was one of the best ways to find practical examples of how to get something done.
There were books, of course. There were MSDN articles. There were mailing lists and forums. But a lot of day-to-day programming knowledge lived in shared examples. You searched for the thing you were trying to build, found someone else’s sample, downloaded it, opened it in Visual Basic, and started learning by reading the code.
That was the workflow. It never was the full solution you were looking for, but you pieced multiple snippets together, troubleshooted, and figure out the solution to get the job done.
The Visual Basic Era
A few of my submissions listed in the archive are Visual Basic 6 related, which makes perfect sense for that period of time. VB6 was everywhere. It was approachable, productive, and widely used for building Windows desktop applications. If you were building business applications on Windows, there was a good chance VB6 was involved somewhere.
One of my old submissions was titled Add Checkbox to MSFlexGrid Control. That alone brings back a whole category of memories.
The MSFlexGrid control was a common control used to display tabular data in VB6 applications. It was useful, but like many controls of that era, it did not always do exactly what you wanted out of the box. So developers found ways to extend it, work around it, and make it behave more like the applications they were trying to build.
Adding checkbox behavior to a grid was a very practical problem. Users wanted to select rows. Business apps needed to mark records as included or excluded. A native checkbox column would have been convenient, but if the control didn’t provide it exactly the way you needed, you built it yourself.
That was a very common pattern in VB6 development: take the controls you had, bend them to your will, and make the application work.
Another submission was HTTP File Download using Winsock. That one is also very representative of the time. Today, if you want to download a file over HTTP, you can do it in a few lines of code with modern libraries. In .NET, you might use HttpClient. In JavaScript, you might use fetch. In Python, maybe requests. It is ordinary now.
But back then, depending on the language, runtime, and environment, you might be working at a lower level. Using Winsock directly meant dealing more closely with network communication. You were sending requests, reading responses, parsing headers, and managing data yourself.
Was that the easiest way to download a file? Probably not by today’s standards. But it was educational. It forced you to understand what was happening under the covers.
That was one of the great things about a lot of old programming examples. They were not always polished libraries. They were often demonstrations of how something worked.
The Early .NET Days
A couple of the archived submissions are also from the early .NET period: Make Form Transparent on Move and Resize and TextBox - Only Accept Numbers. 2002 was still really early days for the .NET Framework.
Those titles immediately remind me of the excitement around .NET when it was new. Developers were moving from VB6 to VB.NET or C#. Windows Forms was new and familiar at the same time. It felt like a modernized version of the desktop development many of us already knew, but with a much more powerful framework behind it.
There was a lot to learn.
The .NET Framework introduced a different way of thinking about application development. Namespaces, assemblies, managed code, garbage collection, metadata, reflection, events, delegates, inheritance, and a richer base class library all became part of the daily vocabulary.
For developers coming from VB6, it was both exciting and disruptive.
Small code samples played a huge role in that transition. You might not need a full book chapter to learn how to restrict input in a textbox. You needed a clear example. How do I handle the key press event? How do I allow numbers but block letters? How do I still allow backspace? How do I account for edge cases?
That kind of practical knowledge spread through community code sites.
The same thing applied to UI effects like making a form transparent when it moved or resized. It was not necessarily mission-critical functionality, but it was the kind of small interaction that made applications feel more dynamic. Developers were experimenting with what Windows Forms could do, how far they could push it, and how to make desktop apps look and behave differently.
A lot of learning happened through experimentation.
Before Stack Overflow Changed Developer Q&A
It is hard to overstate how different programming help was before Stack Overflow.
Today, when a developer runs into a problem, they search the web and often find a Stack Overflow answer, GitHub issue, official documentation page, blog post, or AI-generated explanation. There is an enormous amount of indexed developer knowledge available almost instantly.
In the early 2000s, the web was much smaller and much less organized.
Search engines existed, of course, but finding the right answer could take time. Search results were inconsistent. Documentation was often incomplete or difficult to navigate. Many answers lived in forum threads, mailing list archives, Usenet posts, personal websites, or code-sharing portals.
You had to dig.
Planet Source Code helped because it was organized around code. You could browse by language and category. You could search for examples. You could see ratings. You could download complete projects rather than just read a few lines in a forum reply.
That mattered.
A complete working sample is often worth more than a description. When you can open a project, run it, step through it, and change it, you learn differently. You do not just copy code. You explore behavior.
That kind of hands-on learning shaped a lot of developers from that era.
Before Open Source Was So Social
Open source existed long before GitHub, of course. There were major open source projects, communities, mailing lists, source repositories, and collaboration models. But for many everyday developers, especially those working with Windows desktop tools like VB6, casual code sharing did not feel as standardized as it does now.
GitHub changed the social mechanics of code.
It gave developers a common place to host projects, track changes, report issues, contribute improvements, and build a public portfolio. It normalized the idea that your code could be visible, forkable, and collaborative by default.
Planet Source Code was not GitHub. It was more like a code gallery or community archive. You uploaded a ZIP file or source code submission. People downloaded it, rated it, and maybe commented. There was not the same workflow around version history, pull requests, branching, issues, or continuous improvement.
But it served an important purpose.
It made code visible.
It gave individual developers a place to contribute something useful, even if it was just a small snippet or demo. It let someone say, “I figured this out. Here is how I did it.”
That may sound simple, but it is one of the core ideas behind healthy developer communities.
The Early Days of Blogging
This was also around the early days of blogging.
Personal blogs were becoming a way for developers to share what they were learning. Instead of only publishing formal articles or posting in forums, developers could write directly on their own sites. A blog became a place to document discoveries, explain solutions, share opinions, and build a professional voice.
That was a big shift.
A personal blog gave you ownership over your writing in a way that a forum post or code submission did not. You could collect your thoughts, write tutorials, publish notes, and build an archive over time. Many developer blogs from that era were rough around the edges, but they were authentic. They were written by people solving real problems in real projects.
In many ways, code-sharing sites and blogs complemented each other.
A blog post could explain the context: what problem you ran into, what approaches you tried, what finally worked, and what caveats mattered. A code-sharing site could host the actual sample project for others to download.
Today, we might combine all of that into a GitHub repository with a README, maybe a blog post, and perhaps a package release. Back then, it was much more fragmented. You shared code in one place, wrote about it somewhere else, and hoped people could find it.
Still, it worked.
The web was smaller, but it felt personal.
Looking Back at Old Code
There is always a strange feeling when you look back at code you wrote decades ago.
Part of you wants to critique it. You see things you would do differently now. You notice naming choices, structure, formatting, assumptions, and patterns that reflect who you were as a developer at the time. You may even cringe a little.
That is normal.
But old code is also a record of growth. Every developer has a trail of things they built while learning. Small utilities. Experimental projects. Half-finished ideas. Demos. Workarounds. Snippets copied, modified, improved, and eventually understood.
Those old Planet Source Code submissions are part of my trail.
They represent problems I had solved, technologies I was using, and the way developers shared knowledge at the time. They also remind me that contributing to the community does not always have to mean building a large framework or maintaining a major open source project.
Sometimes it means sharing a small solution to a small problem.
And sometimes, 20 years later, that small solution is still sitting in an archive somewhere, quietly reminding you where you started.
The Value of Small Contributions
One thing I appreciate more now is the value of small contributions.
In modern software development, it is easy to think of open source in terms of big projects: popular frameworks, libraries with thousands of stars, cloud-native tools, massive ecosystems, and widely used packages. Those are important, but they are not the whole story.
Small examples matter too.
A sample that shows how to add a checkbox to a grid can help someone finish a business application. A note about package and deployment issues can save someone hours of frustration. A textbox input example can help a beginner understand events and validation. A Winsock file download demo can teach someone how HTTP works at a lower level.
Not every contribution needs to be grand.
Sometimes the most useful thing you can publish is the thing you just figured out.
That was true in 2002, and it is still true today.
The difference is that now we have better tools for sharing, preserving, and improving those contributions. GitHub repositories can evolve. Issues can capture questions. Pull requests can fix bugs. Discussions can add context. Package managers can distribute updates. Documentation sites can be generated automatically.
But the motivation is the same: help the next person.
Preservation Matters
I am also grateful that archives like this exist.
The original Planet Source Code website is no longer the central place developers go to share and discover code. The web has moved on. Technologies have changed. Communities have shifted. But the code and index pages preserved on GitHub offer a glimpse into that earlier era.
That kind of preservation matters because software history is often fragile.
Old websites disappear. Domains expire. File downloads break. Forum databases go offline. Personal sites vanish. Code that once helped thousands of people can become inaccessible almost overnight.
When old code is archived, it gives us more than nostalgia. It gives us context.
It shows what developers were building, what problems they were solving, what tools they were using, and how knowledge moved through the community. It also reminds us that today’s best practices are built on decades of experimentation, sharing, and iteration.
The specific code may be obsolete. The spirit behind it is not.
It Was a Different Time
When I think back to posting code on Planet Source Code, I remember a web that felt more handcrafted. Developer communities were smaller and more scattered. You learned by searching, downloading, experimenting, breaking things, and trying again.
There was less automation. Less polish. Less infrastructure.
But there was also a lot of curiosity.
People posted code because they were excited to share it. They wanted ratings, sure. They wanted feedback. But they also wanted to contribute to the pool of knowledge that everyone else was drawing from.
That culture helped shape how many of us learned software development.
Today, I can publish a GitHub repository in minutes. I can write a blog post, link to the repo, add sample commands, include screenshots, publish a NuGet package, and have everything indexed and available around the world almost immediately.
That is amazing.
But it is worth remembering that before GitHub made code sharing easy, sites like Planet Source Code helped fill that gap. They gave developers a place to participate. They made small contributions visible. They helped us learn from each other.
And for me personally, seeing those old submissions again is a reminder of where I came from as a developer.
I was solving problems, learning technologies, and sharing what I could.
More than 20 years later, that still feels like the right idea.
