View mode: basic / threaded / horizontal-split · Log in · Help
July 21, 2012
OSCON 2012 notes
I'm back from OSCON 2012, where my talk has enjoyed a somewhat 
unexpected good reception (OSCON is not the most down-D's-alley audience).

The talk abstract is at 
http://www.oscon.com/oscon2012/public/schedule/detail/23888 and the 
slides are at 
http://www.slideshare.net/andreialexandrescu1/generic-programming-galore-using-d. 
There will be a video up some time in the future for the entire talk.

It would be really cool if we could enhance D's offering in the Web 
arena. People were really attracted by the notion of a language not 
requiring many type annotations, yet with the exploratory feel of a 
dynamic language. A small framework or simply a couple of standard 
library components that would make e.g. Vladimir's work (on 
forum.lang.org) or Adam Ruppe's work easy to assemble from preexisting 
parts would be just awesome.

Go has enjoyed a stronger presence in numbers: 
http://www.oscon.com/oscon2012/public/schedule/detail/23910, 
http://www.oscon.com/oscon2012/public/schedule/detail/23906, but my 
perception (confirmed by ratings) is that the reception has been a tad 
colder.


Cheers,

Andrei
July 21, 2012
Re: OSCON 2012 notes
Am 21.07.2012 07:14, schrieb Andrei Alexandrescu:
> I'm back from OSCON 2012, where my talk has enjoyed a somewhat
> unexpected good reception (OSCON is not the most down-D's-alley audience).
>
> The talk abstract is at
> http://www.oscon.com/oscon2012/public/schedule/detail/23888 and the
> slides are at
> http://www.slideshare.net/andreialexandrescu1/generic-programming-galore-using-d.
> There will be a video up some time in the future for the entire talk.
>

Thanks for putting them up. Eagerly waiting for the video.

> It would be really cool if we could enhance D's offering in the Web
> arena. People were really attracted by the notion of a language not
> requiring many type annotations, yet with the exploratory feel of a
> dynamic language. A small framework or simply a couple of standard
> library components that would make e.g. Vladimir's work (on
> forum.lang.org) or Adam Ruppe's work easy to assemble from preexisting
> parts would be just awesome.

We need something like std.database for web development, which as far as
I know is currently on hold.

WinRT support would also be a nice feature. Need to spend some time 
checking how to work with type libraries.

>
> Go has enjoyed a stronger presence in numbers:
> http://www.oscon.com/oscon2012/public/schedule/detail/23910,
> http://www.oscon.com/oscon2012/public/schedule/detail/23906, but my
> perception (confirmed by ratings) is that the reception has been a tad
> colder.
>

Go earns a lot of brownie points from geeks due to Google factor and 
having Plan 9 authors in the team.

I've watched most of their presentations, to be honest their typical web 
application PR demo with goroutines, can be easily reproduced in many 
languages.

Even the features that are sold as why one should pick Go, are no
novelty for the developers that have good CS backgrounds in compiler
design and implementation.

I already had many discussions on gonuts regarding lack of abstractions 
in the language like enumerations and generics, or the distinction 
between make and new.

The Go community seems to think it is ok to make use of code generation 
tools, like the C++ compiler vendors used to do until around 1993,
when preprocessor tricks and external tools were used as a kind of generics.

With Go 2, years away this situation is hardly going to change.

After becoming disapointed with Go leaving in the past, I've come to the 
conclusion that between the two, D is a much better choice.

--
Paulo
July 21, 2012
Re: OSCON 2012 notes
On Saturday, July 21, 2012 08:48:57 Paulo Pinto wrote:
> After becoming disapointed with Go leaving in the past, I've come to the
> conclusion that between the two, D is a much better choice.

I still need to study up on Go one of these days (along with a variety of 
other languages which are on my to-learn list), but the more I learn about it, 
the less I understand why Go and D are treated as competitors. I guess it's 
because of the systems language moniker (though Go doesn't mean it in the same 
was as C++ and D, so that skews things already), but Go and D are just so 
radically different in their basic approaches and philosophies, that I would 
expect that the folks who like one would dislike the other in most cases. 
They're just so completely different that I wouldn't expect them to really 
compete with one another save for the fact that developers only have so much 
time to check out new languages, so if one's getting a lot more attention, 
that could reduce how many people check out the other one, even if most people 
who check out the first one don't end up liking it.

- Jonathan M Davis
July 21, 2012
Re: OSCON 2012 notes
Am 21.07.2012 10:20, schrieb Jonathan M Davis:
> On Saturday, July 21, 2012 08:48:57 Paulo Pinto wrote:
>> After becoming disapointed with Go leaving in the past, I've come to the
>> conclusion that between the two, D is a much better choice.
>
> I still need to study up on Go one of these days (along with a variety of
> other languages which are on my to-learn list), but the more I learn about it,
> the less I understand why Go and D are treated as competitors. I guess it's
> because of the systems language moniker (though Go doesn't mean it in the same
> was as C++ and D, so that skews things already), but Go and D are just so
> radically different in their basic approaches and philosophies, that I would
> expect that the folks who like one would dislike the other in most cases.
> They're just so completely different that I wouldn't expect them to really
> compete with one another save for the fact that developers only have so much
> time to check out new languages, so if one's getting a lot more attention,
> that could reduce how many people check out the other one, even if most people
> who check out the first one don't end up liking it.
>
> - Jonathan M Davis


Go is an evolution of Limbo 
(http://www.vitanuova.com/inferno/limbo.html), where ADTs got replaced 
by interfaces coupled with method declarations syntax from Component 
Pascal (http://www.oberon.ch/pdf/CP-Lang.pdf), an extension to Oberon.

If you spend some time reading Inferno and Limbo documentation after 
learning Go, you'll see how they share so many concepts.

http://doc.cat-v.org/inferno/books/inferno_programming_with_limbo/

Regarding systems programming, Go could actually play in the same league 
as D, since Oberon was used to write the Native Oberon and A2 operating 
systems. Besides the assembly for the GC and boot, everything else is 
written in Oberon.

As a personal workstation the system was used a lot by the ETHZ 
researchers during the 90's. A quite cool environment where you get a 
Smalltalk like environment, with a strong typed language.

Nowadays it is mainly used to teach OS principles at ETHZ, and embedded 
systems development.

You can read more it here,
http://www.ethoberon.ethz.ch/native/WebScreen.html        (screenshots)
http://www.ethoberon.ethz.ch/WirthPubl/ProjectOberon.pdf  (how it was 
implemented)
http://www.astrobe.com/Oberon.htm (embedded systems support)

The trick with Oberon, which Go also uses, is to have a special module
reckognised by the compiler with primitives to do the low tricks C 
offers. Additionaly any function/method without body can be implemented 
in Assembly. This is nothing new, Modula-2 already worked like this.

What I miss from Go, and is what makes me like more of D is,

- enumerations
- exceptions
- metaprogramming
- generics
- dynamic loading
- constness
- operator overloading
- method overloading
- support for FP

Basically everything that has become part of the enterprise world since
the late 90's.

Wirth has a nice paper where we describes the evolution of the languages 
he designed, stating on the chapter 7, that Oberon failed in the 
industry because companies preferred the code bloat of other languages 
instead of Oberon's simplicity.

http://www.inf.ethz.ch/personal/wirth/Articles/Modula-Oberon-June.pdf

This is exactly the same school of thought that Go designers follow. If
language design would be considered art, they would probably be part of
the Minimalism mouvement.

--
Paulo
July 21, 2012
Re: OSCON 2012 notes
On 2012-07-21 06:48:57 +0000, Paulo Pinto <pjmlp@progtools.org> said:

> We need something like std.database for web development, which as far as
> I know is currently on hold.
> 
> WinRT support would also be a nice feature. Need to spend some time 
> checking how to work with type libraries.

The web is a low-hanging fruit for D. The language is already very 
suitable for it: being able to talk to C APIs, socket IO, and starting 
external processes plenty enough. All it needs really is some library 
code.

Supporting WinRT, or Cocoa, in any pleasant way is a much bigger 
project. Both these APIs use OO extensively and, while they are 
accessible from C, dealing with such code using C functions is a pain. 
I'm convinced that what D needs is direct support for new object models 
in the language. The good news is that semantically both the WinRT 
model and the Cocoa model of an object are close enough to the D model 
-- single inheritance, one root object -- and I've shown with my 
experimental DMD/Objective-C branch[1] that such a model integrates 
quite well to D despite the differences. In fact, WinRT, being based on 
COM, would probably map better than Cocoa.

[1]: http://michelf.ca/projects/d-objc/

So in short, to be successful in GUI development, D need to support the 
native object model of the GUI platform it runs on without having to 
jump through hoops and without having a complicated layer of bindings. 
Using D code within a GUI app should be as easy as using C++ code 
within it would be. Otherwise, you cannot really compete.

And also, more and more it'd require ARM support to be competitive in 
the GUI area.

Compare those requirements to those of web development, were almost all 
servers are x86, where C, socket IO, and execution of external 
processes is all that's needed interface with other components, and 
you'll see that web dev is truly the low-hanging fruit in terms of 
market for D.

-- 
Michel Fortin
michel.fortin@michelf.ca
http://michelf.ca/
July 21, 2012
Re: OSCON 2012 notes
On Saturday, 21 July 2012 at 13:47:06 UTC, Michel Fortin wrote:
> The web is a low-hanging fruit for D.

Yea, I've been eating that fruit for years.

While my libs are out there, I haven't gotten around to
doing the rest of the documentation or anything. My libraries
are just a means to an end to me. They get the job done, so
I focus on the job, and then I have other stuff the rest of
my time.

But there's people who have used my libs regardless so if
you are interested, here it is:

https://github.com/adamdruppe/misc-stuff-including-D-programming-language-web-stuff
July 21, 2012
Re: OSCON 2012 notes
On 7/21/12 10:08 AM, Adam D. Ruppe wrote:
> On Saturday, 21 July 2012 at 13:47:06 UTC, Michel Fortin wrote:
>> The web is a low-hanging fruit for D.
>
> Yea, I've been eating that fruit for years.
>
> While my libs are out there, I haven't gotten around to
> doing the rest of the documentation or anything. My libraries
> are just a means to an end to me. They get the job done, so
> I focus on the job, and then I have other stuff the rest of
> my time.
>
> But there's people who have used my libs regardless so if
> you are interested, here it is:
>
> https://github.com/adamdruppe/misc-stuff-including-D-programming-language-web-stuff

Would you agree if someone took your code, modified it for the purposes 
of passing it through the forks of the review process, and pushed it 
into Phobos?

You'd still receive credit, of course, but it would be shared with that 
person or group because that's significant work.

Let us know - thanks!


Andrei
July 21, 2012
Re: OSCON 2012 notes
On Sat, 21 Jul 2012 09:47:06 -0400
Michel Fortin <michel.fortin@michelf.ca> wrote:
> 
> And also, more and more it'd require ARM support to be competitive in 
> the GUI area.
> 

Yes. But there's an even bigger reason for ARM: Mobile devices, like
iOS and Android. I'm not personally a fan of them, but nonetheless those
things are HUGE (no pun intended). And yet the ONLY real language
choices there are C++, Java and Objective-C (and Lua if you count
"Son-of-Flash", ie Corona - which I don't count). And half of THOSE are
out of the question if you want cross platform, which any sane developer
should. So PERFECT fertile ground for D.

I know I keep harping on that, but it's a big issue for me since I'm
deep into that stuff now and goddamn do I wish I could be doing
it in D, but D's support on those devices (or just outputting C/C++)
unfortunately just isn't mature enough ATM.
July 21, 2012
Re: OSCON 2012 notes
On 7/21/12 1:14 AM, Andrei Alexandrescu wrote:
> I'm back from OSCON 2012, where my talk has enjoyed a somewhat
> unexpected good reception (OSCON is not the most down-D's-alley audience).
>
> The talk abstract is at
> http://www.oscon.com/oscon2012/public/schedule/detail/23888 and the
> slides are at
> http://www.slideshare.net/andreialexandrescu1/generic-programming-galore-using-d.
> There will be a video up some time in the future for the entire talk.

Slides are being discussed on reddit: 
http://www.reddit.com/r/programming/comments/wxjv0/generic_programming_galore_using_d/

Andrei
July 21, 2012
Re: OSCON 2012 notes
On 21-07-2012 21:51, Nick Sabalausky wrote:
> On Sat, 21 Jul 2012 09:47:06 -0400
> Michel Fortin <michel.fortin@michelf.ca> wrote:
>>
>> And also, more and more it'd require ARM support to be competitive in
>> the GUI area.
>>
>
> Yes. But there's an even bigger reason for ARM: Mobile devices, like
> iOS and Android. I'm not personally a fan of them, but nonetheless those
> things are HUGE (no pun intended). And yet the ONLY real language
> choices there are C++, Java and Objective-C (and Lua if you count
> "Son-of-Flash", ie Corona - which I don't count). And half of THOSE are
> out of the question if you want cross platform, which any sane developer
> should. So PERFECT fertile ground for D.

... and C# ;)

>
> I know I keep harping on that, but it's a big issue for me since I'm
> deep into that stuff now and goddamn do I wish I could be doing
> it in D, but D's support on those devices (or just outputting C/C++)
> unfortunately just isn't mature enough ATM.
>

GDC is pretty far along as far as ARM support goes; I intend to have 
another run through it one of these days to look at any remaining issues.

-- 
Alex Rønne Petersen
alex@lycus.org
http://lycus.org
« First   ‹ Prev
1 2 3 4 5
Top | Discussion index | About this forum | D home