1998: The Butterfly Landed on a Form
· 49 min read · Views --

1998: The Butterfly Landed on a Form

Author: Alex Xiang

Essays

The butterfly that flew around in the browser in 1997 landed on a form in 1998.

That sentence sounds a little disappointing.

A butterfly is light. The page moves, coordinates change, and the browser feels like a child just learning to walk: clumsy but excited. A form is heavy. Name, department, number, date, amount, status, approver, remarks, printing, searching, statistics. None of this is romantic. Some of it is even dull.

But what truly brought software into the daily life of most companies was often not the butterfly. It was the form.

In 1998, I began doing MIS development. MIS stands for Management Information System. Today the term feels old, even rustic. But at that time, it meant that a company, school, agency, or business department was seriously moving paper workflows into computers.

That was another side of software landing in the real world.

The browser told us the world was becoming larger. MIS told us that, after the world became larger, every form in the office also had to change.

Enterprise Informatization Was Not Cool Technology at First

Many histories of technology like to write about big events: browser wars, search engines, open source, operating systems, chips, and AI. Those things certainly matter. But for many programmers, the first things they encounter after beginning work are often not world-changing platforms, but one business system after another.

They may be called HR management systems, inventory systems, financial systems, customer-data systems, equipment systems, or teaching-management systems. Their names are not attractive, but behind each system is a real organizational workflow.

Who can enter data?

Who can modify it?

Who can approve it?

What happens when data is wrong?

What statistical definition should a report use?

Why does the print format not match the old paper form?

These questions remain central to enterprise software today. We merely wrap them in names such as SaaS, BPM, ERP, CRM, low-code platforms, and digital transformation. In 1998, they were often just called MIS.

The first lesson of MIS is to accept that users do not care how elegant your technology is.

Users care whether the form can be entered, whether tomorrow’s report for leadership can be printed, whether last month’s data can be found, whether permissions are correct, and whether a system failure will prevent them from leaving work.

This was completely different from the butterfly in 1997.

If the butterfly did not fly smoothly, it was only ugly. If an enterprise system got one piece of data wrong, someone could truly become anxious.

Why Delphi Is Still Remembered

To write about 1998 is to write about Delphi.

Delphi did not appear in 1998. Delphi 1 had already been released in 1995. By around 1998, Delphi 3 and Delphi 4 were familiar tools for many Windows desktop database-application developers.

For a long time afterward, I felt the best IDE of that era was Delphi.

This is not merely nostalgia.

Delphi’s usability was concrete. Open the IDE, drag a button, drag an input box, double-click an event, write a few lines of Object Pascal, connect to a database, drop a data-grid component, and a runnable window application appears quickly. For MIS programmers, this efficiency was direct.

More importantly, it changed how programmers thought.

In lower-level eras, you first thought about files, memory, functions, compilation, and linking. In tools such as Delphi, you began thinking about windows, controls, events, data sources, datasets, forms, and reports. A program was no longer only a flow of code execution. It began to look like what users were using.

Enterprise MIS around 1998: from paper forms to database records

The plainest step of enterprise informatization: turning paper forms, approval flows, and reports into records in a database. This is a period-inspired illustration.

Borland also deserves a note.

Many younger programmers may have heard of Microsoft, Oracle, Sun, and Netscape, but may not feel much about Borland. For developers in the 1990s and early 2000s, however, Borland was a name with presence. Turbo Pascal, Borland C++, Delphi, and C++Builder accompanied many people through both learning and real projects.

Borland tools had an engineer-friendly feel.

They were not as heavy as some enterprise tools, nor did they require a pile of scaffolding and configuration like many later Web tools. They gave you the feeling: I know you want to build programs; I will try to make that direct.

Delphi especially did this.

It was not perfect. It had its ecosystem, version, component, and deployment problems. But in an era when Windows desktop applications and database applications grew rapidly, it truly gave programmers strong productivity.

Behind Forms Are Organizations

At first, MIS problems are easy to underestimate.

Isn’t it just CRUD?

Create a few tables, write a few windows, make a few queries, print some reports. The code complexity does not seem high. Compared with assembly, computer graphics, or network protocols, these things look very “business.”

Later I learned that business systems are difficult not because of algorithms, but because of reality.

Real data is not clean. A department may have several names. A person may transfer to another position. A number may follow an old rule. A field originally designed as required may be empty in large amounts of historical data. Real workflows are also unstable. Today approval has three levels; tomorrow it becomes two. One leader is on a business trip, so approval needs delegation. A new report is temporarily required at month-end. At year-end, the statistical definition changes again.

Technical systems fear ambiguity more than complexity.

MIS systems have to handle a large amount of ambiguity. In paper workflows, many rules are filled in by human understanding, explained in one sentence, or handled by experienced employees. Once they become software, you must write them as fields, states, permissions, validation, and processes.

This forces an organization to look in the mirror.

Data that anyone could previously modify: should it now be restricted?

Approval that used to be handled verbally: should it now leave traces?

Metrics calculated differently by each department: whose definition should the system use?

These questions eventually land in front of programmers. You think you are writing forms. In reality, you are helping an organization arrange its own rules.

That is the most interesting and most painful part of enterprise software.

On the surface, it is a technical project. Inside, it is an organizational project.

Databases Gave Software Memory

In 1998 MIS work, the database was the core.

Without a database, a form is only temporary input. Only when data is stored does the system have memory. It can query, count, trace, reconcile, and print historical reports. Only then does software truly participate in management.

Relational databases were common in many projects then. Table design, primary keys, foreign keys, indexes, transactions, and query statements gradually entered daily work. You began to understand that fields are not added casually, types are not chosen casually, indexes are not always better when more numerous, and a slow report may not be a UI problem. It may be a bad query, or the table structure may have been unclear from the start.

From this time, programmers easily form an instinct: look at the data first.

Interfaces can be rebuilt. Processes can be adjusted. Code can be refactored. But once data is wrong, things become much more troublesome. The most valuable asset in an enterprise system is not the window or the button. It is the business data accumulated over years.

This sentence was verified again and again later.

It was true in banking systems, in internet platforms, in big-data platforms, and still true in AI applications today. Models, interfaces, and algorithms all change. Data quality still determines how far a system can go.

MIS systems in 1998 look plain today, but they taught me early that software becomes important when it starts carrying data.

Windows 98 and Office Computers

Windows 98 was released in 1998.

For personal computers and office computers, this was a very period-specific milestone. On more and more office desks, beige towers, CRT monitors, keyboards, mice, and printers appeared. Computers were no longer only devices for a few technical people; they began entering ordinary departments.

Operating systems, Office, database clients, MIS systems, printer drivers, and Network Neighborhood together formed the office informatization experience of the time.

That experience was not smooth.

Drivers conflicted. Printers jammed. Systems blue-screened. Network shares disappeared. Database connections failed. Users closed a window and said the system was gone. Today we are used to cloud services and browsers, and many client-side problems are hidden in servers and web pages. Back then, the desktop environment itself was part of software delivery.

This was why tools such as Delphi mattered.

They generated Windows programs users could open in front of them. The program had menus, toolbars, tables, buttons, and print previews. For users of that era, that was what “software” looked like.

The Web was growing, but many internal enterprise systems were still desktop applications.

The butterfly flew in the browser. The form landed on the Windows desktop.

Another Thread in 1998: Internet Entrances Were Taking Shape

Interestingly, 1998 was not only MIS, Windows 98, and office computers.

Google was founded that year.

Looking back from today, this was of course a huge event. But at the time, a search-engine startup and the enterprise systems we were building seemed far apart. One faced global web pages; the other faced internal organizational workflows. One handled links and ranking; the other handled fields and reports. One later changed the internet’s entrance; the other was merely helping offices fill out fewer paper forms.

But they were actually dealing with the same thing: how information is organized.

MIS structured information inside organizations. Google ranked public web information. The former cared about permissions, workflows, and reports. The latter cared about links, relevance, and entry points. One turned inward, the other outward. Together they show that by 1998, software was no longer only about making machines execute commands. It was beginning to build order around information itself.

In the same year, XML 1.0 became a W3C Recommendation, and the open-source movement took a clearer form. Information exchange, standards, collaboration, and openness all gained weight.

That was not necessarily visible at the time.

When you are sitting in an office changing a form field, you may not imagine that search engines will change the world, or that open source will reshape the software industry. You only know that this field must go online today, because users need it tomorrow.

Major events in technical history always happen alongside daily work.

Most of the time, we are not standing on top of the wave. We are beside the wave, fixing a button.

From Small Programs to Business Systems

In 1996, I was still looking back at the 386, PDP-11, and assembly. In 1997, I wrote a JavaScript butterfly that could fly. By 1998, things suddenly became concrete: fields, tables, reports, permissions, printing, users.

These three years look like three steps in a programmer’s growth.

First, you understand the machine.

Second, you understand the interface.

Third, you begin to understand business.

Understanding machines tells you that programs are not magic. Understanding interfaces tells you that what users see matters. Understanding business tells you that software must eventually enter the real world and become tangled with human workflows, organizational rules, historical data, and responsibility boundaries.

MIS gave me the third kind of training.

It was not cool, but it was solid. It was not as exciting as browser animation, nor as technically pure as low-level development. It was more like a craft: taking the messiness of reality and arranging it into a system users can operate, data can live in, workflows can run through, and problems can be investigated from.

I later built many platform-level, internet-scale, and data-oriented systems, but this training stayed useful.

Because no matter how large a system becomes, it eventually returns to some plain questions: where does data come from, who can modify it, how do you investigate mistakes, why do users use it this way, why reports disagree, and who is responsible when the system breaks.

MIS in 1998 had already asked these questions once.

Next: Forms Connected to Bank Front-end Machines

In 1998, enterprise systems mostly circulated inside offices. In 1999, I would enter a harder scenario: building systems for a bank, using SCO UNIX as a front-end machine, and truly using sockets in production.

That was no longer only about forms and reports.

It was about connections, protocols, stability, production environments, and financial systems.

If 1998 showed me how software organizes information inside an organization, 1999 would show me how software carries responsibility in real transactions and production links.

The next essay is about bank front-end machines and real sockets.

IT Milestones of 1998

  • Google was founded. Google was founded in September 1998. It began as a search-engine startup and later became one of the most important entrances to the internet, influencing search, advertising, data centers, distributed systems, browsers, mobile operating systems, and AI infrastructure.
  • Windows 98 was released. Microsoft released Windows 98, extending the Windows 95 desktop experience and integrating internet capabilities such as Internet Explorer more deeply into personal-computer usage. For many office users, Windows 98 is part of the memory of PC adoption.
  • XML 1.0 became a W3C Recommendation. XML became a W3C Recommendation in February 1998. It became important for data exchange, configuration files, document formats, and enterprise integration. JSON later occupied many lighter Web scenarios, but XML’s influence in enterprise software and standardized interfaces remained deep.
  • The Open Source Initiative was founded. In 1998, the Open Source Initiative appeared, and the phrase “open source” began spreading in a more business-friendly tone. Together with the free-software movement, it helped drive Linux, Apache, MySQL, Python, GitHub, and the cloud-native ecosystem.
  • Netscape opened its browser source code. In 1998, Netscape announced that it would release Communicator source code, beginning the Mozilla project. The early process was difficult, but this line later led to Firefox and became an important part of the open browser ecosystem.
  • iMac G3 was released. Apple introduced the iMac G3 in 1998. Its translucent colorful shell redefined the consumer image of personal computers and helped Apple recover. It was not the protagonist of enterprise MIS, but it marked a turn in personal-computer aesthetics.
  • Confinity, the predecessor of PayPal, was founded. Confinity was founded in 1998, later merged with X.com, and developed into PayPal. It represented early exploration of internet payments and online transaction infrastructure.
  • VMware was founded. VMware was founded in 1998. Virtualization later changed server utilization, development and testing environments, data-center management, and cloud computing.
  • Tencent was founded. Tencent was founded in Shenzhen in November 1998. It later moved from instant messaging into social networking, games, content, payments, cloud, and enterprise services.
  • The early company behind JD.com was founded. JD.com’s early company can be traced back to 1998, later moving from offline retail into online retail and e-commerce infrastructure. Many later internet giants did not begin in the form we know today.

Apple iMac G3

Apple iMac G3. Image source: Wikimedia Commons.

References

More in this column

View all posts in "Thirty Years in IT and Me"