In 1988, a solo developer named Alan Cooper built a drag-and-drop visual interface prototyping tool in his garage and showed it to Bill Gates. Gates immediately saw the potential — not as a standalone product, but as the front end for a new kind of programming language. That tool became Visual Basic, and its launch in 1991 shattered the barrier between “real programmers” and everyone else who wanted to make software. For the first time, you could draw a button on screen, double-click it, and write the code that made it do something — all within minutes. But Visual Basic was only the beginning of Alan Cooper’s impact on the technology world. His later work on interaction design, goal-directed methodology, and the invention of personas would reshape the entire discipline of software design, earning him the title “Father of Interaction Design” and influencing how millions of products are conceived and built to this day.
Early Life and the Road to Software
Alan Cooper was born in 1952 in San Francisco, California. Growing up in the Bay Area during the earliest rumblings of what would become Silicon Valley, Cooper was surrounded by a culture of engineering and invention, though his path to technology was anything but direct. He studied at the College of Marin but never completed a traditional computer science degree — a biographical detail he shares with several other transformative figures in tech, including Bill Gates and Steve Wozniak.
Cooper’s first encounter with programming came in the mid-1970s, when microcomputers were emerging as a hobbyist phenomenon. He taught himself to code, drawn in by the raw creative potential of instructing a machine to do useful work. By the late 1970s, he had co-founded a small software company and was developing business applications for early personal computers. This hands-on experience — building real products for real people who struggled with confusing interfaces — planted the seeds of his lifelong obsession with making software more humane.
Throughout the early 1980s, Cooper worked on a series of commercial software products, gaining a deep understanding of the gap between what programmers built and what users actually needed. He noticed that engineers designed software around internal data structures and system constraints, while users approached software with goals and tasks in mind. This fundamental mismatch would become the central problem of his career.
The Invention of Visual Basic
By the mid-1980s, Cooper had become fascinated with the idea of visual programming. He envisioned an environment where developers could design user interfaces by directly manipulating graphical elements — dragging buttons, text fields, and list boxes onto a canvas — rather than writing hundreds of lines of code just to create a window. The concept was radical for its time. While Alan Kay and the Xerox PARC team had pioneered graphical user interfaces years earlier, programming itself remained a text-only, command-driven activity.
In 1988, Cooper created a prototype he called “Ruby” (not to be confused with Yukihiro Matsumoto’s programming language of the same name, which came later). Ruby was a shell and visual design tool that allowed users to create interactive interfaces by placing and connecting visual elements. It was not a full programming language — it was an interaction design tool, a way to rapidly prototype what software should look and feel like before writing the underlying logic.
Cooper demonstrated Ruby to Microsoft, and Bill Gates recognized its potential immediately. Microsoft licensed the technology and paired Cooper’s visual shell with their existing QuickBASIC language engine. The result, launched in May 1991, was Visual Basic 1.0 — a product that would fundamentally change who could create software and how quickly they could do it.
Why Visual Basic Mattered
Before Visual Basic, creating a Windows application required deep expertise in the Windows API, message loops, callback functions, and memory management. A simple “Hello World” window might require dozens of lines of C code. Visual Basic collapsed that complexity into something almost anyone could understand:
' Visual Basic - Creating a simple form application
' This was revolutionary: draw the UI, then write the logic
Private Sub Form_Load()
' Set up the main window
Me.Caption = "My First Application"
Me.BackColor = &HF0F0F0
' Add a label
Label1.Caption = "Enter your name:"
Label1.Font.Size = 12
' Configure the text input
Text1.Text = ""
Text1.Font.Name = "Arial"
' Set up the button
Command1.Caption = "Say Hello"
Command1.Font.Bold = True
End Sub
Private Sub Command1_Click()
' Event-driven programming made simple
Dim userName As String
userName = Text1.Text
If Len(userName) > 0 Then
MsgBox "Hello, " & userName & "!" & vbCrLf & _
"Welcome to Visual Basic.", _
vbInformation, "Greeting"
Else
MsgBox "Please enter your name first.", _
vbExclamation, "Oops"
End If
End Sub
Private Sub Form_QueryUnload(Cancel As Integer, UnloadMode As Integer)
' Clean exit with confirmation
Dim response As Integer
response = MsgBox("Are you sure you want to exit?", _
vbYesNo + vbQuestion, "Confirm")
If response = vbNo Then Cancel = True
End SubThe key innovation was event-driven programming combined with visual design. You drew a button on a form, double-clicked it, and Visual Basic generated the event handler stub for you. You simply filled in what should happen when the button was clicked. This paradigm — visual layout plus event-driven code — was Cooper’s original vision from the Ruby prototype, and it remains the foundation of virtually every modern GUI builder, from Xcode’s Interface Builder to Android Studio’s layout editor.
Visual Basic became a massive commercial success. By the mid-1990s, it was the most widely used programming language in the world. Corporate IT departments adopted it for building internal tools. Independent developers used it to create shareware and small business applications. It democratized software creation in a way that no language had done before, and its design philosophy directly influenced later platforms like Delphi (built by Anders Hejlsberg before he moved to Microsoft), the .NET Windows Forms framework, and even modern low-code tools.
From Programming Tools to Interaction Design
After the success of Visual Basic, Cooper could have continued building developer tools. Instead, he pivoted to a question that had nagged him for years: why was most software so frustrating to use? He had seen it firsthand — even with Visual Basic making it easier to build applications, the resulting software was still confusing, cluttered, and hostile to the people who used it. The problem was not in the technology. The problem was in the design process itself.
In 1992, Cooper founded Cooper Interaction Design, a consultancy dedicated to rethinking how software products were conceived. His approach was radical for the era: before writing a single line of code or drawing a single wireframe, you needed to deeply understand the people who would use the product — their goals, frustrations, workflows, and mental models. This was a direct challenge to the engineering-driven development culture of the 1990s, where features were added because they were technically possible, not because users needed them.
The Invention of Personas
Cooper’s most influential contribution to design methodology was the invention of personas — detailed, research-based fictional characters that represent distinct user types. The concept emerged from a project in 1983, when Cooper was developing a project management application. He interviewed several potential users, and rather than trying to design for a vague “average user,” he began designing specifically for one woman he had spoken to, imagining her sitting at her desk, trying to accomplish her daily tasks.
He refined this technique over the next decade, eventually formalizing it into a rigorous methodology. A Cooper persona was not a casual sketch or a marketing demographic. It was a deeply researched archetype built from behavioral patterns observed in real user interviews, complete with a name, photograph, personal background, professional context, goals, frustrations, and technology proficiency level. The persona served as a design target — every feature, layout, and interaction could be evaluated against the question: “Would this help Kathy achieve her goal?”
This concept, which Cooper introduced formally in his landmark 1999 book The Inmates Are Running the Asylum, became one of the most widely adopted techniques in user experience design. Today, personas are used by product teams at companies of every size, from startups to Fortune 500 enterprises. The technique influenced the thinking of other design leaders, including Don Norman, whose work on user-centered design and cognitive ergonomics complemented Cooper’s goal-directed approach.
Goal-Directed Design: A New Methodology
Personas were a component of Cooper’s broader framework, which he called Goal-Directed Design. The methodology rested on a fundamental insight: users do not care about features, data models, or system architectures. They care about accomplishing goals. A person using an email client does not want “a hierarchical folder system with drag-and-drop message filing.” They want to find a specific message quickly, respond to it, and move on with their day.
Goal-Directed Design introduced a structured process that moved from research through modeling, requirements definition, framework design, and detailed design. Each phase was guided by the personas and their goals, ensuring that design decisions always traced back to real human needs rather than technical convenience or stakeholder wish lists.
The methodology included several key principles that remain relevant decades later:
- Design before engineering: Interaction behavior should be defined before implementation begins, not discovered during coding.
- Goals over tasks: Design for why users do things, not just what they do. Tasks change; goals persist.
- Eliminate excise: Any interaction that serves the software’s needs rather than the user’s goals is “excise” and should be removed or minimized.
- Polite software: Applications should behave like considerate human beings — remembering preferences, not asking redundant questions, and not interrupting with unnecessary alerts.
- No error messages for expected behavior: If a user action is predictable, the software should handle it gracefully rather than punishing the user with a dialog box.
Cooper detailed this framework in his influential series of books, most notably About Face: The Essentials of Interaction Design, which has been updated through four editions and is widely regarded as a foundational text in the field. The principles map directly to the kind of thoughtful project planning that modern digital agencies like Toimi practice — ensuring that user goals drive every design decision from initial research through final delivery.
The Inmates Are Running the Asylum
Cooper’s 1999 book The Inmates Are Running the Asylum: Why High-Tech Products Drive Us Crazy and How to Restore the Sanity was a provocation aimed at the technology industry’s deepest assumptions. The central argument was blunt: engineers, left to their own devices, design software for other engineers. The resulting products are powerful but incomprehensible to normal people. The “inmates” — developers — were “running the asylum” — the product development process — and the result was a world full of frustrating, unusable technology.
The book struck a nerve. It articulated a frustration that millions of computer users felt but could not name. Cooper argued that the solution was not better engineers or more user testing after the fact, but a fundamentally different process: professional interaction designers should define product behavior before engineering begins, using personas and goal-directed methods to ensure that software served human needs.
The book’s impact extended far beyond the design community. It influenced how technology executives thought about product development, helped legitimize the role of interaction designers and UX professionals in organizations, and provided vocabulary and frameworks that are still in active use. The concept of designing for specific personas rather than generic “users” became standard practice across the technology industry, and its echoes can be seen in agile user stories, jobs-to-be-done frameworks, and modern product management methodologies.
Cooper’s Design Principles in Practice
To understand the practical impact of Cooper’s thinking, consider how his principles apply to a common design challenge — building a task management interface. A traditional feature-driven approach might start with a list of capabilities: create tasks, set due dates, assign priorities, add tags, create subtasks, and so on. Cooper’s approach starts differently — with the persona and their goals:
' Pseudocode: Goal-Directed Design for a Task Manager
' Persona: Sarah, a project lead managing a 6-person team
' Primary Goal: Ensure nothing falls through the cracks
' Secondary Goal: Minimize time spent on administrative overhead
' ANTI-PATTERN: Feature-driven design
' "Let's add every field we can think of"
Class TaskForm_FeatureDriven
Property Title As String ' Required
Property Description As String ' Required
Property DueDate As Date ' Required
Property Priority As Integer ' 1-5 scale
Property Category As String ' From dropdown
Property Tags() As String ' Multiple select
Property Subtasks() As Task ' Nested list
Property Assignee As User ' Team member
Property Reviewer As User ' Approval flow
Property EstimatedHours As Double ' Time tracking
Property ActualHours As Double ' Time tracking
Property Status As Integer ' 7 possible states
Property Dependencies() As Task ' Blocking/blocked by
' Result: 13 fields. Sarah abandons it after day one.
End Class
' COOPER'S APPROACH: Goal-directed design
' "What does Sarah need to ensure nothing falls through?"
Class TaskForm_GoalDirected
Property Title As String ' Natural language
Property Owner As User ' Who owns the outcome
Property DueDate As Date ' When it matters
' Smart defaults eliminate excise:
' - Priority inferred from due date proximity
' - Status auto-updates based on activity
' - Category suggested from title keywords
' - Subtasks available but not required upfront
Sub OnCreate()
' Polite software: remember Sarah's patterns
Me.Owner = InferLikelyOwner(Me.Title)
Me.DueDate = SuggestDeadline(Me.Title)
' No confirmation dialogs for routine actions
' No mandatory fields beyond the title
' Progressive disclosure: advanced options on demand
End Sub
End Class
' The goal-directed version respects Sarah's time.
' She types a title, confirms or adjusts the smart defaults,
' and moves on. The software works FOR her, not against her.This example illustrates the core of Cooper’s philosophy: understanding the human goal transforms the design. The feature-driven approach produces a comprehensive but overwhelming interface. The goal-directed approach produces something that feels effortless. Modern task management platforms like Taskee embody this principle — prioritizing clarity and goal completion over feature accumulation, ensuring that teams spend their energy on actual work rather than fighting their tools.
Legacy and Influence on Modern UX
Alan Cooper’s influence on the technology industry operates on two distinct levels. On the technical level, his creation of Visual Basic’s visual programming paradigm established patterns that persist in every modern IDE and visual development environment. The concept of drawing an interface and attaching behavior to events — which Cooper prototyped in Ruby before Microsoft ever touched it — is so thoroughly embedded in modern development practice that most developers take it for granted.
On the design level, his impact is even more profound. Before Cooper, “software design” typically meant architecture — the internal structure of code. Cooper helped establish interaction design as a distinct discipline, focused on the external behavior of software as experienced by human beings. His personas methodology gave design teams a concrete tool for maintaining empathy with users throughout the development process. His goal-directed framework provided a systematic alternative to the feature-list-driven development that produced so much unusable software in the 1990s and 2000s.
The Cooper consultancy (later acquired by Designit, part of the Wipro group) trained hundreds of interaction designers who went on to influence product teams at major technology companies. The firm’s alumni network spread Cooper’s methods throughout Silicon Valley and beyond, embedding goal-directed thinking into the design cultures of companies building products used by billions of people.
Awards and Recognition
Cooper’s contributions have been widely recognized. He received the Software Visionary Award from the Software Development Forum, the Lifetime Achievement Award from the Usability Professionals’ Association (now UXPA), and was inducted into the CHI Academy by the ACM’s Special Interest Group on Computer-Human Interaction. He is often cited alongside Don Norman and Jakob Nielsen as one of the three most influential figures in the history of user experience design.
Connecting Visual Basic to Modern Development
The lineage from Cooper’s Ruby prototype to modern visual development tools is direct and traceable. Visual Basic introduced millions of developers to event-driven programming and visual UI construction. That paradigm evolved through Visual Basic .NET, C# Windows Forms, WPF, and eventually into web-based frameworks and modern component-driven UI development.
Today’s low-code and no-code platforms — tools that let non-programmers create functional applications through visual interfaces — are the spiritual descendants of Cooper’s original vision. When a business analyst drags and drops components in a modern app builder, they are working within a paradigm that Cooper invented in his garage in 1988. The circle from “Ruby” to modern visual development has come fully around.
Cooper’s dual legacy — both the technical contribution of visual programming and the methodological contribution of interaction design — makes him a uniquely important figure in the history of computing. He did not just create tools for building software; he created frameworks for thinking about what software should be. In a world where software mediates virtually every human activity, that contribution is difficult to overstate.
His work demonstrated that technology and humanism are not opposing forces. The best software emerges when deep technical capability is guided by genuine understanding of human needs — a principle that connects Cooper’s persona-driven design to the broader tradition of human-centered computing championed by pioneers like Alan Kay and Don Norman. Cooper proved that asking “what does the user actually need?” before writing a single line of code is not a luxury — it is the most important engineering decision you can make.
Frequently Asked Questions
Did Alan Cooper actually create Visual Basic?
Cooper created the visual shell prototype called “Ruby” — the drag-and-drop interface design tool that became the front end of Visual Basic. Microsoft paired his visual shell with their existing QuickBASIC language engine to create the complete Visual Basic product released in 1991. So while Microsoft built the language and compiler, the revolutionary visual programming interface — the part that made Visual Basic truly different — originated with Cooper.
What are personas in UX design and why did Cooper invent them?
Personas are detailed, research-based fictional characters that represent distinct types of users. Cooper invented them because he found that designing for a vague “average user” led to software that satisfied no one. By creating specific, named characters with defined goals, frustrations, and behaviors — all grounded in real user research — design teams could make concrete decisions. Instead of asking “what would a user want?” they could ask “what would Sarah, our project lead persona, need to accomplish her goal?” This specificity transformed abstract design discussions into practical, testable decisions.
How is Goal-Directed Design different from User-Centered Design?
User-Centered Design (UCD) is a broad philosophy emphasizing that users should be considered throughout development. Cooper’s Goal-Directed Design is a specific methodology within that philosophy. The key distinction is the focus on goals rather than tasks. UCD often relies on observing what users currently do (tasks) and optimizing those workflows. Goal-Directed Design asks why users perform those tasks — what they ultimately want to achieve — and sometimes discovers that the existing workflow is itself the problem. This goal-level analysis can lead to fundamentally different and often simpler solutions.
What happened to Visual Basic after Cooper’s involvement?
After Microsoft licensed Cooper’s Ruby prototype, Visual Basic evolved through six major versions (VB 1.0 through VB 6.0) between 1991 and 1998, becoming the world’s most popular programming language. In 2002, Microsoft released Visual Basic .NET, a complete redesign that was part of the .NET framework. While VB.NET is a modern language still actively maintained, many longtime developers felt it diverged significantly from the original Visual Basic’s simplicity and ease of use — arguably moving away from the accessibility that was Cooper’s original design intent.
Why is Alan Cooper called the “Father of Interaction Design”?
Cooper earned this title because he was among the first to articulate interaction design as a distinct professional discipline, separate from graphic design, engineering, and usability testing. Through his books, his consultancy, and his methodological frameworks, he defined what interaction designers do (design the behavior of software products), how they should work (using personas and goal-directed methods), and why they are essential (because engineers alone produce unusable software). His 1995 book About Face was the first major work to lay out interaction design as a coherent field with its own principles, practices, and career path.
