I got curious, downloaded and installed it on my computer. Checked the docs, and the next step was to download a stable image. Downloaded 11 (stable) and started it. Then blank stare to screen! What should I do? Lots of things to click on, and no text editor..
Searched for a tutorial on the website, and found nothing! I don't want to spend 30 minutes to look at some random videos of Virtual Reality in Thames or whatever, or read "Pharo for Rubyists" (I use mostly Python). I just wanted to explore a bit, and maybe if it seemed interesting, tomorrow I would continue exploring it. But now I've deleted Pharo!
Warning to other project maintainers: just show a tutorial, or an hands-on doc, so that newcomers may get a feeling of what it is. This is especially important for relatively unknown projects like this.
Some projects that have done it right:
- https://www.djangoproject.com/start/
- https://go.dev/ (Search for Try Go in the main page)
- https://www.python.org/ (Carrousel showing some aspects of the language)
- https://play.rust-lang.org/?version=stable&mode=debug&edition=2021
- others I can't remember now..
The Pharo Launcher has an in IDE tutorial window that opens when you first open the image . Apart from links to documents it also contains an interactive in-development environment teaching you the basics.
One of the images is the Pharo MOOC. The website has links to several documents to get you started.
No offense but you kind of have to look around it to not find the ways in which the Pharo team attemps to get you underway.
Most people have Expectations about the way things work - code in a text editor, write tests, run them. Check code into Github. Go to a website to find documentation.
Pharo defies all of those conventions (well, maybe not Github, but even that is unusual). People just aren't accustomed to in-IDE tutorials. It doesn't even occur to people that such things might exist.
It's hard to notice that which you never even imagined possible.
One of the most frequent criticisms of Smalltalk is that it doesn't play well with others. It's an IDE, but it's also a runtime, and, in a sense, a whole OS, with its own programs and development tools, in a virtual machine (running on your computer or, in ancient times, on bare metal).
It IS alien to those who come from text editors and IDEs.
OTOH, it makes our usual development environments look crude in comparison. In fact, Smalltalk 80 still has that effect.
You can always check out Lisp and its ecosystem. It too doesn't "play well with others", but in modern times, it positioned itself half-way between Smalltalk and mainstream stuff - it still makes our usual practice look crude in comparison, but it lost a lot of magic that come from fully embracing in-image living. The barrier to entry for outsiders is much lower though, and you can use git with it in a straightforward fashion - not in... whatever it is that Pharo does.
> People just aren't accustomed to in-IDE tutorials. It doesn't even occur to people that such things might exist.
Well, yeah. But it opens when you open an image for the first time. It's right there in plain view. The first thing you see on the website are "discover" "download" and "learn" buttons. It's all these in plain view; it's not hidden away.
This was not my experience. In fact, on my windows box the latest Pharo Launcher fails nearly silently when trying to launch both the MOOC image and the Pharo 11 base image. When attempting to launch an image, A piece of toast (to borrow an androidism) would show up in the bottom left saying "Launch, Ctrl+L" for roughly 1 second, fade away, and then nothing would happen.
I had to switch to my Mac to get it to properly launch. The Pharo onboarding experience needs work.
In my experience if you think you've made something clear but people still don't see it, it's because you didn't really make it clear. There's no use blaming users for not looking hard enough even if you think it is really obvious.
Because Pharo is an environment and tool designed and built by those who want to build Pharo.
While there are certainly folks doing other things in it, the Pharo project focuses on the problems of improving the Pharo project to make it easier to develop Pharo.
As with many OSS projects, the developers are there to scratch their itches, which is Pharo, not just random programming projects.
You'd like to think that these goals, improving the development experience, would be generic enough to "lift all boats". I mean, they do solve a lot of issues with Smalltalk distributed development, distribution, source code control, etc. But, to be honest, those are all advanced cases and, while part of the development experience, don't do much to attract developers who are doing distribute "IDE" development.
I've tried several times to work with Pharo as a tool for random GUI apps, and found the experience quite frustrating. But, clearly, the Pharo developers continue to make progress, its just that whatever their destination is, it's not congruent with mine, so I dabble and leave.
If you want a more friendly approach to Smalltalk (which, you'll note, Pharo does not claim to be -- there's no mention of Smalltalk on their front page), then take a look at Squeak.
squeak is very similar to pharo (which is based on squeak) but pharo is a lot more user-friendly and looks nicer. they are both smalltalks - i agree that pharo trying to pretend otherwise is a bit strange.
Or similar to Perl => Raku. The Pharo developers took a wise decision renaming it. Because if you keep the same name, people expect nothing short of total backward compatibility with whatever there was before. If one wants to keep the option to experiment and eventually break backward compatibility, it's better to rename it.
I had no prior experience running Pharo. I wanted to see what all this was about, so I downloaded and ran the launcher (the windows one, since that's what I'd expect most people to be using). It starts with no images. Does Launch work anyway? No. How about New? That lets me select pharo versions. What happens if I pick regular pharo 11? It looks like it's downloading. What happens if I Launch that? Success.
Once the image is run, a "welcome" window appears (which you can get back to, if you already closed it, through the Help menu). The first two panes are a brief description and theme setting. The third pane is how to learn pharo, which lists a few resources and then tells me I can learn Pharo by clicking on the ProStef link. I do.
ProStef tells me to highlight the text below and right click and select "do it". It takes me a couple tries because I'm curious what happens if I select one word or the other. Learned: the entire expression has to be highlighted before telling Pharo to run it works, and both words were part of the expression.
The tutorial proceeds fairly obviously from there, teaching print and inspect. Some additional experimentation reveals that selecting the entire page runs everything, kind of like you might be used to in an IDE that sends things to a repl, and double clicking before the first character on a line selects the whole line.
If you're expecting the sort of tutorial where a guide not only tells you what to do, but shows you what to do before you do it to avoid any ambiguity, so that all you have to do is mimic it, ProfStef isn't that, but mimicry is a weaker form of learning. I'm not sure I'll like Pharo, but the tutorial looks like it starts okay to me. The launcher takes a moment to figure out, but if it's so difficult how do you get anything done that you've never done before?
I would not try to compare pharo with the usual mainstream ways. It's a different world. There's a very very good mooc to explain various aspects of both language and environment/culture. It's really worth a try (and I say that after hearing a lot of high praises about Smalltalk, I wasn't disappointed)
you see a welcome wizard when you open it.
it has pages, as the arrow show clearly (maybe this is not understood?)... and the 3rd page is literally a pointer to resources to learn pharo (including a small tutorial called ProfStef and an online MOOC).
pharo, like other smalltalks, doesn't really have much of a text editor - that's not how you write smalltalk code. instead, you use the browser, which has a text pane, to change/add things to classes (or indeed to objects). you have to think a bit different. and how do you expect to learn anything if you won't read or watch a tutorial?
> how do you expect to learn anything if you won't read or watch a tutorial?
I wanted to follow a tutorial (or another guide) to learn about Pharo, but couldn't find any, at least in the official docs. That's the point I'm making!
Smalltalk in general is about a fully integrated environment, so everything lives inside of the environment, including applications, docs and also the tutorial.
Once you launched the Launcher, you create a image (latest stable, official distribution), launch the image, press the "Next" button until you see "You can learn Pharo by clicking on the following expression:" which launches the tutorial. That's about it.
And I did that the first time just now, without having any experience doing so in the past, or knowing 100% where to go. Everything was easily guessable. But I did know since before what a Smalltalk environment usually looks like, even though I haven't used Pharo specifically before for this.
That is a fair criticism! It is partially (maybe 20%) mitigated by the fact that this is a different lineage of computing and so you were going to hit a huge wall somewhere and when you got it here you reached out to the community and found folks like me to help you. But 80% of the point definitely still stands, this is a big change and there is not much documentation for you.
In this lineage of computing, you do not edit text files and then run a compiler and then run your tests and then cross your fingers and ship to prod. That is, if you like, the “Frankenstein” approach, you cobble together dead body parts into a chunk of dead code and then reanimate it with a lightning bolt. And it has eaten the world so uh can't really bash it.
But another lineage is preserved in spreadsheets and smalltalks, where that general outlook is considered a little barbaric and you want to instead be surrounded by your living, breathing program, with everything available to inspect and tinker with and test and replace. You run the image and you are launched into your running program. Yeah it doesn't do anything yet, because you haven't told it what to do... but here you are, ready to mold and model the compute like clay into whatever your imagination desires. The first few pots you throw, you're lucky if they don't collapse on you.
My standard example of the mentality difference is Object.become. Imagine I tell the standard Java developer, “we search through all of memory, find all private and public variables pointing to that object, and instead point them to this object...” They will look at you like you are nuts! But that’s essentially the underlying functionality needed for “you can edit the method and the entire system will start using your new method.”
So things like versioning and inspecting and editing are generally baked into the image rather than external tools because you want to be able to debug and undo your changes in vivo ... There is going to be an impedance mismatch, and the community can certainly make it easier on you for sure but there is going to be a lot of unlearning no matter what.
Extreme TDD is amazing - you write a test, run it, and when it fails you basically fill in the chunk of code right from the error window and continue. It's not always super obvious how to get into the flow, but I found that although I didn't feel productive enough with the Pharo ecosystem, I _really_ miss the smalltalky development flow which foregoes using text files to organize code.
The primary way of editing code in Pharo, Squeak, and similar implementations derived from Smalltalk-80 (but not all, some use the more familiar idiom of "many files in many directories") is to use one of the built-in (to the Smalltalk environment) browsers.
Select the package, class, and then method (or the options to create new ones) and the method will be in an editor pane for you. Start changing it, and the change is immediately applied once saved. No need to rebuild the world and restart the image. (Of course, that leads to some fun things where you can redefine True/False and break the image right there on the spot. Pharo seems to do a good job of blocking you from changing things like that so easily.)
Smalltalk code "lives" in a database. You interact with that database. The code is also serialized to a file if you happen to want more conventional access, but that's not the normal route. Though serialization to files is how Pharo and others allow you to interact with git and collaborate with other people.
Why does this seem so common in niche projects like this one?
I often see GitHub repos that seem very interesting and even quite liked but as a newcomer you're just supposed to figure everything out blindly by yourself.
P.S: Thanks for saving me the time to download and try out Pharo.
Because lots of software released as FOSS is not made to attract people to start using it without spending at least some time reading and understanding it.
Lots of FOSS is written that way, especially corporate PR FOSS, where engagement and other things are important, because otherwise the cost/value calculation doesn't work out yadda yadda.
But lots of other FOSS is released just because someone wrote something, and then just put it out for others to use, if they're curious. They don't owe you anything, and spending time working on the onboarding UX, tutorials or guides might detract from what they wanted to do: entertain themselves solving a problem they care about.
why should people spend their time trying to convince you of the value of their project? they already know if it's valuable; why should they be interested in your opinion?
if it's a commercial product, they might get your money, but most projects on github aren't
why would they want to keep it to themselves? maybe if it contains trade secrets or defamation or copyright infringement? but probably most code doesn't
i don't want other people to use my open source code unless it's more useful to them than the alternatives, and i think they're a better judge of that than i am; trying to convince them to use it would imply i think i'm a better judge of it than they are
i'm always happy to talk with them about it, but i'm not coming from an advocacy perspective, and i think people who are are bad
I'd just think if you write something like a programming language of all things you'd want others to use it and have a pleasant experience getting started.
> I'd just think if you write something like a programming language of all things you'd want others to use it and have a pleasant experience getting started.
You might be surprised how many different nuances exist in what motivates humans.
I have even avoided to share code in public repositories, because I didn’t want to be bothered by feedback like yours, because I didn’t bring the documentation up to a level that someone farther away from my little niche need and use case can understand it.
While such feedback isn’t going to kill me, it’s nonetheless one of a million tiny little cuts that my life is more pleasant without.
Yes, it should be called "Onboarding UX" and nowadays , it it fails, make someone forget completely about that piece of software until there is another emotional event such as browsing it in HN and have feedback from a friend.
I like the LearnXinYminutes series to get the hang of a new language. It's sussinct and usually covers the main aspects of the language -- at least sufficient for you to decide if it's interesting enough to spend more time on...
Yeah I did the same the other night - same experience. It’s like releasing a modern game and expecting players to read the manual to learn how to play. We know how to effectively teach users to use - there’s an entire field of study devoted to usability and accessibility.
I don’t have time to waste on something that ignores the last 40 years of progress in that realm.
What's to say they have "something" to waste on making a foolproof way of getting started for people who aren't even curious?
They're not selling a product here, they're releasing software they've written in their own spare time. If you can't spare 30 minutes for running through the tutorial, why should they spend more time catering to you rather than spending it on more interesting problems?
Sure - but it's also being touted as something special that's worth paying attention to for programmers.
Like - when I first learned about Smalltalk, and looked at the syntax, I wanted to try it out right away! Playing with that realm of object oriented programming looks like fun!
But jumping through hoops to make it work is not fun - the process of just setting things up and trying to pick through the whole alien interface completely evaporated my enthusiasm. It quickly became clear to me that you can't 'just sit down and write code' the way you can with basically any other modern language I've worked with. You have to do a bunch of other stuff first. And I don't want to do that.
You can open a web browser, hit F12, and immediately start writing javascript and running it. You can use notepad to make an .htm file, drag it into the browser, and boom it's a web page. If you're on a device that makes task switching awkward, you can navigate straight to codepen.io, no sweat. You know what I mean? Immediacy is an essential quality, for me - obscurity, esotericism, inaccessibility and poor usability are all banes of my existence.
It's like sure, I can do anything I put my mind to - I can spend the next hour, the next day, the next week, month, year, decade, learning to do this thing... but that's time I'll never get back, and that's time I could be spending more efficiently stepping into something else, equally exciting and different and new and interesting, with significantly less barrier to entry.
If you care about your work, and your goal is to expose others to it, then you need to put the work into making it accessible. That's been my experience.
> why should they spend more time catering to you rather than spending it on more interesting problems?
Of course, if you're content with your community stagnating and nobody ever using that software, then there's really no reason to put that effort in.
I remember similar arguments about Linux installers. Why should they cater to people who don't even know fdisk? We have kernel to work on, UX of an installer - with obvious, immediate impact on adoption and getting new users - is boring in comparison. Having installed Fedora last week I can attest that this line of thinking, fortunately, went away in Linux as far as installers go. The chances of it going away in the Pharo community, however, are slim at best.
I do sympathize with your experience. It reminds me that one of the frustations when experienced programmers encountered Smalltalk back-in-the-day was often expressed as — Where's the program?
Maybe you wanted to step through like this (and then go explore by yourself):
I'm just learning about it myself but much of what's attractive about Pharo appears to be the IDE rather than the language, so code snippets don't do it justice.
Well, they're consistent at least. It was exactly the same when I first tried Pharo, at version 2.something IIRC. Same in Pharo 5, 7, 9 (increments of 2 purely coincidental) and now with 11.
I love Smalltalk. The language is great, incredibly powerful even though it rests on just a few simple concepts. The design and architecture of some of Smalltalk libraries is marvelous and should be made into UNESCO world heritage site for OOP design. PetitParser is unmatched in the ease of creating and extending parsers, not even PyParsing comes close (Raku grammars are close but use another metaphor for actions, ScalaParsing is... somewhat related but limited). The idea of finally working with a live codebase instead of its dead carcass[1] is frankly groundbreaking - and older than me, apparently. The Smalltalk debugger is a work of art, and the idea of working with images that contain the "whole world" in them is actually very appealing if you ever had to write a Dockerfile.
However, while Pharo may well be the most "advanced" Smalltalk(-like) environment, it's also one of the worst. On my Linux machine releases after 5 refused to as much as display anything - I got an empty window and the VM seemed to hang and never started properly. Glamorous Toolkit version did work, even though they share most of Pharo code. The churn in UI toolkits, the constant rewrites of everything, the utter lack of any kind of documentation (including on classes!) of installable packages, deprecation of tools that work (ofc after breaking them) in favor of tools that don't, yet leaving the former in place just to confuse users (b/c what other goal could it have?) - that's Pharo in a nutshell.
A few years ago I went to complain about the lack of backward compatibility and the fact that a tool, Package Manager, that used to work perfectly well, stopped working altogether. I learned that nobody under the Heavens cares more about backward compatibility than Pharo community (praphrasing: "look, we're even developing all-new annotation/pragma based system for marking and automatically fixing incompatibilities!") and that nobody uses the package manager anyway because they use... something else, I forgot, but anyway - the new thing was nowhere in the menus, while package manager stayed in the same place it was before. I gave up when I got no response after asking "how the heck should I, the user, know about deprecation of a tool if it's not indicated anin any way in the UI". What I got instead of an answer was a bunch of name calling and the usual suggestion for me to go and fix it myself.
I still love Smalltalk. If you love it too, but feel that - at least with Pharo - that feeling is not mutual, go grab Visual Works (no affiliation). Personal license is restrictive, and the version you get is 6 years old at this point. But. It comes with thousands of pages of PDFs with up to date documentation, manuals and guides. It comes with a stable, battle-tested UI framework, not based on Morphic but integrating seamlessly with your env windows (btw: "Pharo can do it too", say Pharo users, "it's just that nobody cares about such things") while still allowing all the dynamic introspection Smalltalk is known for. The infra for versioning and sharing code is idiosyncratic - you need to spin a local Postgres instance - but solid and surprisingly (if you come from git) powerful. There's a working package manager and you can install and run code from the nineties, something that's just absurd to attempt in Pharo, despite all the "caring" about backward compatibility. Yes, the VM is closed source, but it at least starts up properly.
It's a bit underwhelming in the performance dept, which made me reconsider starting one project with it, but by that point I already built my own little Smalltalk environment after fixing a lot of glitches (because, other than the VM, the source of everything else is available and you can modify it as easily as any other code) and I honestly felt really comfortable in it. It's incredibly similar to Emacs in terms of power and workflow, but with proper widgets and no need to worry about terminal users.
I also tried using GNU Smalltalk for a project, but that's basically dead at this point, with a lot of things unfinished. I still managed to build quite nice shell PoC in it. I also tried Smalltalk/X-jv, and it was kind of ok, but VW looked more polished and I didn't need the other langs integrations that Smalltalk/X does, so I stayed with VW. Cuis is also a nice attempt, but I wanted to break out of Morphic, so I didn't investigate it too deeply.
TLDR: Smalltalk is not just Pharo, there are Smalltalks that are not like Pharo, that don't treat users like unneeded baggage, that take integration with modern GUIs seriously, that have a lot of advanced tooling that's actually useful and needed. Oh, and also, there are Smalltalks that are not actively hostile to keyboard shortcuts! Give one of them a chance, you'll be surprised!
GP says it didn't work for them as did the GGP, why would you suggest that this is 'close to misrepresentation' when it is simply two datapoints that may be different from the experiences of others (for instance yourself).
Yeah. It indeed works. With --headless. It's "just" incapable of displaying GUI.
I use Fedora. I ran every other available Smalltalk implementation on it, including Visual Age. GToolkit distribution, too, worked without problems. Pharo didn't, and still doesn't. I know that wanting this to be fixed is lazy of me and shows incredible entitlement, so I stopped - but please don't tell me I misrepresent something.
and then hangs. I suspect I should tell it to quit, but since I don't have the GUI, I can't easily check what method I should call to do that. Ctrl+C works though.
So, yes, without loading the GUI the VM and image seem to work.
BTW, Smalltalk/X has a fully functional REPL, including console based Inspector and debugger. Imagine what would happen if you suggested providing such functionality in Pharo... ("only masochists can bear working with terminal", the "incredible" community says)
In Pharo Launcher, go to "VMs" and try to delete the VM. Pharo should work on Windows just fine. If not, please, report it on the issue tracker with more details.
> BTW, Smalltalk/X has a fully functional REPL, including console based Inspector and debugger. Imagine what would happen if you suggested providing such functionality in Pharo... ("only masochists can bear working with terminal", the "incredible" community says)
You should not generalize in this way. Some people are working on the TUI Spec backend to allow all the tools to run from the console, and I don't know anyone who doesn't realize the importance of keyboard control.
Wait, what? We're talking about Linux. Pharo Launcher also, obviously, doesn't display anything, so how could I do anything there?
> report it on the issue tracker with more details.
No.
> You should not generalize in this way.
Sorry, that was too much, you're right. While it is an exact quote from a member of the community, of course it doesn't mean everyone there is that bad.
Good to know that some people have a bit of a common sense. Congrats.
I mean... it executed code that was supposed to print "Hello world\n" and it did print that, so how is it not working? :) I have no idea why is libgit needed to boot a VM (is it even?), but evidently some functionality is still available despite the error. Not that it changes much...
When all the required dependencies are being found on your Fedora install we should wonder why "the VM seemed to hang and never started properly" but not before.
Yeah, sure. But why would I put effort into providing the dependencies to Pharo on silver platter? I engaged here just to show that it, indeed, doesn't work for me and I'm not misrepresenting anything. Now, it even looks like a well known (yet still not fixed) problem, so I have no further need to do anything.
And no, LD_PRELOAD is not something I should be using, or at least, I didn't need to use it with any other Smalltalk, nor any other program I tried to run in a the past decade. I did have to use it once, with Baldurs Gate 2 (Linux/steam version) and that's about it.
There seem to be 4 different install methods shown on the Pharo download page. Seems like you used "Pharo Launcher"?
There are also "GNU/Linux Packages" and in particular rpm for Fedora 37, Fedora 36, Fedora 35, Fedora 34. I wonder if you tried them?
On the few occasions that I've needed Pharo, I simply downloaded the "Pharo stable VM for Linux" and "Pharo image" separately and unpacked them into the same directory. Maybe it helped to already have a working git install.
If you have an image with Seaside project (they should work in headless mode) or something similar laying around I can try running it, I suspect it'd work.
Because the project competes for attention with a million other OSS projects out there and lowering the barrier to entry for newcomers is good practice for projects that want to stay alive.
I certainly agree that it would be a good thing to do for their own sake, but also at the same there is an amount of effort required. If someone is so lazy and has such a low attention span that they can't even be bothered to find the tutorial before deleting it, were they really going to stick with it anyway? It seems like such a low bar. I honestly think people are just spoilt by these modern FOSS projects with insanely good documentation. You just can't expect that everywhere
Also, frankly, Pharo has its niche. It isn't really competing for attention in the same way as others, since it is the "goto big Smalltalk"
No need to, but the project should be honest about it: "this is not for lazy people! You'll spend a weekend just trying to boot the VM, and once you're done the hard part starts right there! So, go away, you unwanted user, you."
Put something like that on the front page and you're good to go.
Authors of open source projects don’t owe you anything. If you want something changed, do it yourself, or ask them. You could even go so far as to offer to pay them. If you aren’t up for any of that, well… not sure what to tell you!
> If you want something changed, do it yourself, or ask them.
I did ask. See my other comment[1]. The only thing I got out of asking was name calling, dismissive and rude remarks, and the immortal "do it yourself". Before the package manager thing, I did the same - years earlier - asking on the mailing list how to bind keys to commands. What I got out of this was name calling, dismissive and rude remarks, and the immortal "learn to use the mouse already!"
Sure, nobody owes anything to anybody, not even not being toxic and abrasive. But I also don't owe the toxic and abrasive community anything - certainly not avoiding criticizing it. Right?
Oh, and I'm certainly NOT going to offer money to people who swear at me. Yeah, it's not a product, not developed by a company, all true - but I still refuse to be called an idiot and keep quiet about it.
So, to be clear, you are saying that it is indecent that there isn't a notice on their page saying "this project is not for lazy people. Please go away if you are too lazy to find the tutorial"? I really don't think that is more decent
Well, I do. As it is right now, the front page is misleading. They say there that Pharo is made by "an incredible community" (oh, the humility!). Someone might read it and think that there's a helpful, friendly community that they could (politely) ask for support without fear of being called "entitled" and without a barrage of "you just don't understand how glorious our way of doing things is!" following. Well, they would be wrong.
As in the reply to a sibling comment, yeah, nobody owes anything to anybody. But, you know, we do things we don't owe to anybody every day. I don't owe my neighbor saying "hi" when I meet them, but I still do. I don't owe my guests anything, but I still offer them a seat. Pharo community tries to do it both ways: they appear to want new users, but when you come closer you'll see what they actually want is new fanatics. Screw that. They don't owe me anything, but neither do I owe them keeping quiet about what I've been through.
Smalltalk is beautiful. And, Smalltalk is not just Pharo. There are other communities, and there are much better Smalltalks out there. Cincom (no affiliation) Visual Works is so much better an implementation that it's scary. Pharo could be like that, if only the "incredible community" stopped killing all semblance of stability with constant rewrites of everything, stopped treating users like unwanted baggage, stopped insulting people whose use cases don't completely fit the community's idea of what's good and bad.
Pharo community is a museum that preserved the culture of Smug Lisp Weenies intact. Good for them. Meanwhile, Pharo being advertised as "the most actively developed and most advanced Smalltalk" - which means that it's first, and very often last Smalltalk tried out by people - hurts the wider community and hurts Smalltalk adoption. They don't care. Is this a decent behavior? I think it's irresponsible, at the very least.
Look, I spent 5 years trying to work with Pharo. Not a few minutes. Yeah, I don't care about Pharo anymore. At all. That's because of what I've been through with it and its community. So please stop telling me I'm lazy, entitled, or that I "don't care after a few minutes". I've been giving Pharo chances for years - it just never got any better.
I'm mentioning Cincom (no affiliation) Visual Works over and over again. If you read it carefully, you'd see that I'm not entirely OK with the restrictive personal license, the lack of any cryptography-related stuff (incl. HTTPS), and the closed source VM. I'd prefer a Smalltalk without these restrictions. I still use VW and not Pharo - because the gap in quality of the software is so incredibly wide that it dwarfs other considerations. VW looks like it's made by professionals (well paid at that). Pharo looks anything but, yet (politely, out of concern and genuine interest) pointing it out gets you hate and verbal violence from the community.
I want an open source Smalltalk implementation. I want more people to like Smalltalk. I want more people to use Smalltalk. Pharo could be helpful with these, but it's not. Instead of a gateway into Smalltalk ecosystem, Pharo is an impenetrable wall to new users. And the community doesn't care. There are some people that do care. See Glamorous Toolkit. See Cuis.
I wrote a few small pet projects in Pharo, back in 2012. They kept getting broken release after release. And at some point, the default download with official releases stopped working altogether. And never worked again. There's a ticket from 2021 (created years after it stopped working for me) describing the problem: https://github.com/pharo-project/pharo/issues/9729 This is a regression brought about due to another rewrite of something. Still not fixed. You know, I could fix myself and contribute the fix - I have the skills and could potentially find the time. But Pharo and its community burned so many bridges for me that this is not going to happen.
Call me petty all you want, but the kinds of people running Pharo are just not worth being helped.
Please don't perpetuate flamewars on HN, regardless of how bad other comments are or you feel they are. Please make your substantive points without swipes and attacks, no matter how bad a programming community is or you feel it is.
Please review the rules and stick to them from now on.
p.s. I appreciate your love for Smalltalk but if you express it using swipes and attacks, you're actually discrediting it to less knowledgeable readers (i.e. most of us). It's not in your interest to turn people off of something you love, so you should follow the rules out of self-interest too.
I didn't, but isn't this for educational use only (I'm guessing, I can't access the archive of the list)? Cincom seems to offer separate license for students and teachers, I'm unfortunately unaffiliated with any educational institution :(
But I did try to get commercial license, once. I had a project and a client for it, and a seemingly ideal use case. However, I wasn't able to sell the client the kind of licensing scheme Cincom wanted (they weren't unreasonable, just not what the client was willing to have). I ultimately abandoned the idea. Still, even knowing that I'm just a solo developer that's not going to earn them much, my contact with an account from Cincom was very pleasant and helpful. I saw the changelog for the next version of VW - there was a lot of really nice stuff there! Welcome fixes, improvements in many important packages, new functionalities - the product is evidently alive and getting better, but there was one thing missing. There were No. Breaking. Changes. I could reasonably expect my app to work if I built with 8.x version and later upgraded to 9.x. Can you imagine this?
Cincom is, of course, a company targeting big corporations - a for-profit organization, and the most important part of VW is closed source. If Cincom dies, VW will probably also die, along with my projects. It's a risk, and it's not ideal. The fact that the PUL version is 6 years old at this point also isn't nice. And, above all, I don't wear suits and neckties. So, I'd really prefer fully open source Smalltalk (the only reasonable alternative, Smalltalk/X, also has the compiler distributed only as a binary blob) Unfortunately, Pharo simply cannot be that Smalltalk for me.
To the dead sibling commenter: sure, I don't event want anybody to care. I'm writing all this for my own satisfaction, so please, just do your job of not caring properly and ignore it all.
I'm not going to ban you right now because I didn't see other cases of this in your recent history, but please fix this going forward so we don't have to.
I used Pharo in my Object Oriented course at the Univeristy (for my CS degree) and I was really surprised for this paradigm. We saw Haskell and Pharo and I was really happy to discover new things from a language point of view. It is hard to say that Java or any other imperative language is OO after seeing Smalltalk/Pharo.
About the question if it's used in production, the teacher for that segment of the course was a specialist who worked on big companies and showed us examples of being used and we were (again) blown away.
I never fully understood it (although I passed that course), but it's one of the things I'd like to know it better: not for usage, but out of curiosity.
> It is hard to say that Java or any other imperative language is OO after seeing Smalltalk/Pharo.
This.
It so frustrates me to see people trash talk on "OOP" in HN and other forums, where I know people never really got to really realize what it could really be about. Just hacky approximations.
I'm sure that functional silver bullet will avoid this cycle some how. /s
Most people see .prototype and the end-all-be-all of Prototypal Inheritance and base everything they think they know about it, from how a frontend from the early 2000s was coded.
They work through some lisp book in school, have an exam and think that's all lisp development can give you.
Same for functional programming, where most "we love functional programming" companies just compose some small-ish functions in a chain and call it a day.
Everything that is initially niche, finds a good fit and becomes "mainstream" or even a bit popular, tends to be mushed into some other paradigm while getting there.
This is one of my biggest frustrations about online programming discussions. The vast majority of complaints about OOP I've seen online are really complaints about Java and C++, and many of the problems are simply not present in Common Lisp or Smalltalk.
Java shares a lot with Smalltalk though, even if on the surface it has a C++ like syntax, the semantics are closer Smalltalk/Objective-C.
Same applies to C#.
Sure Proxy classes aren't a replacement for #doesNotUnderstand:, the metaclasses are relatively poor when compared to Smalltalk metaclasses, and hot code reloading isn't the same as having a Smalltalk image, but that is about it.
Eclipse was born out of Visual Age for Smalltalk, and the experience isn't that much dissimilar when taking those differences into account.
C++ had two Smalltalk/CL like environments, Energize C++ and Visual Age for C++ v4, they failed to gain adoption due to hardware requirements.
C++ Builder offers a bit of what they did, but its price point means only big enterprises care about it.
Nowadays VC++ with hot reload, or Clion with Live++, are the closest that one can get to Energize/VA.
Not the OP but JP Morgan’s Kapital system which underpins their credit hybrids business was smalltalk.
I say was because i believe it’s been deco’d in the past few years but i don’t know for sure, when i worked at JP it was still a core breadwinning system.
I believe the core of Gemstone is smalltalk - it's an object database/runtime and supports java as well - they also sponsored/made maglev ruby (now dead?):
The congruence with the rest of the language. It makes it so that creating a new class isn't declarative, but also just another message sent to the ecosystem of objects.
No. This is easily the weakest part of Smalltalk IDEs. And with Morphic-based ones, you can't even fix it with a tiling window manager or something, since it's just one window for the rest of the OS. There's no way of organizing the windows in groups, no automatic placement, no virtual desktops. The best you can do is simply get into a habit of culling unnecessary windows. It's emotionally hard to close windows you spent 10 minutes searching in for the code you might (or might not) need in the future, so I made a simple sidebar[1] that I use to bookmark useful stuff. With it, I can close windows with impunity.
Depending on your workflow, you get used to it rather quickly imo.
I recently rewrote a Python script which extracted metadata from an XML file and using that metadata to stitch together fulltext from OCR (OCR where single pages,and the metadata held references to page numbers - whoever programmed that needs to be slapped).
So I worked fully in the Pharo environment, file browser to look and check, "code browser" to code and change etc.
The glory really was, the extraction took quite some time (a few hours, millions of files, python wasn't really faster), but after that, I had objects in the environment and code changes reflected, I saw a wrong extraction, I could correct and run it over this single text, which with the Py script was much more inconvenient. Yes, you could code it differently to do that, but with Pharo my code didn't need to account for that. Also "oh, I need to create a new metadate like year+month", code it and its there for every text, and if I decide to have it generated on the fly, I'm done if I need it as instance variable, I run this (and only this) method for all texts, which takes a second. And then into Elasticsearch for our other pipeline afterwards ;-)
Plus, close it (and save) and you when you reopen, you are exactly where you were, opened windows and all
Idunno, as a Rubyist, the bit on examples was kind of cool (awful syntax though!) but my IDE already offers to create stub classes for lots of stuff.
What I don't get is why this sort of thing needs to be in its own OS. Why can't it live in my OS of choice, so I can use it to interact with things I care about?
I wrote my Bachelor and Master thesis with it. I thought about working at HRWorks, but then decided to do Python and now TypeScript. I'm learning Rust now, just because how the closures look a bit similar to Smalltalk since I miss it so much.
Pharo looks like a blast from the past in a good way. It harkens back to the era when a lot of work was put into carefully designing language, IDE, and UI/UX environments cohesively with an eye toward using the computer to maximize human capability and productivity.
Then we dumped all that and abandoned it and moved to today's visually and ergonomically inconsistent hodge podge. It mostly happened because of the web but also because the velocity of the industry increased to the point that it felt like a waste of time to think deeply about anything. It'll just be obsolete next year. Slap it together, get it out the door, repeat.
I wonder if anyone has experience with this and Amber (https://amber-lang.net/) and can compare the two? The languages at least appear to be very similar, but the latter uses a web browser rather than a fully custom UI like Pharo has. I assume you can't just open a Pharo program in Amber (or the other way around)?
36 years ago a very young me took a programming class in 3rd grade where learned "Small Talk", which was going to be how everybody worked with computers in the future.
I still credit most of my skill at programming to the fact that I was introduced to that and Forth in elementary school. I also miss those C64s....
Wow my highschool didn't even offer programming classes. The closest thing to a computer education were some classes that required us take online tests to obtain Microsoft Office and/or Adobe Photoshop "certifications" before we could graduate.
I think I caught the tail end of that in the 90s. I remember taking a class from the local parks and recreation department where we programmed a little robot in (I think?) LOGO.
Good old RPT 4 FD 50 RT 90. It was only years later that I found out it's basically a full lisp system under the hood with the turtle graphics just a small DSL.
Both Cuis and Squeak (from which both Pharo and Cuis were forked) are still actively developed. Pharo does have the largest presence in the two major Smalltalk conferences (FAST in Argentina and ESUG in Europe) but there is no need to worry if one of the other options is more aligned with your needs.
I always feel like I should be doing more with Pharo. I love smalltalks and there's something really fun and playful about working with it, even those with a more "professional" shine on them like Pharo. I've been experimenting with Godot recently and I feel like there's a lot of that spirit in modern gamedev, where the tool is written in itself and gives you all of the same parts to play and build with.
I guess I don't really know what my usecase for Pharo is, like what niche is it filling? Maybe I need to build my next web...thing with it and see how it works out?
IMO it's a good tool for web scraping. The reason: you can do web scraping with Parasol (i.e. Selenium [1]) and then if you need visualization tools then you can immediately use Roassal [2]. The thing is: Pharo and the fact that it's more GUI-oriented than other programming languages, allows for data visualization a bit easier. Also: you don't need to know database specific. You can just store the data and save the image. Super useful for small web scraping projects.
Another use-case is: open-source software where you want to encourage users to just open up "the damn code engine" and hack straight into it, seeing it change on the fly. Like, can you just right click in Windows on a pixel and change the code that underlies it? In Pharo you can! Commercial parties would find this horrible, but it's amazing for full open-source software. Note: I don't think any other language is capable of this!
For web apps, B2B works quite well. B2C, I see scalability issues.
I find it useful for scripty things once you come to terms with not needing to write to stdout. Although there are ways to do that and call into the image from shebang scripts. Also, as long as you leave the image running you can setup cron like jobs in the image.
The reason I like it for this type of thing is that all you need resides in the image instead of shell scripts scattered hither and yawn. Also, the development for these types of things I find much easier because of the ability to inspect results of every step in the workspace/playground before stitching it all together in a class. I guess in that regard it’s a similar flow to Lisp.
Installing and running Pharo when new release has been introduced; however, yet, Pharo does not support HiDPI screen and disappointed.
Other than this, this project and other projects dependent on this, especially, http://agilevisualization.com/ is looking great to me. Once, I had used Squeak MVC for my company's internal projects (though it has been replaced with Common Lisp applications), and Smalltalk is very productive.
I've wanted to spend time on Pharo for over a year now but the blurriness gives me a headache. Occassionally I'll check back during a new release to see if they fixed the hidpi issue. Really surprised they haven't.
Many languages need constructors (and static methods) because the class is not an object.
In Smalltalk the class is the sole instance of another class (MetaClass), so a "static method" becomes a "class-side" method. And so it is inheritable.
Primitives (as in int, double, etc.) are a different subject, and although an Integer or a Smallinteger is a specially optimized object, it has the overhead of being an object (as in "Boxed" Integer in other languages), instead of some bytes at some memory location.
Most of the times you don't need the optimized version, and if were the case that you do, then it's when you optimize that piece of execution specifically (maybe making an external call to a more low-level, optimized version).
If they were about what user needs not about underlying hardware they'd be fine.
I dont care about int, long, float or double.
I care about number to represent whole amount, or fractional amount or approximate amount with operations that work accordingly lile approximate comparison of approximate numbers. Approximations for when I care about approximation error and for when I don't. Number that are limited to the ranges I care about not some arbitrary MAX_INT. Numbers that have units so that I won't accidently assigned a length to a variable that should hold mass.
So yeah, as they are primitive types do introduce unnecessary complexity and none useful complexity unless you want to work close to the metal.
Constructors are tools to put an object in a starting state, but there's alternative solutions; in Go, factory functions are pretty common.
Primitive types reminds me of Java, which doesn't have primitive types per se (everything is an object under water), but they're adding it soon (or already have) for performance reasons.
Java does have primitives/unboxed types (int, long, boolean, etc) what they’re adding is support for unboxed/value classes created by users. This should help reduce the duplication between int and Integer and so forth.
The primary challenge with Pharo is the complexity of using this in a multi-user type of environment where the image is shared between people. How does one do that?
I did commercial team Smalltalk development using the Digitalk toolset, for a team of around 16 people.
You start with a base development image, loaded with the toolset and frameworks for the project. No one modifies this image.
You share the app code through a source control tool. We used Team/V. Start up the project base image, open the repository browser, load the project packages. Make changes, commit source back to the repository. No saving of the image for development.
So shared, but never changed base image for the project, and app code sharing through the source control repository.
Pharo source management is based on Git, so the workflow is not special. We build the development images on the CI so every developer can download the already prepared image with the latest commits, but that is just for convenience.
Though there is the issue of: the changes in your image are not necessarily the changes in your local repository and the syncing of both can sometimes cause annoying issues. In most cases I've learned to work around it, but it wasn't plug and play straighforward.
I use it for my interactive-fiction backend and to host save files for another game.
Nothing fancy, just a web server getting file and saving them. Like a KV-storage.
I have deployed it to dogital ocean on 2017. I have not TOUCHED it since then. Still running good. And I can access the Pharo GUI via the web VNC just from my browser with full access to the IDE and dev env.
The cons: I forgot how to run that docker image. If it fails I am in troubles reminding myself how to run it one more time. 6 years have passed...
Awesome, I’ve been learning Docker lately and asked ChatGPT how to do this. It told me to run inspect and that there was not a way to get the command used to launch the container. Thanks for sharing.
> And I can access the Pharo GUI via the web VNC just from my browser with full access to the IDE and dev env.
That's a thing I read about elsewhere, and it sounds like it has or had an integrated VNC Server - is that true (meaning run it heqdless from cli via ssh and connect to it through that), or do you need an X and leave Pharo "opened"? Any pointers appreciated ;-)
You need to know more method signatures to write any program in it. For example things like: someCollection do: [ :someArgument | "some code" ]. Stuff like that. It's still a lot less than most languages though.
I found that this really helps [1] and I find it more representative of how difficult the language actually is. The postcard example is a bit contrived.
> From 2008 to 2015 ATMs deployed in Moscow streets were developed and run using Pharo. People use them to pay for services with cash and cards (phone, internet, taxes, parking, etc)."Pharo was a really enabling technology. We developed user interfaces using advanced flow control based on continuations and mixed prototype with class-based programming. We supported various kind of equipment and a...
I have not used Pharo yet, but I've used Cuis Smalltalk for a college class and it was one of the most fun experiences while writing code that I had since my first steps back when I was a kid. I'm pretty eager to learn more about Smalltalk and write something meaningful in it.
To anyone who has not yet tried it I suggest heavily that you do, even if it's just for the sake of having fun, it just can be a bit confusing at first since it's a pretty different environment.
I believe Pharo evolved from Squeak SmallTalk. I'm not sure if they started calling it a new language because of the number of extensions on top of SmallTalk-80 or if they introduced any breaking changes from SmallTalk-80, or if they just didn't want to be bound to strict conformance going forward.
It depends on how many objects you installed the ephemerons. We tested with hundreds of thousands of ephemerons and we saw performance problems. We instrumented the code to capture all object allocations of an application. But, if you use ephemerons with not so many objects, let's say a couple of houndreds max, you should not have any issue.
I love Pharo and have written about it on my blog, but one of the most frustrating things about it is how the documentation in the various books have fallen behind the language.
"In Pharo, you can easily replace an object with another one. All references to the old object in your running program will be replaced by references to the new object."
I wish having to debug this onto the person who downvoted my comment without adding to the discussion.
This is worse than singletons that - in all their glorious capacity to create tight coupling between unrelated parts of your application - are at least guaranteed to keep their identity after having been constructed and can thus provide some sort of sane exit path by keeping track of changes made to their state and informing observers.
The ability to change the identity of objects is not really used in normal code, so it is pointless to complain about it as bad practice.
But it may be handy during debugging sessions, and it is an essential feature that allows the system to evolve like a living system. It is used during class migration and so on. (It wasn't me who downvoted your comment)
Searched for a tutorial on the website, and found nothing! I don't want to spend 30 minutes to look at some random videos of Virtual Reality in Thames or whatever, or read "Pharo for Rubyists" (I use mostly Python). I just wanted to explore a bit, and maybe if it seemed interesting, tomorrow I would continue exploring it. But now I've deleted Pharo!
Warning to other project maintainers: just show a tutorial, or an hands-on doc, so that newcomers may get a feeling of what it is. This is especially important for relatively unknown projects like this.
Some projects that have done it right: