
Open Dylan's Call for Help - BruceM
http://opendylan.org/news/2014/01/28/call-for-help.html
======
gcv
It's a crying shame that Dylan did not become the systems language of Apple's
new era — it's really quite lovely. Much nicer than Objective C, though
undoubtedly trickier to compile efficiently.

~~~
gress
It seems as though Objective-C is slowly morphing into something more Dylan-
like over time.

~~~
sanxiyn
Will Objective-C ever get hygienic macro?

~~~
gress
That would be nice. I think there are a lot of other cleanups that will come
sooner.

------
informatimago
A lot of open source projects are quite human resource constrained. I see two
solutions to this problem:

\- universal citizen revenue, so that programmers who want to work on free
software or open source may do it more easily.

\- let's reduce the ecosystem diversity. I'd move to drop all those useless
fancy languages, and let's all concentrate on Common Lisp, developping tools
and libraries, perfecting the implementations, etc.

(No need to argue, I know the former will occur sooner).

------
peterhull90
In the mid-90s I did some playing round with something called MINDY from
Carnegie Mellon. It was (IIRC) a Dylan interpreter (the acronym was 'MINDY Is
Not Dylan Yet') and was very interesting both to experiment with Dylan and
also to see how MINDY itself was implemented. As I remember, a cool thing
about the Dylan concept was that it had a sliding scale of dynamic-ness - in
other words you could start off being quite relaxed about types but, where
needed, you could narrow down the types, seal generic methods etc. and the
compiler would then be able to optimise better, for example by avoiding
dynamic dispatch if it could prove it knew the specific method at compile
time.

~~~
yetfeo
Mindy was used to bootstrap Gwydion Dylan, a Dylan compiler implementation.
This was the main open source Dylan implementation for quite some time until
Functional Objects (which obtained the code and rights from Harlequin when
they went out of the language business) open sourced their implementation
which is now 'Open Dylan'.

Functional Developer (What was Harelequin Dylan) was nice. The editor would
syntax highlight the code based on the optimization level. In this way you
could look at a method call and see if it was inlined or not and decide
whether to seal functions or classes to improve performance.

Another interesting feature was the editor was written in Dylan (using a
framework called Deuce). This was emacs-like and had features like virtual
sections in a buffer that could each be mapped to a different file on disk.
This allowed viewing in a single editor pane the implementations of all
methods of a generic function even if they crossed multiple files. This could
also be edited as if it was a single file.

~~~
experimentsin
Optimisation colouring was one of the Harlequin Dylan features I was most
proud of having a hand in back in the day. Did anything like it ever get
implemented in a more mainstream IDE?

We only implemented it for static optimisations I think (i.e. you could see at
a glance how well the compiler had inferred types, resolved method calls,
inlined functions, etc), but we had a lot of ideas at the time around its
future application to profiling results, as well as layered, more interactive
presentation.

It'd be a great addition to Light Table...

~~~
yetfeo
I don't know of other IDE's that use the idea. It's a pity as I used this
feature a lot when using HD/FD.

------
gghh
ah, Dylan! I remember from far 2005 a team called "Dylan Hackers" who earned
both the judges' prize and the second prize at the ICFP Contest (cop &
robbers), [http://icfpc.plt-scheme.org/](http://icfpc.plt-scheme.org/).

Here the blog post describing their entry:
[http://www.hoult.org/bruce/icfp2005/](http://www.hoult.org/bruce/icfp2005/)

~~~
yetfeo
Dylan did well in multiple ICFP contests IIRC.

~~~
thomasz
The team is infinitely more important than the language, and the Dylan Hackers
team was top notch.

------
bjourne
When reading about Dylan, it seems one of it's main selling points is
"everything is an object." But nowadays, that's true in many other dynamic
languages like Python, Ruby and Clojure. Macros are everywhere and you can
even add them to Python if you want to using third party modules. Though I've
never felt the need because Python's syntax is excellent as it is.

For me it is very hard to see what Dylan brings to the table. It's nieche is
already filled by more popular languages.

~~~
BruceM
A Common Lisp-style condition system is a pretty key thing for me.

It is highly readable. And you can use '!' and '?' in names!

An optimized implementation of multimethods is always nice.

The ability to apply optional static typing is great for putting stuff into
production and feeling good about it.

Having multiple return values, keyword arguments and rest arguments is nice
(and yes, Python can do much of that).

~~~
coldtea
> _It is highly readable. And you can use '!' and '?' in names!_

Somehow this feels a little contradictory.

~~~
grdvnl
Why do you feel it is contradictory? I think having method names end with "?"
whenever they return a boolean value is quite intuitive. They seem to stand
out more than having such method names start with "is _" or "has_". YMMV.

~~~
experimentsin
Looking back at some Dylan code again now, I still find its richer, Lisp-
derived, hyphenated naming approach more readable-and-expressive than either
camelCase or underscore_separated identifiers.

When Dylan switched from Lisp syntax this was something that was fretted over
an awful lot, for obvious reasons, but we went with it and it worked fine.

I'd love to see some other algebraic (non Lisp) syntax language get more
creative in this direction again one day.

------
sspiff
For those interested in using Dylan or helping out, I've found the community
very welcoming to beginners and they're eager to help you get started.

------
nickik
Since Dylan people are probably reading this.

\- What GC will the LLVM backend use?

\- Is there any data an the performance of the MPS?

~~~
BruceM
Hi Nick,

I have a branch that will soon allow using either Boehm or MPS on the various
backends. That'll probably be the case for the LLVM backend as well.

Part of the reason that I'm doing that is to help gather some performance data
on the MPS. (I'm actually doing that Dylan runtime work under contract.)

~~~
nickik
Hi Bruce.

I actually met prom yesterday and he showed me that there are much more
information on MPS know. I already read threw most of the documentation and
I'm very interested to maybe use it.

I don't yet fully understand the license and what it means, I will probably
join IRC in the next days and dig for some more info on MPS.

Great that you get payed to work on this.

------
CmonDev
Developing the language is more interesting then developing tooling I guess.
F# has same issues.

~~~
kozhevnikov
I'm still waiting on a C# REPL since the 2008 demo [1] or Roslyn release
beyond CTP, not M# whatever that is.

[1]
[http://channel9.msdn.com/blogs/pdc2008/tl16](http://channel9.msdn.com/blogs/pdc2008/tl16)
@ 1h1m

~~~
michael_h
C# REPL like this [http://www.mono-project.com/CsharpRepl](http://www.mono-
project.com/CsharpRepl) ?

