Why I love D

1. The D Programming Language Matthew Clark Power, flexibility and safety

4. Compiles into machine code (GC built-in if you use it)

5. Garbage Collection by default... if you want it

7. Throws exceptions on any error

10. Is object oriented, but no multiple inheritance from classes...

11. So use interfaces instead (inherit as many as you like)

12. Object names are references (only new if new, otherwise just another ref)

13. Object is the “root” of all objects...

15. factory(string T)[returns a new object of the type “T”]

17. foreach(command;args[1..$]) {

18. tester Test = enforce(cast(tester)Object.factory("testFactory."~command),command~" is an invalid command");

19. Test.print();

20. }

21. return 0;

22. }

23. https://gist.github.com/1015355

25. Reduces duplicate code

26. Dynamic arrays (length can be changed and any point)

27. All arrays in D are slices

28. Can read the raw memory pointer at anytime with .ptr (makes working with c-apis like opengl a joy to work with, deal with data in slice and then send into lib with .ptr, get to keep GC that way too!)

30. Are slices of chars so all the power of slices(insert, join, repeat, replace, etc) plus

31. Case manipulation (capwords, capitalize, toupper, tolower, etc.)

32. Split, strip, format, chop, chomp and cat(~=)

33. InPattern? IsNumeric? iswhite(space)? Compare?

35. Flexible - Can contain anything or just make a single function

36. As containers act almost like namespaces

37. Template Tfoo(A, B:A*) { class bar{...} enum {…} struct{...} }; Tfoo(int,int*).bar myBar;

38. C++: template<class T> int func(){ T blah;}

39. D: int func(T)(){T blah;}

41. auto nextPage = to!(string)(data[currentPlace..(currentPlace+40)]);

43. Safe unless you choose otherwise

46. Simple to use asynchronous messaging between threads(to help avoid shared memory)

48. Type.init – types init themselves to logical defaults

49. C – style – So it's easier to get used to the syntax

50. Cross-Platform – compilers for windows, osx, linux and freebsd (open source so can be ported to others!) (if you don't need GC or phobos can compile it to any platform LLVM or GCC support with LDC or GDC)

52. Delegates elegant way to do callbacks, can point to member-function(int delegate(int) dg)

53. Based on C – if all else fails and you want that much more control you can just write that part of the code in C with manual memory management and all(removes GC overhead if needed) or link to a C/C++ lib(restrictions!)

54. Non-templated functions with no parameters don't need ()s ie. MyNumber.getNumber

56. Unittesting – built in

57. Mixins – let you generate code at compile time from any string

58. Phobos – Super powerful std lib(can still use tango if you rather)

60. Object.factory, slice w/ foreach loop, enforce: https://gist.github.com/1015355

61. Simple demo of inheritance: https://gist.github.com/1014930

63. You can get code/libs at http://dsource.org/

66. Email: mclark4386@gmail.com