Hello everybody,
I read this very lively Manu's thread (Had another 48hr game jam
this weekend...,
http://forum.dlang.org/thread/[email protected])
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
