Welcome back, digital pioneers, to another edition of Computer History Wednesdays! The 1990s was a time of neon colors, the inception of the Internet, and the evolution of the programming languages that are pillars of our digital world today. It’s a decade that’s not just about pop culture but more about how the programming world took a quantum leap. Strap in, my code-savvy comrades, as we go binary and deep into the machine code of the ’90s.

History

The Rise of Object-Oriented Programming (OOP)

Before the 1990s, software development was largely ruled by procedural or functional paradigms. However, as software projects grew in scale and complexity, it became evident that a new paradigm was needed—one that could easily manage and model the complexity of burgeoning software systems. And so, the ’90s became the defining era for Object-Oriented Programming (OOP).

Why OOP?

The fundamental idea behind OOP is to model software components based on real-world objects. These objects encapsulate data and the operations that can be performed on this data. The beauty of OOP is in its ability to simulate real-world systems where objects interact with each other. For instance, in a vehicle management system, “Car,” “Truck,” and “Bike” could all be treated as objects with properties like speed, fuel, and capacity, as well as methods to start, stop, or refuel.

C++: Evolution from C

C++ was one of the pioneers that brought OOP to the limelight. Born from the C language, it added classes, inheritance, and polymorphism—fundamental tenets of OOP. Interestingly, the name “C++” plays on the increment operator in C (++), suggesting an increment or evolution of C.

Anecdote alert: C++ was developed by Bjarne Stroustrup at Bell Labs. He initially called it “C with Classes.” The renaming to C++ was a nod to Rick Mascitti’s earlier suggestions and, of course, programmer humor!

Java: Bridging the Gap

By the mid-’90s, the software world was gearing up for the internet age. Java emerged as a language that wasn’t just object-oriented but also platform-independent, giving rise to its mantra “write once, run anywhere.” This was possible due to the Java Virtual Machine (JVM), which interprets compiled Java byte code, allowing it to run on any JVM device.

A fun little story from the trenches: The team behind Java initially named it “Oak” after an oak tree that stood outside James Gosling’s office at Sun Microsystems. The name “Java” only came later and was inspired by the Java coffee consumed in heaps by the development team.

Smalltalk: The Unsung Hero

No deep dive into OOP’s history in the ’90s is complete without mentioning Smalltalk. Though it predates the ’90s, its influence permeated the decade. Smalltalk is often considered the “purest” OOP language, and many modern OOP concepts, like the “class-instance” distinction and “message passing,” stem from it.

Historical nugget: Smalltalk was developed at Xerox PARC, the same place where the first graphical user interface was born. Some say you must learn Smalltalk if you truly want to understand OOP.

The Shift in Software Design

With OOP’s growing popularity, the ’90s also saw a shift in software design philosophies. The Unified Modeling Language (UML) emerged as a standard for visualizing and documenting OOP systems. Design patterns, a set of reusable solutions to common problems, became prominent thanks to the influential book “Design Patterns: Elements of Reusable Object-Oriented Software” by the Gang of Four.

Web Development and Scripting Emerge

As the ’90s unfolded, the World Wide Web rapidly evolved from a collection of static HTML pages to a vast, interconnected platform offering dynamic content and user interactivity. This transformation, however, required a new suite of technologies and languages designed for the web.

The Power of Scripting Languages

Programming was synonymous with compiled languages for a long time, but the web required something nimble, something that could be quickly developed, tested, and deployed. Enter scripting languages!

Perl, initially developed in the late ’80s, became the de facto language for CGI (Common Gateway Interface) scripts in the ’90s. Web servers would run these scripts to generate dynamic content. The famous saying “There’s more than one way to do it” in the Perl community reflected the language’s flexibility (sometimes to its detriment, leading to hard-to-maintain code).

Anecdote time: Perl earned the nickname “the duct tape of the Internet” for its ability to quickly whip up solutions and patch different systems together.

PHP, another major player, emerged as a server-side scripting language. Originally designed to track visits to Rasmus Lerdorf’s online resume, PHP (which initially stood for “Personal Home Page”) evolved into a full-fledged language that powered major websites, including a nascent version of Facebook.

The Birth of JavaScript

However, the burgeoning web needed more than server-side scripting. To make web pages genuinely interactive, a client-side language was needed. Netscape answered the call with JavaScript. Despite the name, JavaScript had little to do with Java and was originally named Mocha.

A fascinating twist: Brendan Eich, JavaScript’s creator, was given just ten days to design the language for Netscape Navigator 2.0. Despite its rushed beginnings, JavaScript has grown to become the backbone of web interactivity.

Flash: A Double-Edged Sword

The web of the ’90s wasn’t just about text and static images. Flash, developed by Macromedia (and later acquired by Adobe), allowed web developers to embed animations, games, and, later, full-featured apps into web pages. While Flash introduced the Internet to rich multimedia experiences, it was proprietary, had performance issues, and posed many security risks. By the 2010s, open standards like HTML5 began to replace Flash, leading to its eventual decline.

VRML and the Dream of a 3D Web

As we touched upon later, VRML (Virtual Reality Modeling Language) was an ambitious attempt to bring 3D graphics to the web. Dreaming of a virtual, interconnected world, VRML unfortunately never took off. While the idea was captivating, the technology and infrastructure just needed to be ready.

The Rise and Fall of ActiveX

Microsoft’s ActiveX was another buzzworthy tech from the ’90s. Introduced as a part of the Internet Explorer browser, it allowed developers to embed Windows apps directly into web pages. While powerful, ActiveX controls were also notorious for security vulnerabilities, leading many users and developers to shun the technology over time.

Operating Systems and Their Competitive Landscape: Impacts on Programming

The 1990s witnessed a surge in programming languages, but it was also a defining era for operating systems. These systems provided the platforms on which these languages ran, shaping development practices, tools, and, at times, even the languages themselves.

Windows: The Playground for Many

The Microsoft ecosystem made significant waves in the programming world. Windows 95 introduced Win32 API, making it easier for developers to create applications for the Windows environment. Programming tools like Visual Basic and Visual C++ became quintessential for Windows application development.

Did you know? Visual Basic, introduced in 1991, made GUI programming accessible to many, drastically reducing the code required to build Windows-compatible interfaces.

As Windows evolved with 98 and ME, Microsoft pushed its proprietary languages and technologies, including introducing .NET towards the decade’s end.

Mac OS: A Haven for Creatives

Apple’s Mac OS, with its unique look and feel, fostered a development ecosystem that prized design and user experience. AppleScript, introduced in the ’90s, allowed the Mac OS and its applications to be automated.

It’s worth noting NeXT’s significant influence here. With the acquisition of NeXT came Objective-C and the NeXTSTEP development environment, which would play foundational roles in the future of Apple software development.

Linux: Power to the Programmers

Linux was not just an OS; it was a movement. Linux’s open-source nature meant languages like C and Perl found a comfortable home here. The introduction of GNOME and KDE in the late ’90s expanded opportunities for GUI-based application development in the Linux environment, fostering languages like Python and Ruby.

Fun fact: The name Python, inspired by Monty Python, was conceptualized during Guido van Rossum’s Christmas holidays in 1989. The intent was to create a powerful language with a fun side.

BeOS: A Fresh Approach

BeOS, with its media-centric approach, provided unique opportunities for multimedia application development. The operating system had its own C++-based API, offering developers a clean, object-oriented environment in which to work.

OS/2: IBM’s Ambition

While OS/2 was seen more as an alternative to Windows, it also had its own unique development environment. REXX, a scripting language, was a prominent feature in OS/2. The OS also provided robust Java support, positioning itself as a platform for web-centric applications.

Solaris and AmigaOS: Niche Champions

Solaris, being an enterprise-grade OS, was an avenue for languages and tools catering to big businesses, such as Java. AmigaOS, on the other hand, with its dedicated following, saw a lot of development with languages like C and assembly for performance-critical applications.

Rise of Integrated Development Environments (IDEs)

As the 1990s unfolded, the programming world was rapidly changing, and so were the tools developers wielded. The decade witnessed the meteoric rise of Integrated Development Environments (IDEs), fundamentally altering how developers wrote, debugged, and deployed code.

Why the Need for IDEs?

The early days of programming often required developers to juggle multiple tools - text editors for writing code, compilers to turn that code into executable programs, debuggers to diagnose issues, and more. The ’90s, with its booming software industry and increasing complexity of projects, demanded a more streamlined approach. Enter IDEs, which integrated these discrete tools into cohesive, often user-friendly environments.

Microsoft Leads the Charge

Microsoft was undeniably at the forefront of this IDE revolution. Visual Studio, launched in 1997, combined multiple languages (Visual C++, Visual Basic, and later Visual J++ for Java) under a single umbrella. This suite allowed developers to switch between languages seamlessly, making the entire application development process smoother.

Anecdote: Remember Clippy, the helpful (and sometimes annoying) paperclip assistant from Microsoft Office? Well, Visual Studio had its animated helpers known as “assistants” like Merlin the Magician! These characters were part of the same Office Assistant technology and aimed to make the IDE experience more interactive.

Borland: The David to Microsoft’s Goliath

While Microsoft’s tools catered to a broad audience, Borland had its eyes on more seasoned developers. With products like Delphi and C++Builder, Borland offered powerful IDEs that many professionals swore by. Delphi, in particular, was revolutionary for its time, allowing rapid application development using Object Pascal.

Trivia: Delphi was initially codenamed “Project X.” However, it was later named after the ancient city of Delphi, an allusion to the Oracle of Delphi and the tool’s goal to provide insights and answers to developers.

Java Revolution and Eclipse

The ’90s also saw the birth of Java. Sun Microsystems, sensing the need for a dedicated development tool, introduced the NetBeans IDE. However, the Eclipse IDE, introduced in 2001 (though its roots trace back to the late 1990s), truly resonated with the Java community. Open source and extensible, Eclipse set the stage for the future of Java development.

Web Development Gets Its IDEs

With the web becoming increasingly central to the ’90s tech boom, web-specific IDEs began to emerge. Macromedia Dreamweaver, launched in 1997, was among the pioneers. Its WYSIWYG editor revolutionized web design, making it accessible even to those with minimal coding expertise.

The Silent Growth of Open-Source IDEs

While commercial IDEs grabbed the limelight, the open-source community wasn’t far behind. Tools like Code::Blocks and KDevelop began their journey in the late ’90s, offering free alternatives to the commercial giants. They underscored a fundamental ’90s ethos: software development was for everyone, and the tools should reflect that inclusivity.

Buzzworthy But Bygone: A Nostalgic Dive

Applets and The Dawn of Interactive Web

In the era before modern web frameworks, Java applets were the saviors of dynamic content. These were small applications written in Java, embedded within HTML pages using the <applet> tag. Though they provided interactivity and features beyond static HTML, they required the Java runtime to be installed and soon faced criticism for their performance and security issues. The rise of JavaScript and Flash soon overshadowed applets.

VRML: Virtual Reality Modeling Language

When virtual reality (VR) was just a budding concept, VRML was introduced as a standard for describing interactive 3D objects and worlds for the web. Despite the initial excitement, VRML was ahead of its time. However, the hardware and internet speeds of the ’90s couldn’t deliver a smooth VR experience, causing VRML to slowly fade into obscurity.

HTML was evolving, and with it came some… interesting choices. The <marquee> and <blink> tags in HTML were used to create scrolling and blinking text effects, respectively. Both were widely used during the early days of web design but soon became synonymous with tacky web aesthetics. Thankfully, they’ve been deprecated, but those who surfed the early web won’t forget them anytime soon.

The Push for Push Technology

In the ’90s, Push technology was believed to be the future of online content delivery. Instead of users pulling information by requesting it, push technology would deliver data to the user’s desktop automatically. Services like PointCast delivered news directly to users’ desktops. However, as the web grew, the idea became less feasible due to bandwidth issues and the rise of personalized content streams.

OS/2: An Operating System That Almost Was

Developed by IBM in collaboration with Microsoft, OS/2 was touted as the successor to DOS. With features like multitasking and a graphical interface, OS/2 was ahead of its time. However, due to marketing decisions and the emergence of Windows as a dominant force, OS/2 gradually faded away.

Technical Tidbits

  • Java’s Garbage Collection: One of Java’s revolutionary features was its garbage collection, which automatically deleted objects that were no longer in use.
  • Python’s GIL: The Global Interpreter Lock (GIL) is a mutex that protects access to Python objects, preventing multiple native threads from executing Python bytecodes simultaneously. This is a significant reason threading doesn’t always result in performance improvements in Python.
  • PHP Sessions: PHP introduced sessions, which allow web developers to store user information across multiple pages.
  • Visual Studio’s Assistants: Microsoft’s IDEs weren’t just about code. They included animated “assistants” like Merlin, built using the same technology as the notorious Clippy from Office. The aim? Making coding a tad more entertaining.
  • Delphi’s Compilation Speed: One of the unsung strengths of Borland’s Delphi was its blazingly fast compilation speed. It was one of the reasons seasoned developers preferred it, especially for large projects.
  • Eclipse’s Plugin Architecture: Eclipse set itself apart with its plugin-based architecture. Developers could extend the IDE’s functionality, tailoring it precisely to their needs. This extensibility is one reason why Eclipse remains popular today.
  • Dreamweaver’s DHTML: Macromedia Dreamweaver was among the first IDEs to support Dynamic HTML (DHTML), which allowed for more interactive web pages at a time when the web was largely static.
  • IDE Debuggers: Debuggers in the ’90s IDEs were game-changers. Tools like those in Visual Studio and Borland’s suite allowed for real-time debugging, drastically reducing the time taken to find and fix errors.

Trivia

  1. JavaScript was initially called Mocha.
  2. Brendan Eich created the first version of JavaScript in just ten days.
  3. Perl’s name doesn’t stand for anything. It was initially a typo of “pearl.”
  4. Python wasn’t named after a snake. It was a tribute to the British comedy group Monty Python.
  5. Sun Microsystems, the company behind Java, initially wanted to call it “Duke”.
  6. Delphi was named after the ancient city of Delphi, drawing an analogy to the Oracle of Delphi—the tool aimed to be the “oracle” for developers, providing insights and answers.
  7. While Eclipse is synonymous with Java development today, it began as an IBM project before becoming an open-source platform.
  8. Borland may not dominate today’s development landscape, but its influence remains. Many of today’s software leaders began their journey with tools like Turbo C++ and Delphi.
  9. While Eclipse gained significant traction in the battle of Java IDEs, NetBeans had its niche. Did you know NetBeans is the official IDE for all Java EE6 development?
  10. While Linux was gaining ground as an OS in the ’90s, IDEs for Linux like Code::Blocks and KDevelop were also emerging, though they would only gain mainstream traction in the 2000s.
  11. Despite its simplicity, many of the concepts introduced by Visual Basic, especially in terms of GUI design, can still be seen in modern IDEs and GUI toolkits.
  12. With the rise of web development IDEs in the ’90s, there was also a growing need to address web vulnerabilities. Tools like Dreamweaver began incorporating features to ensure safer code.
  13. Some ’90s IDEs had easter eggs. For instance, typing a specific command in Microsoft’s QBasic would trigger a hidden game!
  14. Java’s “Write Once, Run Anywhere” mantra was revolutionary, but IDEs were crucial in making this promise a reality. Tools ensured that Java code remained platform-independent.
  15. The ’90s also saw the rise of shareware. IDEs weren’t left out. Some smaller, niche IDEs were distributed as shareware, allowing developers to try before they buy.

Cybersecurity Implications

With the evolution of programming languages, the cybersecurity landscape has its own challenges and innovations. The introduction of web-based languages gave rise to vulnerabilities unique to web applications – think SQL injections, Cross-Site Scripting, and more.

While groundbreaking, Java’s promise of portability also posed risks. Java applets could run code on a user’s machine from a remote location, presenting a potential risk if misused by malicious actors.

In its early days, PHP lacked many security features, giving rise to vulnerabilities often exploited by attackers. File inclusion vulnerabilities, insecure session management, and lack of parameterized queries opened doors to various attacks.

Conclusion

There you have it, folks! A time-travel through the ’90s – a decade that genuinely shaped programming as we know it. Remember, understanding the past is crucial to innovating for the future. Until the next Computer History Wednesday, keep those keycaps clacking and stay curious!