Parallel Axiom

Any type of communication can be encrypted. It may not always make sense to do so but a lot of times it does.

ZeroMQ does not currently support Transport Layer Security ( TLS ) natively but a couple of efforts have been started by different people.

I found a very good read on TLS encryption over ZeroMQ by Ian Barber Here.

While playing around with cling I thought I may want to try to get ZeroMQ compiled using clang.

I run into a couple of issues initially due to the missing Gold plugin, and the gold linker on my system. To get around it I decided to reduce the optimization level while compiling ZeroMQ and I used the following environment variables:

export BASE_PATH=$HOME/bin/opt

export PREFIX=$BASE_PATH
export PATH="$PREFIX/bin:$PATH"
export CC=clang
export CXX=clang++
export RANLIB=/bin/true

I found some interesting links to performance specs for CINT Here and Here

These look not too good wrt execution speed but since ROOT is now moving towards cling, the llvm based C/C++ interpreter there is a good chance that these performance values will improve on top of making the interpreted language C++11 compliant.

I found the instructions on how to properly build cling on your system quite confusing. So below is what I had to do to get cling to compile.

This one is off topic but I think it is a good reflection of why I believe we need a better way of programming in a distributed manner.

The video has had a couple of whoa - moments for me. The first was when light travels through the bottle, and the second one was towards the end when einsteins equations were applied to resolve the distortions of view.

Now I've seen computer animations of relativity distortions. This one just blew my mind.

Here you have some completely legal C++11 lambda functions.

  []{};
  []{}();
  [](){}();
  []()->int{}();
  []()throw()->int{}();
  [this]()throw()->int{}();
  try{[this]()throw()->bool{}();}catch (...){};

Have you noticed that the last line sounds like playing baseball ...

So aside from the strange signature, Lambda functions are a welcome addition to C++. Almost akin to what I would want for the Dynamic Language Extension.

While working on llvm to get some features off the ground I found the following blog to be noteworthy.
Future Chips

A very good example of the value of it is the following blog-entry about the best task size to maximize concurrency.
How to choose the best task-size

The blog is written by Dr. Aater Suleman who is very passionate about the subject.

There is currently no packaged source available and you will have to obtain the code through svn.

First make sure you have the llvm, and clang source code on in place by following
http://clang.llvm.org/get_started.html

then switch into the base clang directory

  cd llvm/tools/clang

and obtain the pcc source through

  svn co http://svn.ParallelAxiom.com/pcc pcc

You should first compile llvm, which will automatically compile clang.

Then you need to change to

  cd llvm/tools/clang/pcc
  make

While the first part of the Dynamic Language Extension seemed fairly clear to me, it is in the eye of the beholder.

So I have received some feedback and a request for clarification about the approach. I will try to take apart one example here to give a better understanding. So please stick with me for the ride.

Introduction:
A compiler consists of two main parts.

Looking at the progression of C++ and how people use this language seems to indicate that more and more template based libraries appear and are being developed.

And why not. Templates are extremely useful, flexible, powerful.

Flexible is here the main driving force. Templates allow the programmer to be resourceful and let the compiler generate a lot of code that he would have to manually create otherwise.

New and improved C++.

The new C++0x standard by all means should be renamed to C++1x. So after a delay of 10 years, it seems that finally it is coming around in 2011.

Problem is: It does little to address todays programming environments.

So let's take a look at the newly introduced threading.

The new standard introduces the amazingly improved threading paradigm of :

#include <thread>

void dummy() {}

int main(int, char*[]) {