

The Grace Programming Language - Morendil
http://gracelang.org/

======
mahmud
Ignoring the numerous typos and the lack of a working implementation, this
stands out:

" _Give the last 20 years experience with C, Java, and other “real” languages,
perhaps it is time to reconsider, and instead create a language designed for
novices._ "

Such language exists, and it's called Oz.

<http://en.wikipedia.org/wiki/Oz_(programming_language)>

It's the most mind-expanding, most diverse in the paradigms it supports, and
certainly one of the most interesting languages out there. And it's a tiny
kernel language the size of Scheme that one can learn piece-meal. You can use
it like Pascal, or Scheme, or Prolog, or Self, or Java, or Erlang ..

Mozart/Oz can teach newbies, no doubt. But it can't be taught by anyone. It
requires an open mind and someone who is a competent programmer, not just an
assignment pusher. I don't think most profs and TAs will be able to teach it
as well as they should, but students can learn it on their own.

<http://www.info.ucl.ac.be/~pvr/paradigms.html>

Click on the PDF poster there and see how broad the language is.

~~~
swah
> and the lack of a working implementation

This is great news, I don't actually have to download and play with this one
:)

~~~
mahmud
Not even a specification.

By the way, I know a few of the names there and I know how completely
different their computing tastes and personalities are. I would love to see
the archives for the discussion mailing-list for this one, will be very
entertaining .. and informative :-)

------
raganwald
I don't understand how "suitability for teaching" and "suitability for
industry" differ, except that industry naturally wants to stick with whatever
it already has.

But if you can design a language that serves as an excellent medium for
teaching all of the important ideas in Computer Science, why wouldn't you go
on to build the libraries and infrastructure you need to make it viable in
industry?

~~~
cageface
It's simple. Designing a language that clearly illustrates CS fundamentals and
a designing a language that supports maintenance of huge codebases by teams of
programmers of varying ability are two very, very different problems. It's no
accident that CS profs love Scheme and banks love Java.

What really matters is how well your language supports your primary level of
abstraction. The turtles-all-the-way-down nature of elegant languages like
Smalltalk or Lisp doesn't really make that much difference when you're mostly
manipulating high-level third party APIs and where mature tools and
predictable, easily readable code count for more than the ability to roll your
own new object system in the core language.

~~~
raganwald
First, I am under the impression that a great many CS professors teach CS
using Java.

Second, are you suggesting that _since_ banks love Java, _then_ Java is a
language that supports maintenance of huge codebases by teams of programmers
of varying ability to a greater extent than Scheme or any other language?

Third, I am confused by the suggestion that "elegant" languages are somehow
unsuitable for writing "predictable, easily readable code." Can you expand on
this?

Update: Fourth, I forgot the essential point I was implying in my original
question. What is there about "maintenance of huge codebases by teams of
programmers of varying ability" that _isn't_ a CS fundamental?

Sure, if you are talking about Computer Science as a study of the properties
of a formal system, this is irrrelevant and lost amidst talk about category
theory and turing equivalence. However if you look at CS in a wider context
you have professors teaching things like encapsulation, which has certain
important implications for the study of formal systems but also has important
implications for "maintenance of huge codebases by teams of programmers of
varying ability."

This is part of the motivation for Wirth expanding Pascal into the Modula
family of languages: To create a language that was useful for teaching and
practical for the construction of the Lilith workstation.

I can't imagine _anything_ about "maintenance of huge codebases by teams of
programmers of varying ability" that isn't a suitable topic for teaching and
especially research.

~~~
cageface
My impression is that most CS profs teach Java because they've been forced to
and that they're not very happy about it. Which makes sense, because Java is a
terrible language for teaching fundamentals.

And yes, I do think Java is much better than Scheme for the kind of software a
bank wants. The rigid syntax, static type system, and built-in OO, and lack of
macros make it easily to build very powerful tools, which you need when you're
wading through a huge, unfamiliar codebase. These same features make it pretty
easy to jump into an arbitrary codeblock and understand what it's doing.
Scheme, for example, is so flexible that you can design your own exception-
handling and iteration constructs, which nobody but you can read.

As far as elegance goes, it counts mostly in the small. Quicksort in Haskell
is a thing of beauty but most production code looks nothing like this. The
vast majority of real production code is just API glue and simple iterations
and elegance just doesn't enter into the discussion.

~~~
raganwald
Your arguments appear to be of your own construction, not of mine. I never
said Scheme is an ideal language for teaching, you did. Yet in the same
thread, you deride "elegant" languages as only being elegant in the small.
This thread is about devising a new language for teaching. If the Scheme is
only elegant in the small, why would we use it for teaching? We would devise a
language that isn't anything like Scheme if we believed what you profess to
believe.

If "rigid syntax, static type system, and built-in OO, and lack of macros make
it easily to build very powerful tools," why wouldn't we teach with a language
featuring "rigid syntax, static type system, and built-in OO, and lack of
macros?"

Overall, I get the strong impression that you like Java and don't like Scheme.
Have at it, you are not alone. But there is no reason for me to debate that
with you, since at no time have I said that I prefer Scheme to Java for
teaching or for industry.

My claim is, essentially, that if we are designing a single new language, then
whatever characteristics we think are appropriate for demonstrating CS
concepts will also be appropriate for business. I voiced no objection to
static typing or rigid syntax or lack of macros. You did.

~~~
cageface
_If "rigid syntax, static type system, and built-in OO, and lack of macros
make it easily to build very powerful tools," why wouldn't we teach with a
language featuring "rigid syntax, static type system, and built-in OO, and
lack of macros?_

Because the point of CS education is to teach concepts, not tools, and all of
those features actually obscure the core ideas. It's the same reason that code
examples in textbooks aren't littered with the kinds of error handling code
that real production code requires. It's the same reason that medical students
work on cadavers before getting anywhere close to a real operating room and
all the extra risks and distractions that entails.

 _Overall, I get the strong impression that you like Java and don't like
Scheme._

No, I'm just not one of those people that tends to assume that industry
programmers are either stupid and/or ignorant for hesitating to build
commercial apps in research languages.

~~~
raganwald
You equate "teaching language" with "research language." You believe that a
language with rigid syntax, static typing, and built-in OO would obscure the
core ideas of computer science. Fine. You believe that. I'm sure you grasp
that others, especially the list of people mentioned in the post, do not share
your views.

So, what we have here is that you have certain beliefs about what makes a
language suitable for teaching and what makes a language suitable for
industry, and on the basis of your views, you do not believe that the same
language would be suitable for both purposes. I accept logically that your
conclusions are compatible with your beliefs.

I don't understand your last sentence. It seems to be some sort of axe
grinding, as I certainly don't recall saying anything about industry
programmers being ignorant or stupid.

So all together, I can't think of anything new to add to this thread. I feel
like a foil used for you to set up and demolish your own arguments.

------
limmeau
Having taught/TA'd first-year university programming courses in both Scheme
and Java, I find the idea of a teachability-oriented imperative OO programming
language quite appealing.

Our first-semester course used DrScheme, and the simplicity of language and
IDE helped us focus on teaching a structured approach to programming, with
unit tests first etc. Also, whenever the program did not behave as expected,
we could go through the program with Scheme's eyes and mentally apply the
evaluation rules.

In the second semester, students are supposed to learn Java, and that was
challenging because you really have to understand static methods and String
arrays just to write a Helloworld program of which you can explain every line.
Also, Java rewards using public field accesses instead of getters&setters (in
the short term), which is just the habit you don't want your students to
adopt. I could go on with arrays vs. collections, classes in the io package
which should be interfaces etc...

So if there was a clean statically-typed modern OO language, I'd look forward
to using it.

------
stefs
> (sometimes by way of C or C)

> New languages such as C and Scala have learned lessons from Java's design
> (... blah blah ...), and also retain or duplicate many features for
> backwards compatibility with C or Java.

drunk blogging ftw.

~~~
zephyrfalcon
I think that somehow a few special characters disappeared here; maybe they
were eaten by some kind of text processor or something. I think the first line
should be "C or C++", the second one "C# and Scala".

------
Morendil
BTW, I'm just being a messenger here - I got this link off Twitter and thought
it'd be of relevance here.

I can't muster much enthusiasm for the initiative myself. My gut reaction is
"oh no, as if we needed one more", and I winced at the blog post which said
"the most important thing in a new language is that you can println 'Hello
world'". I can't find any evidence of design thinking that strives to achieve
the lofty objectives set out in the PDF paper.

But I'm looking forward to the discussion :)

------
xtho
The lack of innovation in the design principles (see the abstract) is well
reflected in the name:

\- <http://freshmeat.net/search?q=grace>

\- <http://www.google.at/search?q=grace%20software>

Could be a case of the NIH-syndrome. The jury is waiting for some sort of
implementation.

------
endergen
I'm not a fan of Teaching languages, teach algorithms and clean concepts. It
takes much time to get good at a language you might as well be using one to
learn your algorithms with.

And not just the language but the Version Control, Libraries, Documentation
Tricks, Culture, and Relationships that come with truly learning a Language.

~~~
limmeau
At least version control and writing good documentation are orthogonal to the
choice of language.

~~~
wazoox
However version control is never taught in school.

~~~
limmeau
Isn't? Both my Java course and the competing C++ course used Subversion.

(Well, at least for submissions).

------
Kilimanjaro
Here, the simplest language that works:

    
    
      $ 'Hello World!'
    
      @ 10
        $ 'Hello world'
    
      @ 1:10 as i
        $ i*i
    
      ? 2>1 $ 'Two is greater than one'
      | $ 'No it is not'
    
      # fact(n)
        ? n<2 -> n | -> fact(n) * n 
    
      $ fact(5)
    

If you can guess its basic constructs then you are already proficient in it.
As in python, white space is important.

