Dear Squeakers, Smalltalkers, and friends of object-oriented, interactive programming environments!
We cordially invite you again to our annual meeting of German-speaking Squeakers (Squeak Deutschland e.V). It will be filled with exciting lectures, demos, and discussions led by both us and you, while also serving as the general assembly of the association. If you want, you can end the meeting with us in the evening in a cozy atmosphere in a nearby inn.
Should I register?
Do you want to participate or do you have any questions or do you even have an idea for demo / lecture / discussion? Get in touch with us so we can plan better. We would like to remain flexible in terms of time and would plan about 15 to 45 minutes for orientation for each lecturer.
For participation on site, please register by informal email to: marcel.taeumel@hpi.de
When do we meet?
Saturday, November 2, 2024, from 1 p.m.
Where do we meet?
We will hold the event in a hybrid form. After registration you can find us on site:
Hasso Plattner Institute for Digital Engineering gGmbH Prof.-Dr.-Helmert-Str. 2-3 14482 Potsdam
It was 28 years ago today when an email (Swiki copy here) was sent to comp.lang.smalltalk by Dan Ingalls with the subject “Squeak – A Usable Smalltalk Written in Itself,” marking the first announcement of Squeak to the world. In his email, Dan announced the release of Squeak with the intent to promote collaboration with academia and industry. Squeak began on a reconditioned Smalltalk-80 system from Apple’s ST-80. Notably, the implementation was written almost entirely in Smalltalk. Beginning with the Blue Book spec, a 32-bit direct pointer Object Memory and incremental garbage collection was added. Additionally it included a color BitBlt, a portable file system, and basic support for polyphonic music synthesis. Contributions were welcome, and the rest, well, is ongoing history.
We would like to acknowledge the invaluable contributions of all who have supported the project. In celebration of this milestone, we reached out to several current contributors, who then also shared this request with others to gather their thoughts on this occasion.
Alan Kay, for this celebration, emphasized several noteworthy contributions that the creation of Squeak and the achievements made for it brought to the community, which he believed deserved recognition. The highlighted contributions were:
Self-Bootstrapped – One of the most remarkable features was Squeak’s bootstrapping process, which allowed the environment to be constructed and run entirely on its own code. This self-hosting capability not only facilitated rapid development but also ensured flexibility and adaptability without reliance on external systems.
Freed from Xerox Ownership – The transition from Xerox ownership to independence was made possible by a special arrangement for the original developers of Smalltalk-80. This agreement enabled them to retain rights and forge a new path for the language, ultimately leading to the creation of Squeak. The developers were determined to continue the Smalltalk tradition while expanding its capabilities.
MIT Licensing – An important moment for Squeak came when design expert Don Norman helped secure a licensing deal that positioned Squeak under the MIT License. This permissive license encouraged a broad community of developers to contribute and collaborate, making Squeak accessible for educational and commercial purposes alike.
Rapid Multi-Platform Deployment – The combination of its innovative bootstrapping approach and strong community support allowed Squeak to achieve impressive cross-platform compatibility. Within just a few months of its initial release, Squeak was operational on all major operating systems, including macOS, Windows, and various Unix distributions. This rapid deployment not only expanded its user base but also solidified its status as a versatile tool for developers and educators.
We extend our heartfelt gratitude to Alan Kay for highlighting these significant achievements of Squeak and recognizing everyone who played a role in its development.
Göran Krampe – “I haven’t used Squeak or Smalltalk for many years. But I fondly remember the time I was heavily involved in the Squeak community, it was fun and warm and I got to know a lot of very sharp and interesting people. I got smitten by Smalltalk around 1993 when I studied Computer Science at KTH in Stockholm. I still consider Smalltalk to be my ‘home language’ which I feel the most at ease in. Eventually I got interested in other languages like Nim and Dart and I ended up trying to implement a simple Smalltalk-like language myself. Last time I really worked with Squeak I worked together with Ron Teitelbaum on the system called Teleplace (renamed many times!) originating from the Croquet project.
“Now, looking at the programming future and daring to make some observations or predictions, there are some obvious trends I think I see…there are so many different areas of software development where Smalltalk still can have an edge, for example in complicated simulation or interactive data exploration scenarios. I think that is where interesting options can be found…Squeak and Smalltalk with the image model and the highly flexible and malleable development environment has a great opportunity right now in tapping into AI…if I would be looking at improving the Squeak development environment – this is clearly where I would put the effort. The programming landscape is changing…I am very sure programming will not look the same in 5 years time. It is already happening.”
Chris Muller – “The rise of cloud app’s made our lives ‘easier,’ but also married us to their limitations. As dependence on them grows, so does the importance of having access to open Personal Computing. ‘Personal,’ meaning an unfettered interaction between an individual and their computer. No sign-ups. No subscriptions. No data-collections. Just a computer, executable, open canvas, and human imagination. Beautiful. Happy 28th!”
Marcel Taeumel – “Happy birthday to the Squeak project! As we celebrate this milestone, I want to express my appreciation for its commitment to backwards compatibility and modularity, which ensures extensibility and readability. Over the past decade of using Squeak for teaching and research in object-oriented design, I have come to value its powerful tools for exploration and debugging. Looking ahead, I envision meaningful improvements that respect and build upon the content we have created. Smalltalk is a beautiful language, and Squeak enables us to learn and grow in ways that truly enhance our productivity. Here is to many more years of success for Squeak and its community!”
Ron Teitelbaum – “I joined the community 19 years ago. It seems like only yesterday. In so many ways the community has changed but in many essential ways it has stayed the same. In that time we relicensed Squeak, went through a few major splits, with Eliot Miranda we helped to develop the new VM and support for ARM, helped push forward Cryptography, and with Ronie Salgado helped to contribute to 3d graphics. We have lost some amazing Squeak people. We also gained some very talented developers that have stepped up in amazing ways to help keep the community functioning. I’d like to say a big thank you to all of you that contribute in so many ways to keeping Squeak alive. It has been amazing. Feels like there is so much more we could do! Happy Birthday Squeak!”
Feel free to share your thoughts or wishes in the comments below!
The Universidad Nacional de Mar del Plata will host this year’s Smalltalks 2024 conference from November 13 to 15. A pre-conference Smalltalks track, designed for students and teachers, will take place on November 11 and 12.
Registration is open here, and talk proposals can be submitted until September 30 (extended from the original September 13 deadline). Accepted talks will be announced on October 10.
On the Squeak developers mailing list, Lauren Pullen shared her experience (found here) using Squeak while working on a rendering engine for a first-person maze game, similar to the technique used to render the original Wolfenstein 3D game. Wolfenstein 3D used a rendering technique known as ray casting. Her project captured our attention prompting us to seek additional information from her about it.
What is Ray Casting?
Ray casting is an early rendering technique used in computer graphics and video games, particularly in 2.5D and 3D environments. It is a simplified form of ray tracing, where a ray is cast from the player’s or camera’s perspective into the environment, and the distance to the nearest object along that ray is calculated. This process is repeated for each column on the screen, creating a 3D representation of the 2D world. Ray casting was widely used in the early days of 3D gaming, particularly in games like Wolfenstein 3D (1992).
From Lisp to Squeak
Lauren, with her extensive experience in Common Lisp, initially chose it to create a GUI application. However, she faced significant challenges. The graphics library was unreliable, often failing to start, and the outdated documentation made it difficult to work with. She studied MVC while designing her application but struggled with basic functionality, such as displaying a simple window.
She decided to switch to Smalltalk, specifically Squeak, which had an immediate impact. The graphical elements worked seamlessly from the start, and although she missed some features from Common Lisp, like restarts and method combinations, Squeak provided a development environment that allowed her to focus on development without drastically changing her mental approach to problems.
Comparing Development Tools
For game development, she initially relied on a much earlier version of Game Maker Pro. When she explored Godot, she found its complexity overwhelming compared to Smalltalk. The disorganization in Godot’s tutorials made her question how to create a basic viable product efficiently. In contrast, though seemingly minimal, Squeak’s classes Form and UserInputEvent provided all that was needed.
Advantages of Squeak
In Squeak, she found it easy to work with graphical elements. Drawing interface components and importing graphics were straightforward, thanks to the source code access for built-in drawing functions. This simplicity was crucial for her development process. While working on the game, she realized that making changes and seeing immediate results was invaluable for debugging. Her experience with Forth taught her the value of functions that do one thing well, and Smalltalk’s debugging tools like Inspect-It and Debug-It further streamlined the process.
Challenges and Solutions
However, she encountered challenges. While most errors in Smalltalk were easy to handle—usually, closing the Debugger was all that was needed—some issues could freeze the image, making recovery a bit more manual than desired. She found herself needing to use the Recover Changes window to restore unsaved changes more often than she would have liked.
In terms of rendering, she faced performance limits with BitBlt when texturing the floor and ceiling. To overcome this, she turned to the AbstractGPU library, leveraging the graphics card for drawing. She continued to use the ray caster to determine what the player could see to speed up the game, but introduced edge pop-in, where objects on the screen edges would suddenly appear while turning the camera, because of differences between the ray caster’s projection and the GPU’s projection. Increasing the field of view used by the ray caster resolved this issue.
Testing Using Morphic Dungeon
Morphic Dungeon is what Lauren developed and uses to test the movement and texturing code. She wants to work with textures that are not symmetrical, which requires mapping the top-left corner of the texture to different positions on each face of the 3D objects. This approach also allowed her to test back-face culling—a technique that improves performance by not drawing faces of a 3D object that are not visible to the camera—in the GPU mode. In this mode, the “back faces” are flipped horizontally and appear further away, as if looking at the inside of a transparent painted box instead of the outside. Back-face culling will be essential for rendering the “walls” of tiles that the player can enter or see through, such as grass or support beams along the grid edges.
Lauren implemented three movement modes:
Free Movement and Free Turning
Grid-Locked Movement and Free Turning
Grid-Locked Movement and Grid-Locked Turning
Full Free Movement is similar to Wolfenstein 3D, allowing sub-pixel steps and small increment camera rotations.
Grid-Locked Movement is useful for first-person dungeon crawlers. Grid-Locked Turning forces camera rotation to 90-degree increments, similar to classic non-raycaster games like Wizardry or modern titles like Etrian Odyssey. Free camera rotation, with Grid-Locked Movement, is also supported which is similar to the modern title Operencia.
While using Morphic Dungeon to test the different movement modes, Lauren encountered an amusing floating point error whereby the player would step repeatedly through walls and out of the play area. This provided a humorous insight into the potential bugs she might encounter.
Additionally, Lauren tested the game with a family member, revealing that the 40×40 maze, though not difficult from an overhead view, proved challenging from a first-person perspective without an overhead view or compass. This feedback helped her adjust the difficulty of the first area to better suit new players.
Future Plans
Looking ahead, she plans to explore non-flat levels and dynamically stitching multiple maps together. This might result in overlaps while rendering, so the ray caster will be in charge of telling the graphics card what to draw. Meanwhile, she will focus on improving floor and ceiling loading performance, although this is currently less critical due to the few vertices involved.
Lauren believes that developing a game is a great way to introduce people to programming. While tools are useful, having something that you can play with is fun. Old tile-based games and raycasters are particularly appealing to her because they are simple to work with, even for beginners.
Overall, Lauren believes that Squeak has proven to be an excellent choice for her project, offering the simplicity and functionality needed for a successful game development experience.
Why Not Give It a Try?
If you would like to experiment with ray casting in Squeak, you can find out more about her project from SqueakSource here. To use the 3D accelerated package, you will also need AbstractGPU by Ronie Salgado, available (here). Ronie is the author of a number of terrific 3D development tools, including Woden (here) and Sysmel (here). Be sure to explore these excellent resources as well!
Have a great time with Smalltalk and keep on Squeaking!
Squeak is a highly open system, which makes it very easy not only to explore every interesting detail in the image but also to customize everything at your will. Whether you would like to adjust some colors, fix a bug you have stumbled upon, or add a new feature, (almost) everything is flexible and under your control.
Squeak lives from your contributions! Squeak is powered by volunteer open-source contributions. Whenever you make an adjustment to the base system, you might ask yourself: “could others benefit from this change, too?” If the answer is yes, we invite you to consider contributing back to the community. Or if you just discovered a bug, have a question, or would like to discuss an idea, our forums are open!
On the mailing list, ideas, bug reports, and patches are exchanged. Version control for all Squeak packages is run via Monticello. All versions that are uploaded to any Squeak package will automatically be forwarded to the list for further discussion. There are three package repositories (hosted on https://source.squeak.org/):
The Trunk repository contains the latest integrated patches. (Only core developers have write access.)
The Inbox repository is the place for all new suggestions and requests for review. Everyone can upload proposals here without the need to create an account. (You can still create an account on https://source.squeak.org/ and edit the repository info of the inbox repository in the Monticello Browser to add your credentials.)
The Treated Inbox repository is for versions that have been dealt with or that have been superseded; it provides some useful history.
The usual workflow for a new contribution is to upload it to the inbox, where others will discuss and review it on squeak-dev, and from where it usually will be merged into the Trunk eventually. Here you can learn more about our development process: https://squeak.org/development_process/.
Making Your First Contribution
Install the latest Trunk updates.
Make your change, preferably starting from a clean image (to avoid configuration drift).
Open the Monticello Browser:
On the left, select the package you have changed (changed packages are marked with an *asterisk).
On the right, select the inbox repository.
On the top, press save.
On the left, select the package you have changed (changed packages are marked with an *asterisk).
On the right, select the inbox repository.
On the top, press save.
Review your changes, enter a meaningful version message that explains what the changes are for (e.g., which bug they address, what they are aimed at improving), and accept the new version to upload it.
That’s it! Your contribution has arrived in the Inbox and soon you will receive feedback from the community through the mailing list. Keep an eye on your mailbox!
Squeak Inbox Talk
Squeak Inbox Talk is an optional tool that attempts to simplify the development process by bringing together all the different artifacts that belong to the development process – mailing list, archives, and Monticello versions – and allowing you to interact with them directly from your image. You can access it from the Tools menu or install it by evaluating Installer installSqueakInboxTalk in a Workspace window.
Change sets: Usually, new proposals are best submitted to the inbox as a new package version. However, when some ideas consist of changes to multiple packages, it becomes tricky to work with multiple versions from the inbox. In this case, a change set is a good alternative. Change sets are collections of methods and class definitions, plus some extras. You can open a dual change sorter from the Tools and Changes menus in the docking bar and open a menu on the change set list on the left. Create a new change set and copy or move all relevant changes to it. Add a preamble to the change set to add an explaining message and finally file out or mail to list it directly. To install a change set, you can file in it from the file list, or you can drag and drop it into Squeak from the outside.
Preambles and postscripts: Some changes make it necessary to run some scripts before or after loading the new code to perform any migrations or changes to the global object graph. This is possible through preambles and postscripts. To add or edit a script for a Monticello package, select it in the Monticello browser and press the Scripts button. Add your logic to the code, test it, save it, and include it in your next inbox version. Note that preambles and postscripts in Trunk packages are required to be idempotent and may be evaluated multiple times. For change sets, you can add a preamble and a postscript as well from the context menu of the change set list in the change sorter.
If you identify any other contribution-related concepts that should be mentioned or explained in greater detail, please feel free to add them to the Contributing to Squeak help documentation. It could even be your first contribution!
Thanks to Christoph Thiede for contributing this excellent documentation! You can find it within the Squeak Help menu (Help->Contributing to Squeak) in the latest alpha version of Squeak. This documentation is especially valuable in this context, as it includes helpful links that execute useful code and actions, further simplifying the process.
Have a great time with Smalltalk and keep Squeaking!
Tim Rowledge, a dedicated community member and long-time contributor, has uncovered a fantastic resource for tech enthusiasts: a comprehensive archive of BYTE magazine issues hosted on World Radio History. This well-organized collection spans from 1975 to 1994 and offers a detailed look at the technological advancements of the time, including the early development of Smalltalk. You can explore the archive here.
Among the highlights is the August 1981 edition, famous for featuring the iconic Smalltalk balloon on its cover. This issue is notable for introducing Smalltalk’s unofficial logo. Curious about the significance of the hot air balloon and what it represents? Delve into this intriguing piece of history on the Squeak wiki. You can access the 1981 edition here.
Also of interest is the August 1991 issue, which includes the article “Smalltalk: 10 Years of Objects.” This piece provides a retrospective and a forward-looking view on Smalltalk, reflecting on its progress since the 1981 feature. You can view this edition here.
World Radio History’s BYTE magazine archive is a valuable tool for anyone interested in the history of computing and programming languages, offering both a broad overview and specific insights into the technology of the past.
Additionally, Tim also found some other nice historical videos presented by Capt. Grace Hooper at NSA in 1982 on “Future Possibilities: Data, Hardware, Software, and People.” You may find some fascinating bits of history from her lectures. You can view part 1 here and part 2 here.
The BYTE archive, along with these historical videos, offers a unique perspective on how early technologies and visionary ideas have shaped modern computing. Together, they provide an invaluable window into the technological advancements and influential figures that have defined the computing landscape.
ChatGPT, embedding search, and retrieval-augmented generation for Squeak/Smalltalk. The package aims to make semantic context accessible in Squeak/Smalltalk by providing the following features:
OpenAI API client: Currently supports chat completions and embeddings. Includes tools for managing rate limits, tracking expenses, and estimating prices for queries.
SemanticConversation: Framework for conversational agents like ChatGPT.
ChatGPT: Conversational GUI for Squeak. Supports streaming responses, editing conversations, and defining system messages.
SemanticCorpus: Framework for semantic search, similarity search, and retrieval-augmented generation (RAG, aka “chat with your data”) through the power of text embeddings. Implements a simple yet functional vector database.
Experimental tools such as an integration of semantic search and RAG into Squeak’s Help Browser or Squeak’s mailing list.
March 2024 Release 1.2.0 adds FFI and MIDI plugins, JIT for Sista bytecodes, JPEG write prim, fixes keyboard input, copy/paste, scroll wheel, highdpi, allows ES6 in source.
SqueakJS executes Squeak in a web page. It is a fully capable virtual machine implemented in pure JavaScript running unmodified Smalltalk images. Check it out at https://squeak.js.org/.
Early Registration Fee: 600€ (all days) / 200€ (per day)
Late Registration Fee: 1000€ (all days) / 300€ (per day)
Extra person to social dinner: 70€
Payment by bank transfer: free of charge
Payment by credit card: +6% fees
For late registrations we cannot ensure the availability of T-Shirts nor Social Event extra participants
: If the refund is requested during the early bird period all the fee (without charges) will be refunded. If it is requested after the early bird period is finished, the refund will be 50%
The Weekly Squeak 