
Pharo 7.0 released - estebanlor
https://pharo.org/news/pharo7.0-released
======
nudpiedo
Where does the Pharo runtime run? To which platforms can I bring its
solutions? are these standalone binaries or can I create libraries or code
which play well with other languages and systems?

Every time I look at a programming language, and at the HN it is every second
day, I think about what kind of problems can it solve, and for what kind of
platforms these compile/run their runtimes.. and surprisingly not many
programming languages inform properly about the most basic feature, and prefer
to go deeper into their.

~~~
virtualized
I looked for any useful documentation for a few minutes and just gave up. I
don't want to read a book. I don't want to watch a video. This is not my first
programming language, thank you. I just want a "hello world" example to get an
idea what I am actually dealing with. How do I run a "hello world" program
from the command line? How can I deploy that to another machine that doesn't
necessarily have a GUI?

~~~
lukego
> I just want a "hello world" example to get an idea what I am actually
> dealing with. How do I run a "hello world" program from the command line?

The trouble is that what you are dealing with is a graphical interactive
programming environment. Sure, you can run it from the command line like
/bin/perl, but to understand what you are dealing with you have to open it up
and try it on its own terms.

If you aren't interested in a novel immersive programming environment then you
can safely ignore Pharo too.

~~~
theon144
>If you aren't interested in a novel immersive programming environment then
you can safely ignore Pharo too.

I was curious and so downloaded and ran the default image, and I'm beyond
captivated by it, but I have to agree that neither the link nor the homepage
do a good job of enticing me to do so, or even hinting and what can I expect.

If I didn't feel like setting up and checking out random projects I stumble
upon, I would have never even seen what Pharo is about, given the abundance of
marginally different programming languages that pop up on HN.

So yeah, I also think Pharo's best "Hello, World" is just opening it and
trying out stuff, but maybe it should try to sell itself, at least a little,
for the uninitiated?

~~~
4thaccount
Agreed. The main website could benefit from somehow conveying the mind blowing
power of using Pharo.

Maybe lots of little gifs?

~~~
smoe
One thing that struck me a bit odd was, that the website makes it look like I
have to buy a book or join a (paid?) mooc to get started, because these are
the very first sections under "documentation".

I was just looking for a basic examples to get some sense what Pharo is about
and what the look and feel are. Without downloading and installing it, I
wasn't aware that there is a pretty nice interactive tutorial built in.

Maybe convey better how Pharo is distinct from other languages/environments
and how to get going?

Pharo is indeed very easy to get started, but the website makes it appear
harder than it actually is.

~~~
4thaccount
I don't remember the MOOC costing money, but it was in French with English
subtitles which is understandable with them being French researchers at INRIA,
but it couldn't keep my attention up due to the gap.

The books are all free in PDF form and the lead developer also has another
website somewhere where he hosts old Smalltalk textbooks which are largely
still relevant.

They certainly could work on conveying this better, but it is open source and
likely not a high priority.

~~~
smoe
Sorry, if I came off as too negative!

For me it was just the initial perception I got. E.g. I only realized that the
books were free after you told me. And yes, this is due to me evidently being
too lazy doing an additional click. I don't mind paying for books, but not as
a first step.

I did download and tried Pharo because I was intrigued by it from another
person, if I just were to land on the website from some random link, I likely
wouldn't have.

I think there could be some small changes in wording and presentation that
would get a long way for people without any prior knowledge of the language.
For example if you compare it to Rust (just content, not design wise)

[https://www.rust-lang.org/learn](https://www.rust-lang.org/learn)

~~~
4thaccount
I see what you mean. I think Smalltalk and lisp have always suffered from poor
marketing. There have been efforts to change this, but possibly too little too
late.

------
klibertp
Detailed changelog: [https://github.com/pharo-project/pharo-
changelogs/blob/maste...](https://github.com/pharo-project/pharo-
changelogs/blob/master/Pharo70ChangeLogs.md)

Sounds incredible! Git integration and related code management changes are
especially nice, 64-bit by default is great and support for binary packages is
also important. New, extensible code browser (Calypso) also sounds impressive,
but I'll have to see it in action first.

Pharo is an incredibly productive environment. Fully inspectable everything
(on the language level, but also on GUI level - you can inspect all kinds of
widgets interactively) and the Debugger where you can define your logic as
needed make for incredible programming experience. Plus, it's Smalltalk, which
is a beautiful language in its own right.

With this release, it looks like Pharo may finally become more than just a
toy. Looking forward to it!

~~~
lukego
GToolkit is also an exciting new development that's happening in parallel with
the mainline Pharo. This is a reimagined programming workflow for Smalltalk
with new UIs for coding, debugging, documenting, example browsing, testing,
etc.

Likely the best bits of this environment will be cherry-picked into future
Pharo releases, but meanwhile it is available here at
[https://gtoolkit.com/](https://gtoolkit.com/) and I for one am building an
application on it.

~~~
vanderZwan
Are there any screencasts or similar videos out there? Looks promising but it
probably "clicks" more if you see it in action with a more complete example.

~~~
lukego
I'd recommend downloading and starting it. It opens into an interactive
"notebook-like" tutorial. The system is very discoverable. Has a markdown-like
syntax where you can embed Smalltalk objects and code examples and interact
with them directly in the page.

------
nyrulez
I like what I see, but they do a poor job of explaining the use cases, which
is a common issue for most technical projects. Is this for:

\- learning?

\- developing personal projects?

\- developing business projects?

\- can be deployed to desktop platforms? mobile ? web?

\- Has GUI library support?

Without a clear break down of use cases, I am just lost in the cool technology
without any way of determining if it fits my needs.

A good example of how to do this well is GameMaker Studio:
[https://www.yoyogames.com/gamemaker](https://www.yoyogames.com/gamemaker)

~~~
rajula96reddy
Hey!

In fact, Pharo pretty much can do everything you asked for. It is just amazing
to learn a lot of CS concepts. Just so know, Pharo is a great tool to teach. I
am a student and this is how I came across Pharo about a few years back.

And you can build both Business applications
([http://pharo.org/Companies](http://pharo.org/Companies)) or personal
applications. Take a look at the catalogue here
[http://catalog.pharo.org/](http://catalog.pharo.org/) and
[http://smalltalkhub.com/list](http://smalltalkhub.com/list). You can do
almost everything in Pharo. Imagination is the limit to what you can do in
Pharo.

And also there is a good list of use cases at
[http://pharo.org/success](http://pharo.org/success).

HTH

------
jug
I was going to say that it sounds a little like that Smalltalk IDE Squeak, and
then it dawned upon me that this is actually a Smalltalk dialect too. :D

I'm going to throw this in here:

"Squeak or Pharo for the beginning Smalltalker?"

[https://stackoverflow.com/questions/8426981/squeak-or-
pharo-...](https://stackoverflow.com/questions/8426981/squeak-or-pharo-for-
the-beginning-smalltalker)

And a third option that is much leaner and maybe less overwhelming especially
if you are interested in actually learning Smalltalk itself to begin with:

[https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-
Dev](https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev)

~~~
sigzero
Pharo forked from Squeak a long while ago.

------
diegoperini
I lol'd when the quote, "Pharo is a pure object-oriented programming language
and a powerful environment, focused on simplicity and immediate feedback.", is
accompanied with a relatively chaotic artwork of the development environment.

Anyways, the dedication of the team is really remarkable. It looks like a
really useful learning/teaching tool for OOP. I'll try and hopefully beat my
prejudice.

~~~
shobith
For someone who's familiar with the "IDE" shown in the artwork, I was able to
quickly parse the different components and it conveyed a vague sense of
excitement :).

~~~
bitwize
Indeed. It harks back to the "holy shit, look at all the stuff you can do with
our tool!" marketing of the 80s and 90s.

Microsoft used to market advanced versions of their BASIC -- such as
QuickBASIC for DOS -- by having it open several windows on the screen and draw
or animate something different in each. A similar program shipped as a demo
for Microsoft's AmigaBASIC.

~~~
shobith
In any case, I'm not one to judge a programming system by its artwork. I hope
people don't get discouraged by it and not try it out, It's a phenomenal
system for translating thoughts to programs.

------
thekingofh
"Everything's an object" is object oriented programming done right and I can
see why Ruby and other languages used those ideas from Smalltalk. I couldn't
understand the fascination with the integrated environments though. It was my
biggest stumbling block. Is there a pathway to use Pharo with my traditional
tools?

~~~
infinite8s
It's more than "everything is an object", though. It's "everything is a _live_
object", which is why you need the entire integrated environment with it.

~~~
pavlov
Yes, that's the real point of Smalltalk.

I'm incredibly frustrated by environments like Ruby on Rails which pay lip
service to the idea of "everything is an object" — but those objects are just
a cesspool of hollow non-evolving throwaways that get built up and torn down
on every request.

It's the difference between a castle made out of toy blocks and the Buckingham
Palace.

------
vanderZwan
> _IoT is now an important part of Pharo. Installing PharoThings
> ([https://github.com/pharo-iot/PharoThings](https://github.com/pharo-
> iot/PharoThings)) provides an impressive amount of tools to develop
> applications in small devices._

On that GH repo[0] I see:

> _Raspberry driven by WiringPi library_

> _Arduino driven by Firmata, soon_

> _Beaglebone, soon_

Has anyone played with this?

[0] [https://github.com/pharo-iot/PharoThings](https://github.com/pharo-
iot/PharoThings)

~~~
ben-coman
I haven't yet. Plan to soon. Here is a demo...
[https://www.youtube.com/watch?v=ezfjditHjq4&t=344s](https://www.youtube.com/watch?v=ezfjditHjq4&t=344s)

------
AdmiralAsshat
The Pharo website has zero mention of its relation to Smalltalk, although the
Wiki article calls it a dialect.

So how close are the two in reality? Is the syntax from your standard
Smalltalk-80 textbook largely portable/compatible to Pharo, or is Pharo merely
"inspired" by Smalltalk?

~~~
zestyping
Why isn't Smalltalk mentioned on the front page?

It seems that simply mentioning that Pharo is based on Smalltalk would
immediately convey a lot of useful information to people who are new to Pharo.

------
norberthartl
Final steps have been taken to make it useful from small devices up to
enterprise usage. Still the best working environment ever encountered.
Congrats to this gem!

------
svc
A significant milestone, worth exploring for getting a new perspective on
working with objects.

Congratulations !

Sven

------
butterisgood
Been a fan for years of this work - though distant. I’d love to get more time
to really build something interesting in Pharo.

------
typon
Any good examples of open source tools made using Pharo?

~~~
offray
Many of them a listed here:
[https://pharo.org/success/](https://pharo.org/success/)

------
int_19h
Every time I try a Smalltalk (++) implementation, the custom UI framework is
what kills it for me. Not only are they completely non-native in look and
feel, but they also lag behind on features - e.g. Pharo is apparently non-
high-DPI aware on Windows.

~~~
aldanor
Plus the lack of vim mode.

------
stunt
Their website is down atm.

[https://github.com/pharo-project/pharo-
changelogs/blob/maste...](https://github.com/pharo-project/pharo-
changelogs/blob/master/Pharo70ChangeLogs.md)

~~~
ben-coman
[https://pharo.org](https://pharo.org) was down. Its now back.

------
register
The main issues that prevents me to have an interest in Pharo are the
following two: \- There is no real multithreading support \- It's not easily
embeddable

I believe that there are attempts to tackle these problems but what is the
status?

~~~
ben-coman
The traditional problem embedding is that the VM did a lot of window
configuration before the image started. This has all been stripped out of the
"minheadless" builds, which have defined a "virtual machine interface" used
like... [https://github.com/OpenSmalltalk/opensmalltalk-
vm/blob/Cog/p...](https://github.com/OpenSmalltalk/opensmalltalk-
vm/blob/Cog/platforms/minheadless/common/sqVirtualMachineInterface.c)

and... [https://github.com/OpenSmalltalk/opensmalltalk-
vm/blob/Cog/p...](https://github.com/OpenSmalltalk/opensmalltalk-
vm/blob/Cog/platforms/minheadless/common/sqMain.c)

------
zem
does it have decent hidpi support yet? I remember trying out pharo 6 briefly
and being unable to get it usable on my laptop.

~~~
armitron
This has been a point of contention for lots of people, including myself. From
what I remember, it was supposed to happen for Pharo 7 but now I see that it
didn't.

Squeak and Pharo are great but the font rendering is terrible, I can't stress
how bad it looks on hidpi screens. That makes it unusable for me since it
gives me headaches. It's a shame too since they have spent a lot of time
working on related frameworks (athens?, brick?, bloc?) that alas don't seem to
go anywhere (or nobody is in the position to bring everything together). Last
I checked they were trying to use a native library from Mozilla (Moz2D which
is the backend of Firefox!?!?) to do all rendering, which is highly
problematic and disappointing if it ends up being used. The clusterfuck of
libraries that they have layered together should clearly point out that this
is not the right approach.

On macOS, the graphics stack looks like: CoreGraphics <\- Skia <\- Moz2D <\-
Sparta <\- Bloc <\- Brick

Alan Kay would have a seizure. Aliaksei Syrel: What happened to keeping things
simple?

I really hope the graphics issues get resolved since I'm pretty sure they are
costing them a lot of users. The regular Pharo devs by virtue of using Pharo
every day are (probably) not in the position to realize how a new user coming
from environments with great font rendering, UI speed/smoothness, reacts to
Pharo. Initial impressions are everything.

~~~
scroot
I agree that the appearance of the system in this regard probably turns off
lots of users. There are some in the Pharo community who are quite aware of
this fact, but there are simply not enough contributors at the moment to deal
with it on their own.

I am more hopeful about Bloc, however. The stack is not any more insane than
that of a web browser.

~~~
atemerev
The entire subsystems were rewritten from scratch, there are huge lengths of
deprecated and/or poorly documented code, however, this hidpi bug remains
unfixed for 5 years or more.

This is not about having too few contributors; this is about different
priorities. This is why Pharo remains an obscure project on the margins of the
industry, despite all its potential.

------
bunderbunder
For anyone interested in learning Pharo/Smalltalk, there is a pretty decent
MOOC: [https://mooc.pharo.org](https://mooc.pharo.org)

------
claystu
TLDR: Pharo needs mountains of high-quality documentation equal to Python's
docs or Java's docs if it seriously hopes to attract server-side or desktop
mindshare among developers.

Long Version:

In 1980, Smalltalk had some of the best documentation of any language out
there. In 2019, it basically has none. By 2019 standards, Pharo 7 ships
without any documentation at all. That's a game-stopper.

Pharo 7 looks really polished. It sounds like the design team put in tons of
hard work over the past year and half to produce this release. Moreover, since
it's smalltalk, Pharo is also probably very powerful for both web and desktop
development. BUT NONE OF THAT MATTERS IF DEVELOPERS CAN'T FIGURE OUT HOW TO
USE IT!!!

(pardon the all caps, but I want to emphasize my point)

Here is my message for the development team: if you really want developers to
start building stuff with Pharo, then you absolutely must (1) write detailed,
soup-to-nuts, high quality docs for web design and (2) write another set of
detailed, soup-to-nuts, high quality docs for desktop GUI programming.

The Pharo book doesn't cut it--not even close. It's not a very good book. The
Pharo MOOC doesn't cut it--again, not even close. Who wants to learn that way?
ProfStef is just a fancy hello world; it's really not a tutorial and it
doesn't lead anywhere.

I realize that what I'm saying comes across as pretty strong medicine, but
please understand, that's because I actually think Pharo looks amazing and
would like to use it.

In my opinion, you should stop development on Pharo and document what you've
built instead. Write docs for a year. Today's release announcement states that
the Pharo 7 team closed 2142 issues. Brag in 2020 about the fact that you
wrote 2142 pages of documentation and tutorials over the past year. Make your
documentation coverage as thorough as your testing coverage.

Imagine what might happen if Smalltalk 2020 was as thoroughly documented as
Smalltalk 80.

~~~
offray
Thanks for the feedback.

Have you seen [1] and specifically [2]?

[1] [https://pharo.org/documentation](https://pharo.org/documentation)

[2] [http://books.pharo.org/](http://books.pharo.org/)

Do you have a particular example of a site where the kind of documentation
that you would like to find is published for other language (lets say Python)?
This could help to understand better which are the expectations and why
current books and MOOC are not enough.

~~~
khinsen
From my experience as a recent Pharo user (started in October 2018 with the
Pharo MOOC), the two main issues with existing documentation are

1) Much of it is outdated. 2) Much of it supposes significant prior knowledge
of Pharo.

Once you start to become familiar with Pharo, neither is much of a problem.
You see that the screenshot of Pharo 5 resembles what you see on Pharo 7 in
spite of superficial differences. And you picked up enough of the jargon to be
able to judge if some documentation is close to your level or not.

For someone who downloads Pharo 7, starts it up, and wonders "what now", most
of the existing documentation is confusing. The MOOC was a much better
starting point back in October, but with the new system browser in Pharo 7,
it's seriously outdated as well.

~~~
hilaire
Racket is very exemplary with its documentation: [https://docs.racket-
lang.org/](https://docs.racket-lang.org/)

GUI documentation will likely never show up: the current graphic framework is
outdated, subject to deprecation and no subject to improvement since Athens
low level layer was left as it is. It may or may not be replaced by Bloc or
something else. I don't thing anyone is willing to write documentation when
there is not clear direction regarding the GUI framework.

~~~
klibertp
> when there is not clear direction regarding the GUI framework.

Isn't it crazy for this not to be solved yet?! That's a long time - don't
remember exactly, but I started with Pharo 1.4 IIRC, and it was bad back there
already, then juz got worse.

Is there a blog post detailing a) all the kinds of GUI frameworks that are out
there and how advanced their development; and b) what approaches were tried
and abandoned, when, and why? I know it's much to ask, but, at this point, I
feel the lack of progress in this area should become a much higher priority,
and a blog post like would help in recruiting people for the effort.

------
dangom
How does this feel compared to programming in Emacs? (It's an honest question,
from someone who'd love to try out Pharo)

~~~
klibertp
It's more like " _programming Emacs_ " instead of "programming _in_ Emacs".

Try writing a mode for Emacs, something like Helm or NeoTree or Dired, _in_
Emacs and you'll get pretty much the same experience you'd get from Pharo,
although with a lot less visual feedback. Emacs is concerned mainly with text
and it's naturally reflected in its APIs, but the fact that you can live-edit
any function or advice and see its results change immediately after pressing
C-M-x is exactly what Smalltalk/Pharo does.

It's magical, in both versions. Smalltalk was designed for GUI first, so its
APIs for manipulating graphical objects are much like Emacs APIs for text
manipulation: vast, rather complete, also a bit arcane due to decades of
history. There's one thing that Emacs lacks and that would be support for
restarting code execution from any place (possibly edited in the meantime) on
the call-stack after exception: Pharo's debugger lets you do that, which is a
thing worth experiencing at least once as a programmer. :)

------
qwerty456127
Is it possible to integrate Pharo with KDE so the windows won't be trapped
inside the Pharo window (I don't really like MDI) and would have system-set
decorations (I love using "keep above", "keep below" and "shade" buttons I've
added via the window manager configuration)?

------
zionpi
Is there any progress on porting to mobile
system.[This]([https://medium.com/@richardeng/mobile-
smalltalk-c6f0cc712909...](https://medium.com/@richardeng/mobile-
smalltalk-c6f0cc712909\)mobile) SmallTalk seems to be the furthest endeavor.

------
agumonkey
old article about calypso class browser
[https://dionisiydk.blogspot.com/2016/12/calypso-new-
system-b...](https://dionisiydk.blogspot.com/2016/12/calypso-new-system-
browser-for-pharo.html)

------
mhd
A few years back Pharo's predecessor/sibling Squeak was garnering some
interest due to its "Seaside" web framework, which used continuations and so
made some interactions easier to program.

But after the rise of JavaScript, this became a lot less important.

------
kgrimes2
Looks interesting. Getting a weird error when installing it via Homebrew,
though: "“Pharo6.1-64” is damaged and can’t be opened. You should move it to
the Trash."

Anyone experience anything similar?

~~~
scroot
I think this is some BS that has to do with OSX's "security" and that
applications like this are required to be in the Applications folder. I could
be wrong.

------
m_mueller
Genuinely curious: Is there any industry usage going on for Pharo?

~~~
pjmlp
There is, if you consider it is a Smalltalk dialect.

[http://www.cincomsmalltalk.com/main/](http://www.cincomsmalltalk.com/main/)

[https://gemtalksystems.com/](https://gemtalksystems.com/)

So you can learn Smalltalk with Pharo and then get into the big boys
Smalltalk.

However expect the typical enterprise projects where Oracle DB licenses are
footnotes on the overall budget.

~~~
emaringolo
These are commercial vendors, but there are industrial uses of Pharo itself,
and as Pharo gets better a lot of companies are moving from their commercial
dialects to Pharo. In particular from Cincom Smalltalk to Pharo.

~~~
pjmlp
Thanks for the heads up.

------
AllegedAlec
I have Pharo installed on my laptop to try some stuff out with it, but I
haven't gotten around to it yet. Maybe this is as good a time as any to start
it up again.

------
idahasen
Big fan of Pharo!

------
collyw
First time I have heard of this. What does it offer that other languages
don't? What are the downsides?

~~~
snazz
Pharo is the most actively developed and used Smalltalk environment. There’s
plenty of evangelism and information on the Web about it in a similar way to
Lisp. Pharo takes the “integrated” in IDE to a whole new level, which is one
of its selling points. You can find plenty more information about how
Smalltalk-style OOP is superior to Java-style OOP, so I won’t rehash that
here.

~~~
sigzero
> Pharo is the most actively developed and used Smalltalk environment.

Is that true? VisualWorks isn't used more places? Where are you getting that
information from?

~~~
d-mason
One of the key words in that statement was "actively developed". Cincom,
Instantiations, and GemTalk have some great people working on them, but Pharo7
had 75 different people contributing - including probably almost as many full-
time people as the commercial developers (maybe more).

~~~
sigzero
I love Pharo, so don't take this as me trying to take anything away. Cincom
"actively develops" VW as well. I keep in touch with that side just for my own
information. Pharo is doing a phenomenal job.

------
shubb
What is this thing - is it a programming language or an operating system or a
desktop environment?

~~~
Gene_Parmesan
It's a Smalltalk. It's half language, half environment. The language itself is
one of the inspirations for Ruby, and you will find in Pharo a purer
expression of much of Ruby. The whole, 'everything is an object' applies, but
so does 'everything is message passing,' and in a much more thorough way. The
language's syntax is almost reminiscent of LISP in its simplicity (not its
actual form, but there is so little of it that you start to feel like you're
working directly with the objects, rather than programming them).

The other half is the environment. It's possible to run Pharo code, e.g., from
the command line, but if you do all of your Pharo coding and debugging from a
traditional editor+terminal combo, you're missing out on most of the reason to
use the environment in the first place.

The environment is 'live' while you code. The objects are live, and the
environment itself is an object you can interact with. When you add code, your
code executes within that very same environment. There is no separate runtime.
The runtime and the codetime are the same. Your code simply gets saved as part
of a Pharo 'image' you are editing, and this image can be reloaded and resumed
from where you left off.

The most common idiom is to program with a "TDD on steroids" approach. You
create a skeleton of a few tests, and start it running. The debugger will stop
and tell you the object you are sending Message X doesn't respond to that
message. So while the debugger has paused the environment, you add the method
with the help of the integrated GUI. Smalltalk (the original Smalltalk)
pioneered the use of a 'class browser,' which does what it says on the tin.
Pharo includes and extends this concept. Once you've added your method (or
even, added the class entire), just hit resume and the (incredible) debugger
will take you to the next bit that needs fixed. This is a more powerful edit-
and-continue that actually works.

Having said that, while I enjoy playing around with the environment and using
it to prototype some class hierarchies, I've had a tough time finding a
professional use for it. The very qualities that make it mind-expanding to
learn and play with, seem to limit its use "in production," so to speak. Who
knows, maybe I'm unique, but I couldn't see myself in a hundred years being
able to convince my employer to use it.

But it really is an eye-opening experience to learn. Just like learning LISP
pushed my personal boundaries although I don't use LISP at work, similarly
Pharo has pushed my boundaries in a way that I highly recommend experiencing.

~~~
shubb
Thank you very much for writing this!

------
i_feel_great
By the way, how do I update pharolauncher to pick this up?

------
fxfan
[https://web.archive.org/web/20190122153012/https://pharo.org...](https://web.archive.org/web/20190122153012/https://pharo.org/news/pharo7.0-released)

~~~
ahmedalsudani
Documentation if, like me, you want to find out more about the language

[http://web.archive.org/web/20190118083918/http://pharo.org/d...](http://web.archive.org/web/20190118083918/http://pharo.org/documentation/)

------
allwein
After reading this line:

> Pharo is a pure object-oriented programming language and a powerful
> environment, focused on simplicity and immediate feedback.

and seeing the initial screenshot on the announcement, I thought that this was
a joke post. How you can call this "focused on simplicity" while showing that
horrific hodge podge of a screen shot is beyond me.

~~~
ben-coman
Thanks for your feedback. Maybe it would be better to show the three tools in
separate screen shots rather than overlapping.

One aspect of simplicity is its minimal syntax...
[https://en.wikipedia.org/wiki/File:Pharo_syntax_postcard.svg](https://en.wikipedia.org/wiki/File:Pharo_syntax_postcard.svg)

~~~
wolfgang42
That's a pretty chaotic postcard. I think I get the point that it's trying to
make, but at first glance it doesn't exactly convey the idea of simplicity.

~~~
the_af
Keep in mind that seems to be the _entire_ syntax. Doesn't look chaotic to me,
and I'm not even a Pharo (or Smalltalk) user!

~~~
ben-coman
correct. that is the _entire_ syntax.

------
m3kw9
Why would I use this instead of C++ for example

~~~
Gene_Parmesan
It's a totally separate domain. Pharo/Smalltalk is essentially pure OOP in the
way that Scheme is pure FP/LISP. So for me personally, I've used to increase
the depth of my understanding of programming. It can also be good for
prototyping class hierarchies and the like.

You can find examples of people using Pharo in production (and far more
examples of people using other, more industrial-grade Smalltalk dialects), but
I personally haven't been able to think of a way to use it on real projects.
But that doesn't mean that it isn't worth studying.

