Pharo 11 | Hacker News Reader

Pharo 11

pharo.org

304 pointsxkriva11180 comments

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..

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.

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.

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.

P.S: Thanks for saving me the time to download and try out Pharo

Unnecessarily snarky

Not meant personally, but sure my apologies.

Same vibe.

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

I mean sure, I have nothing to say against that.

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.

Because they want other people to use it obviously. Why share it with the world at all if that's not the case?

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

Given the prominent "What is Pharo?" it seems that the developers are spending their time trying to convince others of Pharo's value.

And that worked "got curious, downloaded and installed it" but then hit a bug "Lots of things to click on, and no text editor".

We can see that they are trying to explore using the knowledge they already have, as we might expect.

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?

Serious question: Can you create medium-size to large applications without a text editor?

yes, pharo is basically written in pharo.

please note you _do_ have to type in code in text, but not monolithic amounts of it as you would in (say) a C++ program.

It's actually one of the best parts of it.

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.

it's not that it doesn't have a text editor; most smalltalk windows have five or six text editors

Oh boy, how does one keep their sanity like that?!

you use the windows to keep them organized, same as in any other gui

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.

> 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!

Did you download "Pharo Launcher" from https://pharo.org/download ?

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.

Think 'emacs' not 'C'. Smalltalk based systems are compete runtimes, a tutorial for Pharo is here:

https://ceronio.net/2017/07/first-steps-with-pharo-smalltalk...

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.

> My standard example

Ummm I daresay the vast majority of Smalltalk programmers never have (and never will) use become:

http://books.pharo.org/

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).

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.

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.

As-in meet people where they are.

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.

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?

> 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.

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.

Pharo by Example is a good book to start with.

Not really, it assumes smalltalk knowledge.

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.

Because in a similar vein to Dr. Scheme => Raket, Pharo has moved from its raw Smalltalk roots.

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 would not say moved, but rather expanded. the roots are still there in both.

Then take a look at Cuis-Smalltalk.

https://github.com/Cuis-Smalltalk/Learning-Cuis/blob/master/...

"Learn Pharo" is right there in the Welcome screen when you started it.

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)

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!

[1] https://blog.bracha.org/exemplarDemo/exemplar2021.html?snaps...

> On my Linux machine releases after 5 refused to as much as display anything

That seems close to misrepresentation, Pharo works OK.

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

Pharo 9.0.21 on quad-core 3.0GHz Intel® i5-3330® with 15.8 GiB of RAM and 2TB SATA disk drive; using Ubuntu™ 22.10 x86_64 GNU/Linux 5.19.0-29-generic

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).

jventura did not say Pharo didn't work. jventura said they didn't know what to do.

Quoting from your link:

    COMMAND LINE:
    /opt/src/pharo-vm-Linux-x86_64-stable/pharo --headless [...]

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.

Do those script files work with your Fedora Pharo install?

I'm not sure, I'd need to try. I'm also curious how this:

    (SystemWindow windowsIn: World
          satisfying: [:w | w model canDiscardEdits])
       do: [:w | w delete].

works in headless mode. I guess #windowsIn:satisfying: simply returns an empty array?

But, why do you ask?

Curious as to whether Pharo does work with --headless on your Fedora install. (I don't currently have an Ubuntu install to poke.)

It seems to work. I found Pharo 10 on disk, running it like this:

    -▶ ~/portless/pharolauncher/pharo-vm/pharo --headless Pharo10-SNAPSHOT-64bit-0618067.image a.st

with a.st:

    Object subclass: #BenchmarksGame
       instanceVariableNames: ''
       classVariableNames: ''
       poolDictionaries: ''
       category: ''!

    Transcript show: BenchmarksGame!

First signals an error:

    primitive #primLoadSymbol:module: in TFFIBackend failed

this seems to be related to libgit, as the stacktrace ends with:

    LGitLibrary(FFILibrary)>>ffiCall:
    LGitLibrary>>libgit2_init

but it continues running and displays:

    BenchmarksGame

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)

I wouldn't describe that as "seem to work".

What if a.st is

    Stdio stdout
        nextPutAll: 'Hello, world';
        nextPut: Character lf

Here: https://gist.github.com/piotrklibert/e953b7bf85821f88f02a3c2...

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.

From the gist that install doesn't work headless.

Seems like this:

https://github.com/pharo-project/pharo/issues/9729#issuecomm...

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...

https://github.com/pharo-project/pharo/issues/9729#issuecomm...

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.

Is it the missing `libpcre.so.3` `libpcreposix.so.3` ?

    ldd libgit2.1.0.0.so

No.

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.

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.

> Pharo should work on Windows

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 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):

https://cuis-smalltalk.github.io/TheCuisBook/Writing-your-fi...

https://cuis-smalltalk.github.io/TheCuisBook/A-brief-introdu...

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'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.

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...

https://learnxinyminutes.com/docs/smalltalk/

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.

I'd be interested in some of these industry use case stories if you could share something.

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?):

https://gemtalksystems.com/about/customers/

Most of them were financial industries, and a gov body in charge of tax processing and that stuff.

They have an extensive list at https://pharo.org/success/.

What book did you use?

I don't remember using a book for this part of the course.

> 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

I think that's true for most paradigms.

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.

Could you give a good example of functional programming that does not follow that method? I am very interested.

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.

As a rails developer - my introduction to Pharo started with this video:

https://youtu.be/HOuZyOKa91o

If you're not a ruby/rails developer you can still see how awesome it is, but for rubyists specifically it can really be quite mind blowing.

> ...There you go. Now you've seen a little bit of Smalltalk and now you hate your Ruby development environment. Have a nice day!

I switched from Ruby to Smalltalk in 2008 for this specific reason.

Do you actually work in smalltalk or is it just your hobby language of choice?

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.

I feel anxious looking at the multitude of windows. Do you get used to it?

it's not much more overpowering than other ides - just close anything you are not interested in.

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.

[1] https://klibert.pl/statics/smalltalk/sidebar.png

Yes and then you learn how use them together.

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

Until I watched this I never understood class definitions in Pharo. His "we tell the TestClass to create a subclass of itself" blew my mind.

What's the usefulness of that?

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.

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?

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.

My high school didn't either, just my elementary school. The mid-1980s were a different time....

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.

So, is Cuis Smalltalk left behind? For a while it seemed to maybe be the path forward for a lean, Free Smalltalk?

https://cuis.st/

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.

Pharo is anything but lean, so I don't think their relative merits have changed at all.

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.

[1] https://github.com/SeasideSt/Parasol

[2] https://github.com/ObjectProfile/Roassal3

What about trying the Godotalk [1]?

[1] https://pharoweekly.wordpress.com/2021/02/03/godotalk/

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.

I hope Pharo developers find time to fix this. HiDPI and variable DPIs are way too common and it does put users off to work with fuzzy/tiny UIs.

The "fusion of a developed program and development environment" idea is very cool.

One (maybe dumb) question though:

> Simple & powerful language: No constructors, no types declaration, no interfaces, no primitive types.

Are constructors and primitive types really the sort of things that people find to be unnecessary complexity?

you can (and often do) have constructors in smalltalk: https://stackoverflow.com/questions/36878787/making-a-constr... - i think the stuff you quoted was probably written with little thought.

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.

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.

The meta relationship is hard to understand (at first), but it is part of what causes the parsimony in all the interactions, and the "everything is an object". https://stackoverflow.com/questions/57898036/is-it-true-that...

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).

Primitive types are really annoying.

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.

I wish more languages handled it like Frink does.

https://frinklang.org/

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?

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.

Note the Cuis-Smalltalk Daily Workflow:

https://cuis-smalltalk.github.io/TheCuisBook/Daily-Workflow....

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.

I really wish Apple’s ObjC went more into the self/smalltalk route in its language and IDE rather than invent swift as a replacement.

I downloaded the launcher and there are two minor annoyances:

1. The font is blurry (upd: solved by increasing "SDL2 Screen Scale Factor Base DPI" in settings)

2. ~/Pharo/images is being created even though I changed all paths in settings

Anyone knows how to solve this?

>> solved by increasing "SDL2 Screen Scale Factor Base DPI" in settings

I drove it to 300, the fonts are still blurry. Are you on Linux or MacOS?

Linux using X11

Also setting 'Display scale factor'=1.0 because any other value makes fonts blurry again.

What do people use Pharo for? Is anyone here using it for a product?

See discussion for Pharo 10: https://news.ycombinator.com/item?id=30917420

https://pharo.org/success/

I work for one of the companies on that list and can attest we still use smalltalk/pharo.

Very cool. Smalltalk is one of those "I'd like to learn" languages for me.

it would take you about half an hour. absolute minimal syntax and fairly obvious semantics.

of course, learning how to use it properly might take a little longer :-)

I disagree with this.

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.

[1] https://gist.github.com/jdevoo/8e8866cd6087e05790841d0f20b2e...

sigzero doIt.

> ATMs in Moscow streets

> 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...

> 2 March 2017

https://pharo.org/success/ATMsInMoscowStreets.html

That's a surprising success story!

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...

On contra, my dart telegram bot runs on the same machine. I have to restart it weekly. Even when the load is 0. LMAO

You can use this tool to figure out how to run again any currently running container https://github.com/lavie/runlike

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.

Your bash history should be helpful here.

> 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 ;-)

There is a list at:

https://pharo.org/success/

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.

My first time seeing Pharo. First impressions are that it reminds me strongly of Smalltalk with the single-source IDE and runtime.

Not a bad thing, just an observation.

"Pharo is an open source, cross-platform implementation of the classic Smalltalk-80 programming language and runtime."

So not surprising.

Aah, it's intentional. :)

> Pharo features

> A dynamic, pure object-oriented programming language in the tradition of Smalltalk

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.

Can Pharo also store data in its language runtime (which is long-running if I understand right)? If so, does that make it its own type of database?

Yes, it is sometimes used as a database, and there is Gemstone [1] which brings it to another level.

[1] https://gemtalksystems.com/products/gs64/

> Ephemerons Production Ready.

Does anyone have any insight into this development? What impact on GC performance?

Some materials:

https://github.com/pharo-project/pheps/blob/main/phep-0003.m...

https://thepharo.dev/2021/04/07/a-taste-of-ephemerons/

But I do not know if Guille has some benchmarks.

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.

And motherpharos act like they forgot about Kay.

s/Pharo/Pharo Smalltalk/g

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."

This sounds like global mutable state hell.

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)

Perhaps the comment seemed to condemn without showing knowledge or understanding.

Perhaps asking why someone might need to do that would have prompted a more informative response.

Reply on news.ycombinator.com