Welcome back, digital pioneers, to another edition of Computer History Wednesdays! The 1990s, 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. A decade that’s not just about the pop culture, but more about how the world of programming 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, the world of 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, and 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++” is a play 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 device that has a JVM.
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 Smalltalk.
Historical nugget: Smalltalk was developed at Xerox PARC, the same place where the first graphical user interface was born. Some say if you truly want to understand OOP, you must learn Smalltalk.
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 to visualize and document 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 began its rapid evolution 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
For a long time, programming was synonymous with compiled languages, but the web required something nimble, something that could be quickly developed, tested, and deployed. Enter scripting languages!
Perl, originally 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 stood for “Personal Home Page” initially) evolved into a full-fledged language that powered major websites, including a nascent version of Facebook.
The Birth of JavaScript
However, server-side scripting wasn’t enough for the burgeoning web. To make web pages truly 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 weren’t 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 didn’t just witness a surge in programming languages; it was equally 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 also pushed its proprietary languages and technologies, including the introduction of .NET towards the end of the decade.
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 automation of the Mac OS and its applications.
It’s worth noting the significant influence of NeXT here. With the acquisition of NeXT came Objective-C and the NeXTSTEP development environment, both of 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. The open-source nature of Linux 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, with the intent of creating a language that was powerful yet had a fun side to it.
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 to work in.
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 world of programming was rapidly changing, and so were the tools that 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 and made the entire process of application development significantly smoother.
Anecdote: Remember Clippy, the helpful (and sometimes annoying) paperclip assistant from Microsoft Office? Well, Visual Studio had its own 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 wide audience, Borland had its eyes set 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, it was the Eclipse IDE, introduced in 2001 (though its roots trace back to the late ’90s), that 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 to be experienced on the web. Despite the initial excitement, VRML was ahead of its time. The hardware and internet speeds of the ’90s couldn’t deliver a smooth VR experience, causing VRML to slowly fade into obscurity.
Marquee and Blink: The Wild Web Designs
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 user’s desktops. But 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 the revolutionary features of Java was its garbage collection, automatically deleting 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 at once. It’s a major reason why threading doesn’t always result in performance improvements in Python.
- PHP Sessions: PHP introduced sessions, allowing web developers to store user information to be used 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 that supported Dynamic HTML (DHTML). This 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
- JavaScript was initially called Mocha.
- Brendan Eich created the first version of JavaScript in just ten days.
- Perl’s name doesn’t stand for anything. It was originally a typo of “pearl”.
- Python wasn’t named after the snake. It was a tribute to the British comedy group “Monty Python”.
- Sun Microsystems, the company behind Java, initially wanted to call it “Duke”.
- 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.
- While Eclipse is synonymous with Java development today, it initially began as a project by IBM before becoming an open-source platform.
- 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.
- In the battle of Java IDEs, while Eclipse gained significant traction, NetBeans had its niche. Did you know that NetBeans is the official IDE for all Java EE6 development?
- While Linux was gaining ground as an OS in the ’90s, IDEs for Linux like Code::Blocks and KDevelop were also emerging, though they wouldn’t gain mainstream traction until the 2000s.
- 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.
- 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.
- Some ’90s IDEs had easter eggs. For instance, typing a specific command in Microsoft’s QBasic would trigger a hidden game!
- 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.
- 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 had its own set of 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.
Java’s promise of portability, while groundbreaking, 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.
PHP, in its early days, 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 truly 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!