Hubbry Logo
Alice (software)Alice (software)Main
Open search
Alice (software)
Community hub
Alice (software)
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Alice (software)
Alice (software)
Alice (software)
View on Wikipedia
from Wikipedia
This article is about the educational programming environment. For the multi-paradigm language based on ML, see Alice ML. For other uses, see Alice (disambiguation).
Alice
DeveloperCarnegie Mellon University
Initial release1998
Stable release
3.9.0.2 / June 8, 2024; 20 months ago (2024-06-08)
Written inJava
PlatformJava platform

Windows

MacOS

Linux (Debian file format)
TypeEducational
LicenseSome parts released under an open-source license, source code is available[1]
Websitewww.alice.org

Alice is an object-based educational programming language with an integrated development environment (IDE). Alice uses a drag and drop environment to create computer animations using 3D models. The software was developed first at University of Virginia in 1994, then Carnegie Mellon (from 1997), by a research group led by Randy Pausch.

Origin of name

[edit]

According to Randy Pausch, the name "Alice" comes from author Lewis Carroll, who wrote Alice’s Adventures in Wonderland. He said:[2]

Alice pays homage to Lewis Carroll, author of Alice’s Adventures in Wonderland and Through the Looking Glass. Carroll was a mathematician, novelist, and photographer. Most important, he could do intellectually difficult things but also realized the most powerful thing was to be able to communicate clearly and in an entertaining way. This inspires our efforts to make something as complex as computer programming easy and fun. The name is also a very practical choice. The artwork associated with the Alice books is now in the public domain, its copyright having lapsed. Also, the name "Alice" has several other advantages: It is easy to spell. It is easy to pronounce. It shows up near the top of alphabetical lists.

Purpose

[edit]

Alice was developed to address four core problems in educational programming:[3]

  1. Alice is designed solely to teach programming theory without the complex semantics of production languages such as C++. Users can place objects from Alice's gallery into the virtual world that they have imagined, and then they can program by dragging and dropping tiles that represent logical structures. Additionally, the user can manipulate Alice's camera and lighting to make further enhancements. Alice can be used for 3D user interfaces.
  2. Alice is conjoined with its IDE. There is no syntax to remember. However, it supports the full object-based programming, event driven model of programming.
  3. Alice is designed to appeal to specific subpopulations not normally exposed to computer programming, such as students of middle school age, by encouraging storytelling. Alice is also used at many colleges and universities in Introduction to Programming courses.
  4. Alice can be used with Netbeans to convert the Alice file into Java.[4]

Alice 3 is released under an open-source license allowing redistribution of the source code, with or without modification.[5]

Research

[edit]

In controlled studies at Ithaca College and Saint Joseph's University looking at students with no prior programming experience taking their first computer science course, the average grade rose from C to B, and retention rose from 47% to 88%, exceeding even the 75% retention rate of students with prior programming experience.[6]

In a second study at Carnegie Mellon University, students taking their first computer science course with a mediated transfer approach that transitioned from Alice 3 to Java scored an average of 84.96% and 81.52% in two semesters of testing this approach, compared to an average of 60.8% before the mediated transfer approach.[7]

Screenshot of Alice 3.7

Variant

[edit]

A variant of Alice 2.0 called Storytelling Alice[8] was created by Caitlin Kelleher for her PhD dissertation.[9] It includes three main differences:

  1. High-level animations that enable users to program social interactions between characters.
  2. A story-based tutorial that introduces users to programming through building a story.
  3. A gallery of 3D characters and scenery with custom animations designed to spark story ideas.

In a study performed on middle-school girls in the United States, Storytelling Alice appeared to increase interest compared to generic Alice, with a 42% increase in programming time, with students three times as likely to do additional work on their projects, with no reduction in basic programming concepts learned.[10]

Storytelling Alice was succeeded by the interactive storytelling application Looking Glass, developed at Washington University in St. Louis.[11]

See also

[edit]

References

[edit]

Further reading

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Alice (software)

View on Grokipedia
from Grokipedia
Alice is a free, innovative block-based programming environment designed to teach fundamental programming concepts, logical thinking, and object-oriented principles through the creation of 3D animations, interactive narratives, and simple games. Developed by the Alice Project at , it emphasizes creative exploration over rigid puzzle-solving, making it accessible for beginners across , high school, and levels, while particularly targeting diverse and underserved groups to boost engagement and retention in education. The software features a drag-and-drop interface where users manipulate 3D objects and characters in a , allowing immediate visual feedback on execution without the need for traditional text-based . Key elements include a of pre-built 3D models, effects, and camera controls, enabling users to build complex scenes intuitively. Alice 2, an earlier version, established its reputation for fostering skills, while Alice 3 builds on this foundation by integrating more advanced tools and compatibility with environments like for broader development capabilities. Since its inception, Alice has been distributed as with extensive supplemental resources, including curricula, tutorials, and online workshops, to support educators and informal learning settings. Its impact lies in demystifying programming for non-experts, with proven benefits in encouraging participation from underrepresented demographics in STEM fields, and it continues to evolve with updates focused on inclusivity and real-world applicability.

Development

Origins and Naming

Alice was initiated in 1994 at the as an educational tool aimed at facilitating 3D animation and introductory programming for novices. Developed by and his Stage 3 research group, it emerged from broader efforts to lower barriers in (VR) content creation, allowing non-experts to prototype interactive 3D environments without deep technical knowledge. This work built on Pausch's early 1990s research, including his 1991 paper "VR on $5 a Day," which explored accessible VR systems to enable rapid experimentation with virtual worlds as a medium for teaching complex concepts like programming to beginners. The project's early prototypes emphasized simplifying 3D graphics programming, using a scripting-based approach integrated with the Python language to make VR development intuitive for users lacking prior experience in graphics or coding. By 1995, Alice had been in active internal use at for over two years, supporting graduate courses and researcher collaborations while building a of reusable 3D objects and classes. The name "Alice" was chosen to honor , the author of , symbolizing the goal of rendering intricate ideas—like programming and —accessible, imaginative, and engaging for newcomers. Carroll, a mathematician known for clearly conveying complex topics through whimsical narratives, inspired the software's user-friendly ethos. Additionally, the artwork from Carroll's Alice books had entered the , providing readily available illustrations that could be adapted into 3D models without concerns. In 1997, the project transitioned to , where Pausch continued its evolution.

Key Contributors and Timeline

The development of Alice was led by , who joined (CMU) in 1997 and expanded the project from its origins at the in 1994, shifting focus toward educational applications in 3D programming. Under Pausch's direction at CMU's Stage 3 research group, affiliated with the Robotics Institute, Human-Computer Interaction Institute, and Department of Computer Science, the team grew to include key contributors such as Wanda Dann and Stephen Cooper, who co-authored foundational curricula and textbooks. Caitlin Kelleher, a PhD student and later collaborator, contributed significantly to later variants, notably developing Storytelling Alice in 2007 to enhance engagement for middle school users. The project's timeline began with its transfer to CMU in 1997, followed by the first public release, Alice 99, in 1999, which introduced drag-and-drop coding for novice users. Subsequent milestones included the launch of Alice 2.0 in 2004, alongside the textbook Learning to Program with Alice, and the beta testing of Alice 3 in 2009, marking the integration with Java for object-oriented programming and text-based code export via NetBeans. Alice 3's full release came in 2010, incorporating assets from Electronic Arts' The Sims 2 through a partnership. In 2015, the project relocated within CMU to the Entertainment Technology Center, continuing under open-source development on GitHub. Since 2015, the project has continued open-source development on GitHub, with the 30th anniversary celebrated in October 2025. The latest stable release, version 3.9.0.3, occurred on November 12, 2025, supporting Windows, macOS, Linux, Raspberry Pi, and Chromebook platforms. Funding has primarily come from university resources at CMU and grants from the (NSF), supporting educational outreach and research into programming pedagogy. These resources enabled ongoing maintenance and expansions, with the project distributed freely under CMU's .

Educational Purpose

Target Audience and Learning Objectives

Alice is primarily designed for novice programmers, ranging from students to undergraduates, particularly those without prior coding experience. It targets diverse and underserved populations, including girls and underrepresented groups in , by leveraging engaging, creative activities to make programming accessible and appealing. The core learning objectives focus on introducing fundamental programming concepts through visual, block-based methods, including procedures, loops, conditionals, and . These are taught within an object-oriented framework, enabling users to grasp principles like classes, objects, and methods without encountering syntax errors that often frustrate beginners. Beyond technical skills, Alice aims to foster logical and computational thinking while reducing the intimidation associated with traditional coding. By allowing users to build 3D animations, interactive narratives, and simple games, it promotes creativity and storytelling, helping students gain confidence before transitioning to text-based languages such as . In educational settings, Alice integrates into introductory curricula, such as CS1 courses, to teach object-oriented principles without the barriers of textual syntax, thereby supporting a smooth pathway to more advanced programming.

Pedagogical Principles

Alice employs visual programming as a core principle to eliminate syntax barriers that often frustrate novice learners, allowing them to focus on logical problem-solving and algorithmic design rather than grammatical errors. This drag-and-drop interface, where code blocks are assembled like puzzle pieces, aligns with constructivist learning theory, which posits that students construct knowledge most effectively through active creation and experimentation in meaningful contexts. By visualizing program execution in a 3D world, Alice enables immediate feedback, fostering deeper understanding of computational concepts without the distraction of textual . A key emphasis in Alice's design is on and to boost learner engagement, drawing from narrative-driven pedagogies that transform abstract programming into relatable, creative endeavors. Users program 3D characters to enact stories or interactive games, making concepts like loops and conditionals concrete through scenarios such as character dialogues or quests, which particularly motivate underrepresented groups like middle school girls. This approach not only sustains interest—evidenced by increased programming time and enthusiasm—but also illustrates how narrative contexts can bridge creative expression with technical skills. The software adopts an object-based paradigm to introduce fundamentals early, teaching encapsulation and methods through direct manipulation of 3D objects in virtual worlds. Each object bundles ( like position or color) and behaviors (methods like movement or interaction), mirroring real-world OOP principles where private attributes are accessed only via defined procedures, thus promoting secure and modular code design from the outset. This hands-on method helps novices grasp and polymorphism by extending or modifying object classes visually. To scaffold progression to text-based languages, Alice 3 incorporates mediated transfer techniques, including the ability to export visual programs as code via a plugin, allowing learners to view and edit underlying syntax while retaining familiar structures. This bridging enables gradual exposure to conventional programming environments, using analogies and incremental challenges to connect visual abstractions to Java's explicit rules, thereby easing the transition for advanced study. Alice operates under an open-source model, with its source code hosted on GitHub to facilitate community contributions, modifications, and broader accessibility in educational settings, while adhering to Carnegie Mellon University's end-user license agreement that permits non-commercial redistribution with proper attribution.

Core Features

Programming Interface

Alice employs a visual, block-based programming interface designed to enable users to construct programs through intuitive manipulation rather than text entry, facilitating the creation of interactive 3D animations and narratives. Users interact with a Code Editor where they drag and drop graphical tiles representing commands and control structures from a Methods panel, such as movement instructions like "move" or "turn," and conditional elements like "if-then" statements. These tiles snap into place along a green guideline to indicate sequence, allowing for the assembly of methods that dictate object behaviors in the virtual environment. Control tiles, including "do in order" for sequential execution and "do together" for concurrent actions, provide essential mechanisms for managing program flow without requiring syntactic knowledge. The interface supports an model, where programs respond dynamically to user inputs within the 3D world, such as clicks, keyboard presses, or changes in object positions. Events are configured in a dedicated "initializeEventListeners" method within the Scene class, categorizing triggers like scene activation, keyboard inputs, or interactions, with policies such as "ignore," "enqueue," or "combine" to handle multiple simultaneous events. This setup allows methods to be invoked in response to runtime interactions, enabling interactive scenarios like via dragging. Central to the interface is the organizational structure of the , represented by the Scene class, which serves as the foundational container for all elements, including 3D objects, a , and camera settings. Methods and properties are attached modularly to individual objects or the world-level "myFirstMethod" for initialization, promoting object-oriented principles through hierarchical management. Billboards, as specialized 2D elements, integrate into this structure by adding image-based backdrops (e.g., or files) that always face the viewer, enhancing scene composition without complex modeling. Debugging is integrated seamlessly through visual and interactive tools that leverage the animated nature of code execution. Users can right-click tiles to disable specific statements for isolated testing, employ a "fast forward" feature to preview individual instructions, and utilize /redo functionality along with project history to revert changes. An embedded viewer activates via the "Run" button, opening a runtime window for real-time playback of animations, complete with pause, restart, and speed controls to observe and troubleshoot behaviors as they unfold. For transitioning to text-based languages, the interface includes code export capabilities that generate from Alice projects. A "Java Code On The Side" option displays equivalent alongside the blocks in a read-only view, while full export saves projects as class files importable into environments like via an Alice plugin, aiding gradual exposure to procedural code.

3D Modeling and Animation Tools

Alice provides users with a comprehensive gallery of pre-built 3D models, including characters such as bipeds and quadrupeds, vehicles like flyers, and environmental elements drawn from public domain sources and licensed assets like The Sims 2 characters. These models are organized by class hierarchy, themes, groups, and search functions, allowing easy selection and placement in scenes. Customization options enable modifications to textures, colors, opacity, size, and positioning, with subparts adjustable via skeletal joints and rotation handles in the scene editor. Animation in Alice relies on keyframe-based sequencing, where users arrange movements, rotations, and scaling through sequential procedures in dedicated tabs like myFirstMethod, creating smooth transitions over specified durations. Built-in controls support one-shot actions such as moving forward or backward, turning left or right, and rolling, with parameters for distance and revolutions to facilitate precise . These animations can be briefly attached to programming events for interactive responses, enhancing scene dynamics without requiring complex scripting. The camera system features adjustable viewpoints through pre-set options like top, side, front, and isometric views, along with markers for defining paths and dynamic shots to support narrative storytelling. tools allow users to modify and atmospheric colors, above- and below-light intensities, and , creating varied effects to improve visual depth and mood in animations. Physics simulation includes basic using object bounding boxes, which notifies overlaps during runtime, though it is not infallible for complex interactions. effects can be simulated by positioning objects to fall naturally or through procedural adjustments, supporting simple interactive games with realistic motion. Import capabilities provide limited support for external models, such as (.dae) files in Alice 3 via the resource manager, enabling integration of user-created assets after conversion if needed. Export options allow saving animations as video files in formats like for sharing, including direct upload to platforms like , though audio synchronization may require additional troubleshooting.

Versions and Variants

Alice 2.0

Alice 2.0, released in 2004 by Carnegie Mellon University (CMU), represented a significant evolution from the original 1999 prototype known as Alice 99, incorporating enhanced stability and broader cross-platform compatibility for Windows and Mac operating systems. This version built upon the foundational drag-and-drop interface of its predecessor while integrating pedagogical insights from educators, resulting in a more robust tool for introductory programming education. Accompanying the software was the textbook Learning to Program with Alice by Wanda Dann and Stephen Cooper, which provided structured curriculum resources to guide users through object-oriented programming concepts via 3D animations. Key features of Alice 2.0 included an expanded of puzzle-piece-style blocks for drag-and-drop programming, enabling users to construct animations without traditional text-based coding, and a basic expansion of the 3D object gallery to include more diverse models for scene building. The interface emphasized visual scripting, where users could manipulate 3D characters and environments to create interactive stories or simple simulations, fostering without requiring integration or external dependencies. These elements made Alice 2.0 accessible for beginners, prioritizing ease of use over advanced functionality. As a standalone application, Alice 2.0 had limitations such as the absence of easy export capabilities, confining projects to the Alice environment without seamless transition to other programming languages. It focused primarily on and creation rather than supporting complex game development or real-time interactions, which constrained its scope for more advanced applications. By the late , Alice 2.0 achieved widespread adoption, being used in 10 to 15 percent of U.S. colleges and universities, as well as numerous high schools, with CMU providing extensive curriculum materials to support implementation. This version also served as the foundation for the Storytelling Alice variant, a specialized aimed at engaging middle school girls through story-driven programming.

Alice 3.0

Alice 3.0, first released in beta in 2009 and fully launched in 2010, represents a significant in the Alice programming environment, serving as the current primary version with the latest update, 3.9.0.3, issued in November 2025. Recent updates include bug fixes for binary operations and enhanced error reporting. This version was rewritten in to enhance performance through optimized libraries and improve portability across operating systems, including the addition of native support alongside Windows and macOS. Key technical upgrades in Alice 3.0 include integration with , enabling users to generate and edit code directly alongside the block-based interface for seamless transition to text-based programming. Expanded 3D import options allow incorporation of custom models, broadening creative possibilities beyond the built-in gallery. Additionally, VR support is provided through the Alice 3 Player, a standalone Unity-based application that enables running projects in environments. These enhancements build on the drag-and-drop interface from Alice 2.0 while introducing more robust capabilities for modern educational use. The version also features enhanced tools such as advanced event handling for responsive interactions like mouse and keyboard inputs, integrated sound capabilities using for adding audio to animations. Alice 3.0 is distributed as a free download from alice.org, compatible with various platforms including and Chromebooks in beta, and includes curriculum kits with tutorials, sample projects, and educator resources to facilitate classroom integration.

Specialized Variants

Storytelling Alice is a specialized variant of Alice 2.0 developed in 2007 by Caitlin Kelleher as part of her doctoral research completed in 2006 at (CMU), designed to motivate girls to learn programming through features. It extends the core environment with social computational elements, such as non-player characters that prompt users to create dialogue trees and narrative interactions, fostering engagement by aligning programming with creative expression. In user studies, participants using Storytelling Alice spent 42% more time programming compared to those using the standard Alice 2.0, and they were over three times more likely to voluntarily extend their sessions. Other variants include the Alice 3 with integration, an extension for advanced users transitioning to professional development, which allows importing Alice 3 projects into the NetBeans IDE for further coding and compilation. Limited experimental versions, such as the Alice 3 Player + VR, support immersive learning by enabling Alice worlds to run in environments using Unity, enhancing spatial programming experiences. Additionally, open-source forks have facilitated niche integrations, exemplified by adaptations like Finch 4 Alice, which connects the environment to the for hands-on programming. These specialized variants were primarily led by CMU researchers and collaborators, building on the open-source nature of Alice to address targeted educational needs. Storytelling Alice remains downloadable from the official alice.org archives but has not been actively maintained since around 2010, while other extensions like and VR support continue to evolve with core Alice updates.

Research and Impact

Empirical Studies on Effectiveness

Empirical studies on Alice's effectiveness have primarily employed quasi-experimental designs, including pre- and post-tests, control groups exposed to traditional programming languages like , and comparisons of at-risk novice learners. These methodologies allow researchers to assess improvements in conceptual understanding, performance, and retention while controlling for prior experience. A key early study conducted in the early 2000s at and examined Alice's impact on at-risk majors with limited prior programming exposure. Students in the Alice treatment group achieved an average CS1 GPA of 3.0, compared to 1.9 in the control group using traditional methods, representing an improvement of at least one letter grade. Retention rates in CS1 rose from 47% in the control group to 88% in the treatment group, with similar gains for high-risk subgroups (84% versus 15%). These results were statistically significant (p < 0.05, chi-squared and ANOVA tests). At , follow-up research on mediated transfer from Alice 3 to reinforced these findings, showing doubled retention for (88% enrollment in CS2 after Alice exposure versus 47% without). In transition courses at , students using Alice 3 before achieved average final exam scores of 84.96% and 81.52% in successive semesters, significantly higher than 60.8% in prior Java-only courses (p < 0.001, ANOVA). These outcomes highlight Alice's role in bridging to text-based languages while boosting success rates. Trials of Storytelling Alice, a variant tailored for narrative-driven programming, demonstrated enhanced among middle school girls. In a controlled study comparing it to generic Alice, girls using Storytelling Alice spent 42% more time programming and were over three times as likely to choose programming over non-programming tasks. Qualitative feedback indicated reduced , with participants reporting programming as a creative tool rather than a male-dominated technical skill, fostering greater motivation and interest. Broader meta-analyses confirm 's positive effects on conceptual understanding in programming, with an overall of 0.54 (Cohen's d, 95% CI: 0.34–0.74) across six quasi-experimental studies involving 464 participants from 2000 to 2014. Alice outperformed conventional languages in learning outcomes, though variability arose from differing teaching methods. However, data on long-term retention remains limited post-2015, with calls for more longitudinal . Recent studies, such as a 2025 evaluation in IEEE Access, continue to show positive effects on programming competencies for university students, though large-scale longitudinal post-2020 is still sparse.

Educational Adoption and Legacy

Alice has been integrated into U.S. K-12 and university curricula since the early 2000s through the efforts of Carnegie Mellon University's (CMU) Alice Project, an outreach initiative that provides free resources, curricula, and professional development for educators. By 2009, Alice was adopted by over 10% of U.S. colleges and universities for introductory programming courses, with workshops introducing the tool to more than 10,000 students in K-12 settings. These programs have emphasized engaging novice learners, particularly in , fostering broader educational outreach. Globally, Alice has achieved widespread use, with adaptations and implementations in and to support diverse educational contexts, making it accessible as a tool for worldwide. Ongoing international competitions, such as Romania's Learn to Code with Alice (involving over 7,000 students and 3,000 teachers as of 2024) and Qatar's localized , demonstrate sustained adoption. Its design has aligned with initiatives promoting diversity in , encouraging participation from underrepresented groups in programming . The legacy of Alice extends through its pioneering of 3D visual programming paradigms for education, influencing the broader field of block-based environments. Randy Pausch's 2007 "" significantly boosted its visibility, highlighting Alice as an innovative and inspiring broader adoption. As an open-source project since its repository launch on , Alice sustains community-driven updates, with contributions from developers enhancing its features and accessibility. Research indicates that such visual tools like Alice support improved student retention in computing courses. Documentation on Alice's integrations in the 2020s has grown, including adaptations for via the Alice 3 Player and explorations of AI-assisted features and voice-activated programming as of 2024. While remote learning applications during the were not extensively documented, ongoing developments focus on hybrid environments and inclusivity. Looking ahead, expansions into AI and VR offer potential for enhanced interactive educational applications.

References

  1. https://www.alice.org/
  2. https://www.cs.cmu.edu/outreach/programs/alice
  3. https://www.alice.org/get-alice/alice-2/
  4. https://www.alice.org/get-alice/alice-3/
  5. https://www.cs.cmu.edu/~stage3/publications/95/journals/IEEEcomputer/CGandA/paper.html
  6. https://www.alice.org/about/our-history/
  7. https://www.alice.org/about/
  8. https://www.alice.org/about/the-team/
  9. https://www.cs.cmu.edu/news/2008/carnegie-mellon-begins-beta-tests-alice-3-software-new-version-incorporates-resources-ea-hit
  10. https://www.cs.cmu.edu/~kiesler/publications/2007pdfs/2007_Storytelling-Alice-motivates-middle-school.pdf
  11. https://cacm.acm.org/opinion/education-alice-3/
  12. https://www.oakparkusd.org/cms/lib5/CA01000794/Centricity/Domain/294/chapter01.pdf
  13. https://www.researchgate.net/publication/281933623_Using_Alice_for_Teaching_Object-oriented_Programming_for_Novice_Programmers
  14. https://www.alice.org/wp-content/uploads/2017/04/TeachingObjects-firstInIntroductoryComputerScience.pdf
  15. https://dl.acm.org/doi/10.1145/1240624.1240844
  16. http://cse.unl.edu/~scooper/alice/p141-dann.pdf
  17. https://github.com/TheAliceProject/alice3
  18. https://www.alice.org/wp-content/uploads/2017/05/Alice-3-HowToGuide-Complete.pdf
  19. https://www.alice.org/wp-content/uploads/2019/11/Programming-In-Alice-Facilitation-Guide.pdf
  20. https://www.alice.org/wp-content/uploads/2017/04/chialice.pdf
  21. https://www.alice.org/wp-content/uploads/2019/10/Building-A-Scene-Facilitation-Guide.pdf
  22. https://www.alice.org/resources/how-tos/importing-models-overview/
  23. https://www.alice.org/resources/how-tos/recording-and-sharing-alice-worlds/
  24. https://aace.org/review/curiouser-and-curiouser-creating-stories-and-games-with-alice-3-part-2/
  25. https://www.cmu.edu/homepage/computing/2008/fall/onward-with-alice.shtml
  26. https://www.alice.org/wp-content/uploads/2017/05/Alice-3-HowToGuide-Part1.pdf
  27. https://www.alice.org/get-alice/alice-3-player/
  28. https://www.alice.org/resources/exercise-and-project/tutorial-introduction-to-events/
  29. https://www.alice.org/resources/how-tos/the-basics-of-using-audio/
  30. https://www.alice.org/get-alice/storytelling-alice/
  31. https://www.alice.org/get-alice/alice-3-with-netbeans/
  32. http://cse.unl.edu/~scooper/alice/p75-moskal.pdf
  33. https://www.alice.org/wp-content/uploads/2017/04/EvaluatingTheEffectivenessOfANewApproach.pdf
  34. https://www.alice.org/wp-content/uploads/2017/04/MediatedTransfer.pdf
  35. https://bera-journals.onlinelibrary.wiley.com/doi/abs/10.1111/bjet.12496
  36. https://ieeexplore.ieee.org/document/10857329
  37. https://ui.adsabs.harvard.edu/abs/2011nsf....1031029S/abstract
  38. https://etc.cmu.edu/about/news-events/alice-30-years
  39. https://www.alice.org/get-alice/
  40. https://speakola.com/motivate/randy-pausch-last-lecture-2007
Add your contribution
Related Hubs
User Avatar
No comments yet.