End-user development
End-user development (EUD) is a set of methods, techniques, and tools that enable users of software systems, acting as non-professional software developers, to create, modify, or extend software artifacts to meet their specific needs.[1] This paradigm shifts the focus in human-computer interaction from mere ease of use to ease of development, empowering domain experts—such as biologists, teachers, or business analysts—who possess specialized knowledge but lack formal programming training to adapt technology flexibly.[1] By bridging the gap between professional software engineering and everyday user requirements, EUD promotes tailorability and personalization in dynamic environments.[2] The concept of EUD emerged in the late 20th century alongside the rise of personal computing, with early influences from visual programming and tailorability research in human-computer interaction.[2] Pioneering tools like Apple's HyperCard in the 1980s allowed users to build interactive applications through card-based metaphors, while programming-by-demonstration techniques, such as the Peridot system, enabled inference of code from user demonstrations.[2] The term gained formal recognition in the early 2000s through initiatives like the EUD-Net consortium and the 2006 edited volume End User Development, which synthesized multidisciplinary approaches from software engineering, computer-supported cooperative work, and usability studies.[3] By the 2010s, EUD had expanded with Web 2.0 technologies, exemplified by platforms like Yahoo! Pipes for data integration and Google App Inventor for mobile app creation.[2] Key principles of EUD emphasize accessibility and scalability, including a low threshold for entry—using intuitive interfaces like visual blocks or natural language prompts—and a high ceiling for advanced customization without steep learning curves.[2] Systems support incremental development, where users start with simple configurations and progressively add complexity, often through metaphors such as jigsaw puzzles or direct manipulation.[1] Cooperative aspects allow shared adaptation in teams, fostering meta-design where creators build in flexibility for future end users.[1] These principles address the disparity between professional developers and end users; for instance, in 2012, the United States had fewer than 3 million professional programmers but over 55 million knowledge workers using tools like spreadsheets and databases.[2] In contemporary contexts, EUD has evolved to encompass no-code and low-code platforms, particularly for artificial intelligence and Internet of Things (IoT) applications, democratizing access to advanced technologies.[4] Recent developments include AI-assisted EUD, where machine learning supports users in composing intelligent agents or customizing smart environments through wizard-based or component-based paradigms, with applications in education, industry, and personalized IoT ecosystems.[5] A 2023 systematic review of 22 studies highlighted trends toward lay-user tools for AI model creation, though challenges remain in supporting collaboration and expert-level customization.[4] This progression underscores EUD's role in empowering diverse users to innovate amid rapidly changing technological landscapes.Definition and History
Definition
End-user development (EUD) refers to a set of methods, techniques, and tools that enable users of software systems—who are typically non-professional software developers—to create, modify, or extend software artifacts in order to address specific needs within their domain of expertise.[2] This approach empowers individuals with limited programming experience, such as domain experts in fields like business, education, or science, to tailor applications without relying solely on professional programmers, thereby bridging the gap between rapidly evolving user requirements and the constraints of traditional software development.[6] At its core, EUD emphasizes flexibility and modifiability throughout the software lifecycle, shifting the paradigm from designing systems that are merely easy to use to those that are easy to develop and adapt during ongoing use.[6] It originated as a response to the limitations of professional development, where developers often lack deep domain knowledge, leading to delays in accommodating user changes; EUD tools thus prioritize low thresholds for entry, intuitive interfaces, and support for iterative customization to foster end-user agency.[2] Seminal work in the field, such as that by Lieberman et al., highlights EUD's role in enabling non-programmers to engage in software creation across diverse contexts, from personal computing to collaborative environments.[6] EUD is distinct from related concepts like end-user programming (EUP), which focuses narrowly on programming techniques such as visual scripting or macros, whereas EUD encompasses the broader software development process, including design, extension, and maintenance.[6] It also differs from participatory design by allowing continuous user involvement post-deployment, often through meta-design principles that embed adaptability into the system from the outset.[6] Recent reconsiderations of EUD definitions emphasize its integration into modern programming practices, moving beyond a strict dichotomy with professional development to focus on the nature of tasks and platforms that support non-expert innovation.[7]Historical Development
The roots of end-user development (EUD) trace back to the late 1970s with the advent of personal computers, which democratized computing and allowed non-professionals to customize software for their needs. The release of VisiCalc in 1979 marked a pivotal moment, as the first electronic spreadsheet enabled business users to perform complex calculations and automate tasks without traditional programming skills, effectively turning end-users into inadvertent programmers.[8] This innovation, developed by Dan Bricklin and Bob Frankston, fueled the adoption of microcomputers in offices and highlighted the potential for domain-specific tools to empower users.[9] By the early 1980s, subsequent spreadsheets like Lotus 1-2-3 (1983) and Microsoft Excel (1985) further entrenched these practices, with macros and scripting features allowing users to extend functionality iteratively.[9] In the 1980s and 1990s, EUD evolved through graphical interfaces and hypermedia systems that lowered barriers to creation. Apple's HyperCard, introduced in 1987 by Bill Atkinson, provided a visual programming environment where users could build interactive applications, such as databases and presentations, using stacks of cards and simple scripting in HyperTalk.[10] This tool exemplified "programming by demonstration," influencing later web development and underscoring end-users' ability to tailor software in use.[11] Concurrently, the term "end-user programming" gained traction through empirical studies of spreadsheet and macro usage in workplaces. Bonnie Nardi's 1993 book, A Small Matter of Programming, analyzed these activities, arguing that end-users routinely programmed to meet practical needs but faced challenges in reliability and scalability, laying foundational insights for the field.[12] The 2000s saw EUD emerge as a distinct research paradigm, formalized through workshops and comprehensive reviews. Henry Lieberman's 2003 CHI workshop on "Perspectives on End User Development" and his co-edited 2006 book End User Development defined EUD as methods enabling non-professionals to create or adapt software, emphasizing psychological and social dimensions.[3] This period also quantified the scale: Scaffidi et al. (2005) estimated 55 million end-user programmers in the U.S. by 2012, far outnumbering professionals, based on surveys of tool usage across domains like spreadsheets and databases.[13] Building on this, Ko et al.'s 2011 survey, "The State of the Art in End-User Software Engineering," synthesized over two decades of work, highlighting shifts toward testing, debugging, and reuse in diverse contexts like web and mobile applications, while identifying gaps in end-user support tools.[14] These contributions established EUD's focus on empowering users amid growing software complexity.Core Concepts
End-Users vs. Professional Developers
End-user development (EUD) refers to the creation, modification, or extension of software by individuals who are not professional software developers, often using specialized tools to address domain-specific needs without formal programming training.[15] In contrast, professional developers are trained IT specialists who build software as their primary occupation, typically employing rigorous engineering methodologies to produce scalable, maintainable systems for broad audiences.[14] This distinction arises from differing roles: end-users act opportunistically within their professional domains (e.g., scientists analyzing data or teachers automating grading), while professionals focus on comprehensive system design and integration.[16] The motivations of end-users and professional developers diverge significantly. End-users engage in development to solve immediate, personal, or task-oriented problems, prioritizing functionality over long-term quality or scalability, such as customizing spreadsheets for financial modeling.[14] Professional developers, however, are driven by organizational requirements, user demands, and commercial viability, often working in teams to ensure software reliability and compliance with standards.[16] As a result, end-user efforts emphasize rapid prototyping and iteration within constrained timeframes, whereas professionals invest in upfront planning and documentation to mitigate risks in complex environments.[15] Skills and expertise further highlight these differences. End-users typically possess deep domain knowledge but limited software engineering proficiency, relying on intuitive tools like visual builders or macros that abstract away low-level code.[14] Professionals, by comparison, master programming languages, algorithms, and practices such as version control and automated testing, enabling them to handle intricate architectures and edge cases.[16] This gap leads end-users to adopt ad-hoc, implicit strategies—such as trial-and-error debugging—while professionals apply systematic approaches, including formal requirements elicitation and peer reviews.[15] Challenges in EUD stem from end-users' resource limitations and overconfidence in their creations, often resulting in untested applications prone to errors or security vulnerabilities.[14] Professionals face their own hurdles, including bridging communication gaps with non-technical stakeholders and maintaining legacy systems, but benefit from institutional support and tools tailored for scale.[16] Despite these variances, both groups encounter common software engineering issues like requirements evolution and maintenance, underscoring the need for EUD tools that borrow from professional practices without overwhelming users.[15]| Aspect | End-Users | Professional Developers |
|---|---|---|
| Primary Focus | Domain-specific, immediate tasks (e.g., data analysis in spreadsheets) | Scalable, maintainable systems for multiple users |
| Development Approach | Opportunistic, visual/declarative tools | Systematic, code-based with testing frameworks |
| Key Risks | Poor quality, security flaws due to inexperience | Integration complexity, evolving requirements |
| Benefits | Empowerment, reduced IT dependency | High reliability, team collaboration |