OSDev.org

Hello,

I just learned about D Programming Language from the Google and it seems like it is a cool language. Do anyone in here know more about D Programming Language? Can it be done write kernel/OS in D? To me, it has the nice OOP (Object Oriented) and other options so far from what I have read.

http://www.digitalmars.com/d/
http://www.digitalmars.com/d/comparison.html

Too bad, the core is closed that avoid others to port in the different OS. Does this avoid to write kernel/OS in D?

Just right time, there has a recently nice article about it over at OSNews.com.

http://www.osnews.com/story.php?news_id=6761

Also, he pointed that there has a very nice white paper.

http://www.digitalmars.com/d/sdwest/paper.html

Looks like not many people know about D in here.

actually, i'm a fan of pre-processing, so i have some kind of ... resistance ... in learning D

Pype.Clicker wrote: actually, i'm a fan of pre-processing, so i have some kind of ... resistance ... in learning D

You can always still use the standalone version of cpp... though you'd have to inform anyone else who uses it about that first.

Also, if you are going that route, you might as well use a more powerful macro preprocessor, such as m4, or even one of your own devising. Though I suppose there could be some conflicts, and it would mean learning yeat another new language to do so.

Of course, macros are one of the great things about Lisp and Scheme (hey, I had to get a plug in for my favorite, didn't I?), though in the latter case the official 'hygenic' macro system is a subject of controversy - powerful, but with certain intentional restrictions and an overly verbose syntax. OTOH, the more traditional Common Lisp macro system can seem pretty arcane when you first run into it, and can be harder to learn how to read. Go figure.

If one likes preprosessing, then Lisp macros are like heaven. There are many opinions about 'hygienic' Scheme macros, but most of them are either 'but they are safer' or 'they suck in power'.

The 'true' Lisp macros in the form of 'defmacro' in Common Lisp act like functions, but which are evaluated at compile-time, and instead of receiving values of evaluated arguments, they receive the actual lisp-data representing the source-code written within the macro call. Macros can use the whole Lisp language, and they return some other piece of Lisp-data representing code, which is then evaluated/compiled in the place of the macro call. If this code contains macros, those are then used to futher transform the code.

Since in Lisp code and data are both just list-structures, macros can be used to transform these list-structures in any way. Implementing new control-structures, mini-languages with completely different semantics, or almost anything else is possible with macros. In a sense, every macro is a small compiler.

Lisp macros really have nothing to do with textual macros like those in C. They are Lisp functions used to transform Lisp code.