End user experience with D

[Ludovit Lucenic]

Hello everybody,

I read this very lively Manu's thread (Had another 48hr game jam 
this weekend..., 
http://forum.dlang.org/thread/mailman.680.1378001151.1719.digitalmars-d@puremagic.com) 
and am about to share my own D experience as someone who 
discovered D less than a year ago looking for a useful 
alternative to nowadays standards.

I'd like to point out that the thoughts I write here form an 
essay rather than some well structured discussion contribution. 
However, please read on and you may find it interesting after all.

Imagine someone (a developer/programmer or a software engineer) 
being in a search for something that is more appropriate to 
address his professional needs. Someone who do this on his own, 
is genuinely interested in software science, has something to 
offer and who understands the corporate motivations behind all 
the fancy languages/frameworks (most of which are not free/libre 
software at all) that have all the design-shortcomings that are 
20+ years old. And (in contrast with corporate attitude) someone 
who as a human being seeks inner fulfilment in exchange of mutual 
respect, results, in learning and support.

But from the beginning. In my most recent job I lead development 
of a platform that enables better software design using a 
complete new approach (or paradigm) based on encapsulating 
software components into so called configurations or 
configuration patterns, while having all the OOP-like features as 
inheritance, polymorphism etc. in this (configuration) dimension 
as well. The inventor of the idea behind this concept had found 
investors that make an effort to make big business out of this 
here in Slovakia. I feel lucky I have had this opportunity of 
being a part of this endeavour since its to-mature phase. But as 
the time passed by I realized I felt tired of being in restraint 
of the fear of "the idea cannot leak or even losing the platform 
implementation" that was constantly imprinted upon us. As such, 
it had many impacts on our proficiency as software engineers. So 
I quit this job.

A couple of months before I have decided to resign I had tried to 
prove the concept of what we've been dealing with in the company 
in some technology other than Java and its servlets engine. I 
studied the current possibilities and that was the point I came 
to know D. I ever thought that some lower level approach, no VMs 
and some language constructs would outperform the implementation 
of this 'code the architecture with software component 
configurations' concept in Java we had, though it was a decent 
one.

To explain a little more on how my intention relates to D, I dare 
to claim that this new paradigm has potential of becoming next 
standard in software architecture design. Especially for larger 
projects. It will definitively address at least two of the three 
major goals of D Walter spoke about in his DConf intro talk this 
year: large scale project support (in this case: on architectural 
level) and the performance D would lend to this paradigm would 
ensure industry quality of modern systems.

After reading Andrei's book I sat down to computer and it took me 
about 5 man-days to design and program this concept in D. No 
previous experience with D at all. Technically, it was about an 
engine interpreting tree (stored e.g. in XML), where the target 
software application had stored its architecture. Polymorphism, 
hierarchy and everything on level of configuration patterns. 
Awesome. Actually this experience contributed to my ultimate 
decision on quitting :-) Walter et al., please be aware of how 
your work does change people's careers and lives :-D

To get that far I needed a web server in D. Technically, it was 
not necessary, but it might had been convenient as I was 
accustomed to the web interface for this platform. I have read 
everything that was at hand at that time and ended up with that 
only Mango would suite my needs the best. It 'just' needed to 
port it from D1 to D2. Somehow neither Adam D. Ruppe's web stuff 
nor vibe.d server were not able to target my intention to have 
latest D2 compiler support (Dec 2012/Jan 2013) and so did 
anything else I might have found. The mission also was to compile 
the tango on my Ubuntu, than to port and compile mango, link it 
with tango, create my own project and compile and link it with 
these libraries. While doing this I came across all the notorious 
in the community: dead dsource.org, only D1 version of majority 
of D code I could use, phobos vs. tango incompatibility and so 
on... Real pain that substituted the initial enthusiasm I felt 
almost instantly about D as a software engineer by heart. But my 
conviction to go on was stronger...

The first thing before I get into coding in D was desperately 
looking for an IDE. From my experience, Eclipse and Visual Studio 
have learned me to such comfort. In this case though it was not 
only about the comfort. The concept rely on some higher level of 
abstraction that even takes time to visualize in mind, not 
speaking about track in the code without using decoded memory. 
Getting 0x00FE67ED in debugger instead of a dynamic class 
instance with some details on some interface parameter or local 
variable, not speaking of global variables is just no-go.
I had three computers at my disposal at that time, two with 
Ubuntu and one with Windows 7, later upgraded to 8. I tried 
everything I found: Code::Blocks plugin, DDT, VisualD, Mono-D and 
maybe some others. I was looking for an eclipse-like debugging 
experience the people familiar with Java have. Desperately: 
WinDBG, Mago, Visual Studio Debugger, MonoDevelop.Debugger.GDB, 
CLI of GDB. No way except for DIY.

In order to at least finish my proof-of-concept project I chose 
Mono-D and contacted Alexander Bothe asking him for support in 
assistance with building a GDB add-in for MonoDevelop that would 
support D (I mean useful support, not the declared one in GDB 
announcements). The results of the joint effort, by the way, is 
at my GitHub 
(https://github.com/llucenic/MonoDevelop.Debugger.Gdb.D). I 
recently started a new job, where I am to switch to Windows 
platform (please keep this in mind ! people may change the 
platform along the career roads, even if their preference stays 
the same - free software in my case). After, it took me a while 
until I managed to update the Gdb.D Mono-D add-in in order to be 
used in a Xamarin Studio (MonoDevelop successor) along with 
Mono-D on Windows. When I got that far I came to the point that 
DMD on Windows does not generate debug info that GDB can read and 
make use of. So I started to get working executable of GDC and/or 
LDC as alternatives that should be (at least in theory) capable 
of cooperation with GDB on Windows. None of these efforts have 
been successful so far, the details of which we discuss in GDC 
and LDC forums respectively.

All in all, to sum things up I list all my fundamental show 
stoppers so far:
  1) only D1 version of majority of D code I could use, phobos vs. 
tango incompatibility, ... (valid for January 2013)
  2) missing IDE - comfort and primarily handling higher level 
abstraction necessity,
  3) debugger not capable of basic memory interpretation - as 
said, interface/class instances visualized just as memory address,
  4) GDB not working with DMD on Windows,
  5) not able to compile GDC on Windows,
  6) LDC complaining a lot of linkage errors when integrated in 
Xamarin Studio (with Mono-D) on Windows (not tried on Unix)

I am addressing these issues on their respective forums in 
particular, just need comment on the show stopper number 4. Why 
is it not possible, or what would it take to support GDB debug 
info format in DMD back-end on Windows ?

These issues are basically hindering me immensely in achieving my 
ultimate goal, which I think may contribute essentially to the D 
coming up.
I am enthusiastic about D, but I cannot estimate how long it will 
take until all this confusion and obstacles roll over me :-)
Hope it never happens, but I will definitively need a lot of 
support and help with making my intention reality.

After all, I consider this D community is pretty much about 
philosophy. I value highly (actually, one of my major reasons to 
go for D) Walter's motivation on creating a language out of love. 
Although, there surely is some pragmatic aspect in all this as 
well. And this makes D so special (at least for me).
When we get older, at some time we are going to pose the 
question: 'Did it all make sense ?" I guess with this language we 
say: 'it Did'

I wish you found this posting at least of some value.
Thank you for your time.

Kind regards,
Ludovit