Relaunching Open Dylan on Windows requires ... (Part 1)
"Peter Robisch" <[email protected]>
| Newsgroups | gmane.comp.lang.dylan.gwydion.devel |
|---|---|
| Message-ID | <[email protected]> |
Relaunching Open Dylan on Windows requires ...
... to reckon: What are core features of the next programming languange
on Windows
--- This is Part 1 of the Serie
"Requirements to relaunch Open Dylan on Windows" ---
Any relaunch project for Open Dylan for Win 8 has to anticipate the Microsoft technology strategy, especially related to its OS world, or the interactive development environment (IDE) world, or the world of programming languages (PLs). The topic of this post is:
How to reckon MS Vision related PLs
A blog entry by Hermann Venter from Microsoft Research, who invented with his team the CCI (Common Compiler Infrastructure) based on CLI / .NET, gives a first hint. His blog article It is not usable if it is not functional [1] describes the demands of the future and why .NET, is lagging. (.NET represents here the Common Language Infrastructure as specified by Microsoft and publish by EMCA)
Introducing Joe Duffy and bluebytesoftware
Related to “what are core features of the next programming language on Windows” the blogs of Joe Duffy [2] provide some hints. His webblog is the bill-board of the startup "bluebytesoftware.com". Joe Duffy is a former member of the Common Language Runtime (CLR) team of Microsoft [3]. It seems that two other former CLR team members are working at "bluebytesoftware.com" [4]: Adam Nathan and Krzysztof Cwalina.
Adam Nathan's author page at Amazon mentions that he is "a principal software architect for Microsoft in the Startup Business Group" [5]. But let us turn form insight in the current startup world back to our real interest of this post: What is MS vision relate to PLs?
To find an answer to this question it is helpful to look at Joe Duffy's last blog titled "Imperative + Functional == :-) " (Dec. 8, 2012).
( --- Note:
Joe Duffy blog is related to MS Research papers,
that Bruce Mitchener, our designatus for the title
community director, already brought in mind to us
in his post on Dec 5, 2012 [7]
-- )
In his blog from of Dec 8, 2012, Joe Duffy describes the goals of his current work:
1. Create a single language that incorporates the best of functional and imperative programming. Both offer distinct advantages, and we envisioned marrying the two.
2. Codify and statically enforce common shared-memory state patterns, such as immutability and isolation, with minimal runtime overhead (i.e., virtually none).
3. Provide a language model atop which can be built provably safe data, task, and actor-oriented concurrency abstractions. Both implicit and explicit. This includes, but is not limtied to, parallelism.
4. Do all of this while still offering industry-leading code quality and performance, rivaling that of systems-level C programs. Yet still with the safety implied by the abovementioned goals.
The four points are quotes from "Imperative + Functional == :-) " [6]. Already the title of this blog does mention an approach which the backbone of dylan’s language design. Also Duffy’s programming language background enforces that belief, that the Dylan language starts to reach an era where its design approach is becomingthe mainstream approach.
Joe Duffy's programming language background
“I've programmed a great deal in functional languages.
I'm a long-time lover of LISP and ML, and my closest friends
know about my hard-core dedication to Haskell (expressed in
an admittedly odd manner).”
Let us continue in quoting from [6] to make this clear:
“In fact, Haskell's elegant marriage of pure functional
programming with monads, notably the state monad, was
a major inspiration for the design of the type system.
There are of course many other influences, such as regions,
linear types, affine types, etc.; however, I'd say Haskell
was the strongest.”
In short: Haskell will influence the next language project of Microsoft.
"What would it be like to embed pure functional programming
within an otherwise imperative language?
In some sense, we have simply taken the reverse angle of Haskell
with its monads: what would it be like to embed pure functional
programming within an otherwise imperative language?"
In short: Imperative + Functional == :-)
(BTW, that is the titel of Joe Duffy's blog.)
“This first goal is proving to be my fondest aspect of the
language. The ability to have "pockets of imperative mutability,"
familiar to programmers with C, C++, C#, and Java backgrounds,
connected by a "functional tissue," is not only clarifying, but
works quite well in practice for building large and complex
concurrent systems. It turns out many systems follow this model.
Concurrent Haskell shares this high-level architecture, as does
Erlang. Well-written C# systems do the same, though the language
doesn't (yet) help you to get it right.
Of course, as called out by the second goal, immutability and
controlled side-effects are tremendously useful features on their
own. Novel optimizations abound. “
Open Dylan members are invited to comment this,
e.g. Peter Housel, Hannes Mehnert, or anyone else.
Perhaps Peter Housel comment on this,
- currently working on the LLVM back-end for the Open Dylan compiler -
or Hannes Mehnert
- known for his hacking on the dylan type system
Especially I like hear their views about
-- what are dylan capabilities to scope with such a next language
-- where does dylan have hidden feature which can be adapted
to scope with such a next language
-- Some hints how LLVM can work as JIT compiler. The .NET system
uses assemblies with CIL code as input to the JIT compiler.
Is something similar possible with LLVM. Or let us turn the
question around. Do have the chance to adapt the CLR way of
compiling with dylan and llvm?
Of course anyone else from this list is also invited, to give a respond, too. :-)
The above writing focused around
Relaunching Open Dylan on Windows requires ...
... to reckon: What are core features of the next
programming languange on Windows
Let us switch the focus to
Why supporting WinRT by the dylan language makes sense
In my last post : WinRT and dylan - first insights (Dec. 10, 2012)
I announced to give some background information to my belief, that supporting WinRT by the dylan language makes sense.
WinRT is currently used by Microsoft Marketing for its fight to get a better share in mobile computing market. So its new UI (tiles, asynchro mechanism) is mentioned in many WinRT related articles you get back from search engines. But the new UI (and adapting DUIM) is not what makes WinRT interesting to the Open Dylan community.
WinRT is so interesting to the Open Dylan community, because now Microsoft announces a technology which requires a programming language to support DSL (Domain Specific Language). Dylan already in its design has this capability (macros) (and many other languages have not). Dylan now has the chance to become the language of choice. Of course, Dylan has to evolve to fill such market niche.
As we are in phase of refactoring the code of Open Dylan, it good that Microsoft does the related things to its API in the context of publishing
WinRT.
What make WinRT interesting is that it is Microsoft's technology to automates the bridging between WinFX (Microsoft internal name for .NET as CLI technology implementation) and the WinOS. So evolution to the WinOS are now directly accessible to .NET developer as soon as they are published. (This was not the case as interop from .NET to WinOS in the past required a wrapper layer which was not automated, but required hand coding.
If you feel bridging between WinFX and WinOS could more explained, I like to forward you to Krzysztof Cwalina.
Krzysztof Cwalina is a coworker of Jeo Duffy at the above mentioned (Microsoft) startup and also know to some of you for authoring a book about Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET [9].
Well, I can not forward you to him personally, but I like to invite to two of his record presentations:
- The first I like to forward you to the video of his A .NET developer's view of Windows 8 app development session on the last day BUILD 2011 [10].
- My second forward is to the videa of his Lecture on framework design at the Redmond’s Micrososft Research Center [11]. (There he talks about learning how to make API usable. He drop interesting insight from API usability research. For example he drops the statement "Let the usual developer fall into the pit of success via exception".
(BTW, in one of his video's sztof Cwalina states that hand coding of wrappers between .NET and WiOS -- as mentioned above -- was once his
first job at Microsoft.)
To summarize: Currently we have the situation that Microsoft with WinRT passes to the programming language world a feature requirement. These requirement are an invitation to the dylan language.
I am looking forware to 2013. With the help of all readers of this board, 2013 can become a very interesting year for the Open Dylan community.
My personal vision for 2013 is that we use this very positive initial situation at this New Year and turn it during the year into a situation, that we get a letter of acknowledgement and affirmation for our Open Source code and work.
With this vision I mind, I think we will have a better standing in 2014 and more resources for our work.
That’ s what I had in mind during writing
Supporting WinRT by the dylan language makes sense for both:
Microsoft and the Dylan Community.
in my last post.
Happy New Year 2013, Open Dylan Community
My Best Wishes,
Peter Robisch (pet-ro),
Germany, Rhine-Main Area
Postscriptum
I like to see this post be published to other channels
to attract people for the opendylan community :-)
But first I will wait for some comments to this post
on this board.
Any responds that improves content and typos of this
post are welcome.
By the way I have to admit, I also thought, it would
be nice, if someone from the dylan community applies
to Joe Duffy's job advertisement link here [4].
I send special greetings to Hannes, who is missed here
during finishing his thesis.
Thanks for Bruce for his great enthusiasm during this year.
And my a special thanks to Peter Housel for coding on things which
are import for Open Dylan's long-term future. And of course
there are some people in the background I do not know so well.
To all of you I send.
Last, but not least my best wishes to Jonathan Bachrach and
all his colleagues at Harlequin.
My Best Wishes for 2013 :-)
\ /
\---------/
\ . . /
\ . /
\ /
\ /
|
|
|
888 2013 888
-------------
- pet-ro
Links:
[1] "It is not usable if it is not functional" by Herman Venter, MS Research; published on MSDN Blog 22 May 2011.
http://blogs.msdn.com/b/hermanventer/archive/2011/05/22/it-is-not-usable-if-it-is-not-functional.aspx
[2] Blog of Joe Duffy on www.bluebytesoftware.com
http://www.bluebytesoftware.com/blog/
[3] "Blogging around the CLR", a blog entry on MSDN blogs, lists several CLR blogger back in 2005.
http://blogs.msdn.com/b/shawnfa/archive/2005/02/08/369384.aspx
[4] "Work fun" is job advertisement published in July 2012 by Joe Duffy for the startup bluebytessoftware
http://www.bluebytesoftware.com/blog/WorkFun.aspx
[5] Adam Nathan's author page on Amazon.com
http://www.amazon.com/Adam-Nathan/e/B001H6N8KK
[6] "Imperative + Functional == :-) " by Joe Duffy published on the webblog of bluebytesoftware (Dec. 8, 2012)
http://www.bluebytesoftware.com/blog/ImperativeFunctional.aspx
[7] Bruce Mitchener posting a Joe Duffy MS research paper to the Open Dylan community (Dec. 5, 2012)
https://lists.opendylan.org/pipermail/hackers/2012-December/006577.html
[8] My last post on the Open Dylan community : WinRT and dylan - first insights (Dec. 10, 2012)
https://lists.opendylan.org/pipermail/hackers/2012-December/006584.html
[9] Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET by Krzysztof Cwalina, Brad Abrams (2. Ed, 2008)
http://books.google.com/books/about/Framework_Design_Guidelines.html?id=39d1wZ598ecC&redir_esc=y
[10] Krzysztof Cwalina at BUILD 2011: "A .NET developer's view of Windows 8 app development"
http://channel9.msdn.com/Events/BUILD/BUILD2011/TOOL-930C
[11] Lecture on framework design. Given at the Redmond’s Microsoft Research Center in 2007.
http://blogs.msdn.com/b/kcwalina/archive/2007/06/01/fdglecture.aspx
Note: This provides a link to a 3 hour zipped video of ~500 MB.
Originally it online at www.researchchannel.org, but this
url has been closed.
_______________________________________________
hackers mailing list
[email protected]
https://lists.opendylan.org/mailman/listinfo/hackers