The threaded comments view are originally left to right. Ok, it’s the default for everything; almost every language is left to right except Persian, Hebrew, Arabic and Urdu from what I recall. So what if I want to have the threaded comments in my Persian website to look really right to left? In general terms you can find the best guidelines and tops and tricks on rtl-this.com. But what DISQUS does generating threaded comments needs attention.

Here are the possible actions one can take:

1. DISQUS supports custom CSS. You can find the appropriate stylesheet classes and override them in “Appearance” menu in DISQUS admin panel. Make sure to put a !important at the end of each attribute.
2. Alternatively you can add jQuery scripts on your site template to work this solution out on the client side. A partial approach looked like what you see in the following

// Find all li's which are children of the main comments part
// and reverse the left and right margines.
$("#dsq-comments > li").each(
function(){
var l = $(this).css("margin-left");
$(this).css("margin-right", l);
$(this).css("margin-left", "0px");
} );
// This list could continue...
$(".dsq-comment-message").css("text-align", "right");
$(".dsq-comment-message").css("direction", "rtl");
$(".dsq-comment-footer").css("direction", "rtl");
$(".dsq-comment-header").css("direction", "rtl");

I check the above script in FireBug and it worked so I just added this to my local site. I will be blogging more about this. Meanwhile I ask the DISQUS team to find a workaround for this RTL issue for such languages. Sometimes margin-left’s should change to margin-right’s.

Syntax

The grammar of C# is extended as follows:

method-modifier:
…
async_opt

lambda-expression:
async_opt anonymous-function-signature => anonymous-function-body

anonymous-method-expression:
async_opt delegate explicit-anonymous-function-signature_opt block

The async modifier is not allowed on method-declarations where the method-body is a ‘;’.

Note that async is a contextual keyword. In all syntactic contexts other than the ones above it is considered an identifier. Thus, the following is allowed (though strongly discouraged!):

using async = System.Threading.Tasks.Task;

…

async async async(async async) { }

I expect we are going to face a lot of new challenges and progresses. All the fellas from computer and science world, I hope you all a Happy New Year.

Visual Studio 2010 also ships with F# as a first class language which should gain more attention in different ways. F# takes your hand and brings you to a very practical functional environment which on top of all of its features adjusts a new way of thinking about programming in particular and software development in general. F# also speaks a new language in parallel programming. Its simple and efficient way of implementing the parallel life helps programmers and system engineers to provide better software faster; maybe it’s unusual to say but programming in F# has a very similar taste of developing the agile way. Everything you build is the result of functions interaction; growing, extending and fixing the software is just doing the same to the functions. Therefore you just need to think about the functions of the system you are trying to build and build the essential functions that make it in whole.

It seems this aspect of F# (parallel abilities) is affecting other parts of the .Net framework. C# and VB are going to support the new async programming constructs built-in and therefore we are going to have a new road ahead in the parallel land. As a system engineer/software developer, people should reconstruct their building blocks inside their software repositories. We all have a huge amount of code here and there with the biggest overhead of taking care of parallelization (if available) which could be done in a more efficient and faster way. Many different parts of the programs could run in parallel now, which we may have been implementing the usual sequential way. If we think about our pockets and we need to compete in the market, I think we all should think again and think parallel.

This Async CTP is in its early stages but I’m sure it will become an uncontrollable giant facing every one of us. Take a look at it.

(*
    bool isOdd(int n)
    {
        return ( (n%2) == 1);
    }
 
    int sqr(int n)
    {
        return n*n;
    }
 
    main(void)
    {
        for(int i = 1; i <= 10; i++)    // I know this is stupid!
            if(isOdd(i))
                printf("%d ", sqr(i));
    }
*)
 
#light

[1 .. 10]
    |> List.filter (fun n -> n % 2 = 1)
    |> List.map (fun n -> n*n)
    |> List.map (printfn "%d")

I’ve read lots of books on the topic but J.D. Meier‘s book is different. It’s more exciting when you could read the book online on this address. Thank you J.D.

I had many ideas for him ready in my pocket about the architecture and even the object model suitable for the project but when it came to the point of programming language I just had a second thought. It was somehow strange for me not to shout out C# or C++.

As you may have noticed from my initial post in this weblog, it’s been a while I was exploring different aspects of F# which is amazingly beautiful, straightforward, succinct and functional. I guess this whole F# thing is playing my head; you know why? Because it took me about 8 hours to write down a prototype of my idea about my friend’s project and about half an hour to make it real. I’m so much excited about this and it’s killing me to check with him, cause I’m not sure if it’s ok to publish the code.

By the way, what took me to the point of implementing a “blah blah simulator” in F# was curiosity at first, but the precise functional attributes of F# with the help of its active pattern and agents ended up in heaven. You may follow this story on my next one or two posts here by the subject of “F# and simulation strategies”.

let greeting = “Hello, World!”
printfn “%s” greeting

I’ll get into more detail in my future posts.