Le blog à Fred

Balancing bullshits

2013-04-19T14:22:00+02:00

After spreading bullshits, our Bullshit Company has been overflown by bullshit requests.
It's time to provide a bigger architecture than the one we used. Let's balance the Bullshit Generator.

For the impatients, this post will deal with several problems that a beginner could encounter or fear : exceptions handling and sequences

After dealing with millions of requests, our CBSG server was unable to answer to all of these.
A solution is to provide a load balancing CBSG.
To do this, we planned to dispatch several CBSG servants on different machines. These servants will have to register themselves to a CBSGBalancer.%%
Let's start with IDL.
We add the following at the end of our previous file:

// This exception is thrown when a client is asking for a CBSG
  //And no more are available
  exception NoMoreCBSGAvailable
  {
  };
 
  //This exception is thrown when a servant tries to unregister
  //itself and that a client still uses it
  exception CBSGInUse
  {
  };
 
  typedef sequence<CBSG> CBSGSeq;
 
  //Our load-balancing object
  interface CBSGBalancer{
    //This method allows to register a new servant to put in the balancer
    void register(in CBSG newServant);
 
    //This method should be called when a servant is shut down
    void unregister(in CBSG servantToRemove) raises (CBSGInUse);
 
    //This method is for client wanting to use a CBSG
    CBSG reserve() raises (NoMoreCBSGAvailable);
 
    //This method allows a client to reserve several CBSG
    //Less than the parameter could be returned depending on the number available
    //The exception is thrown when none can be returned
    CBSGSeq reserveSeveral(in long numberToReserve) raises (NoMoreCBSGAvailable);
 
    //This method must be called by client to 
    //release a previously reserved CBSG
    void release(in CBSG noMoreUsedCBSG);
  };

The IDL code is self-explanatory and reflects what we described before.
Take care of keeping your last *-impl.ad[sb] as the generation will overwrite them^[1].
We generate Ada code from it like in the previous post:

fred@coruscant :~/cbsg/corba/Ada $ iac -i ../idl/cbsg.idl

Ok, now, we have to write the code of our balancer.

The Balancer

First of all, let's modify the spec :

--[snip...]
   function "=" (Left, Right : CorbaCBSG.CBSG.Ref) return Boolean;
 
private
   package Ref_Vectors is new Ada.Containers.Vectors(Index_Type => Positive,
						     Element_Type => CorbaCBSG.CBSG.Ref
						    );
 
   type Object is
     new PortableServer.Servant_Base with record
	Usable_Refs : Ref_Vectors.Vector;
	In_Use_Refs : Ref_Vectors.Vector;
      end record;
--[snip...]

We will use a standard Ada Vector to keep our CBSG servants. As a consequence, we need a way to test equality on CBSG references.
As you can see, we use to vectors for this. This is easy, one for available servants and the other for busy ones.
Now, here's the implementation. First, the register method :

procedure register
     (Self : not null access Object;
      newServant : CorbaCBSG.CBSG.Ref)
   is
   begin
      Ref_Vectors.Append(Self.Usable_Refs, NewServant);
      Put_Line("A servant was registered");
      Put_Line("It corbaloc is " & To_Standard_String(PolyORB.CORBA_P.CORBALOC.Object_To_Corbaloc(NewServant)));
   end register;

In fact, we will not receive CBSG servants directly but references to them^[2].
We simply add the reference to our vector.
As in every quick and dirty code, we use standard output for logging :D
Off course, using Alog, GNATCOLL or whatever logging framework would be smarter.
After registering, we need unregistering

procedure unregister
     (Self : not null access Object;
      servantToRemove : CorbaCBSG.CBSG.Ref)
   is
      Index : Ref_Vectors.Cursor;
   begin
      -- first, test if present in usable
      index := Ref_Vectors.Find(Self.Usable_Refs, ServantToRemove);
      if (Index /= Ref_Vectors.No_Element) then
	 Ref_Vectors.Delete(Self.Usable_Refs, Index);
      else
	 raise CBSGInUse;
      end if;
   end unregister;

We simply remove from the vector where it's referenced... Well, this could be better as we can imagine that the servant which is unregistering would probably quit anyway but reliability is not part of this post :)
As you could have seen exceptions in CORBA are just plain old Ada exceptions. That's all !!!

function reserve
     (Self : not null access Object)
     return CorbaCBSG.CBSG.Ref
   is
      First_Cursor : Ref_Vectors.Cursor := Ref_Vectors.First(Self.Usable_Refs);
      Returned_Ref : CorbaCBSG.CBSG.Ref;
   begin
      if (First_Cursor /= Ref_Vectors.No_Element) then
	 Returned_ref := Ref_Vectors.Element(First_Cursor);
	 Put_Line("Sending " & To_Standard_String(PolyORB.CORBA_P.CORBALOC.Object_To_Corbaloc(Returned_Ref)));
 
	 -- we put it in use
	 Ref_Vectors.Append(Self.In_Use_Refs, Ref_Vectors.Element(First_Cursor));
	 -- we remove it from usable
	 Ref_Vectors.Delete(Self.Usable_Refs, First_Cursor);
      else
	 raise NoMoreCBSGAvailable;
      end if;
      return Returned_Ref;
   end reserve;

Now what about sequences we use in reserveSeveral?
Well, it's more complicated than in other languages but let's check.
In our case as sequence is a typedef in our package, the specification is in corbacbsg.ads

--snip
   package CBSG_Forward is
     new CORBA.Forward;
 
--snip
   package IDL_SEQUENCE_CorbaCBSG_CBSG_Forward is
     new CORBA.Sequences.Unbounded
        (CorbaCBSG.CBSG_Forward.Ref);
 
   type CBSGSeq is
     new CorbaCBSG.IDL_SEQUENCE_CorbaCBSG_CBSG_Forward.Sequence;
--snip

In fact, in PolyORB, sequences don't contain directly our object but an adapter object called Forward as explain on Khotar Labs blog. So we won't be able to return a reference array but an array of forward objects containing references.
As sequences are instanciations of CORBA.Sequences.Unbounded generic package which in fact are PolyORB.Sequences.Unbounded, all we need is in the polyorb-sequences-unbounded.ads file.

--snip
   function reserveSeveral
     (Self : not null access Object;
      NumberToReserve : CORBA.Long)
     return CorbaCBSG.CBSGSeq
   is
      use CorbaCBSG.CBSG.Convert_Forward;
 
      Returned_Seq : CorbaCBSG.CBSGSeq;
   begin
      for Index in 1..NumberToReserve loop
	 begin
	    Append(Returned_Seq, 
		   To_Forward(
			      Reserve(Self)
			     ));
	 exception
	    when NoMoreCBSGAvailable =>
	       if (Index = 1) then
		  raise;
	       else
		  exit;
	       end if;
	 end;
      end loop;
 
      return Returned_Seq;
   end reserveSeveral;
--snip

In order to convert our objects into forward objects, we need to use the To_Forward function. This function is defined as a package called Convert_Forward in the file representing the object to store. In our case, it will be in CorbaCBSG-cbsg.ads.
Once the object has been converted, we can put it in our sequence using Append... Easy :)
Well, this implementation is not really great as it can return fewer references than requested but it conforms to our spec in the IDL file ;)

Finally, the release function is quite simple.

procedure release
     (Self : not null access Object;
      noMoreUsedCBSG : CorbaCBSG.CBSG.Ref)
   is
      In_Use_Cursor : Ref_Vectors.Cursor := Ref_Vectors.Find(Self.In_Use_Refs, noMoreUsedCBSG);
   begin
      -- we remove it from in use vector if present
      if (In_Use_Cursor /= Ref_Vectors.No_Element) then
	 Ref_Vectors.Delete(Self.In_Use_Refs, In_Use_Cursor);
	 Ref_Vectors.Append(Self.Usable_Refs, NoMoreUsedCBSG);
      end if;
   end release;

The last function to implement is the equality for our objects. As Corbaloc are unique, the test only deals with this :

function "=" (Left, Right : CorbaCBSG.CBSG.Ref) return Boolean
   is
   begin
      if (PolyORB.CORBA_P.CORBALOC.Object_To_Corbaloc(left) = PolyORB.CORBA_P.CORBALOC.Object_To_Corbaloc(right)) then
	 return True;
      else
	 return False;
      end if;
   end "=";

Our servant is implemented, so it's time to expose it :

with Ada.Exceptions;
with Ada.Text_IO; use Ada.Text_IO;
 
with CORBA.Impl;
with CORBA.Object;
with CORBA.ORB;
 
with PortableServer.POA.Helper;
with PortableServer.POAManager;
 
with CorbaCBSG.CBSGBalancer.Impl;
 
with PolyORB.CORBA_P.CORBALOC;
 
-- allows to specify to PolyORB how to run
with PolyORB.Setup.No_Tasking_Server;
pragma Warnings (Off, PolyORB.Setup.No_Tasking_Server);
 
procedure Balancer is
begin
 
   declare
      -- We retrieve paramaters defined in CORBA standard such a InitialRef
      Argv : CORBA.ORB.Arg_List := CORBA.ORB.Command_Line_Arguments;
 
   begin
      -- We initialize our bus as ORB
      CORBA.ORB.Init (CORBA.ORB.To_CORBA_String ("ORB"), Argv);
 
      declare
	 -- The PortableObjectAdapter is where we store our objects
         Root_POA : PortableServer.POA.Local_Ref;
 
	 -- we declare a reference on it
         Ref : CORBA.Object.Ref;
 
	 -- and its implementation
         Obj : constant CORBA.Impl.Object_Ptr := new CorbaCBSG.CBSGBalancer.Impl.Object;
 
      begin
 
	 -- Get the root POA
         Root_POA := PortableServer.POA.Helper.To_Local_Ref
           (CORBA.ORB.Resolve_Initial_References
	      (CORBA.ORB.To_CORBA_String ("RootPOA")));
 
	 -- Start it
         PortableServer.POAManager.Activate
           (PortableServer.POA.Get_The_POAManager (Root_POA));
 
	 -- Create a reference in the POA
         Ref := PortableServer.POA.Servant_To_Reference
           (Root_POA, PortableServer.Servant (Obj));
 
	 -- Display the IOR
         Put_Line
           ("'"
	      & CORBA.To_Standard_String (CORBA.Object.Object_To_String (Ref))
	      & "'");
         New_Line;
 
         --  and the corbaloc
         Put_Line
           ("'"
	      & CORBA.To_Standard_String
	      (PolyORB.CORBA_P.CORBALOC.Object_To_Corbaloc (Ref))
	      & "'");
 
         --  Launch the server. CORBA.ORB.Run is supposed to never return,
         --  print a message if it does.
 
         CORBA.ORB.Run;
 
         Put_Line ("ORB main loop terminated!");
      end;
   end;
exception
   when E : others =>
      Put_Line
        ("CBSG Balancer server raised " & Ada.Exceptions.Exception_Information (E));
      raise;
end Balancer;

There's nothing special to say about it, so we go on with the CBSG that will register to the balancer

The registering CBSG

In fact, our previously implemented CBSG is still usable without any modification. The only thing we have to do is to change the way we launch it.
This time, we will also need a reference to the balancer and we will need to register it.
The code is really simple.

with Ada.Command_Line; use Ada.Command_Line;
 
with Ada.Exceptions;
with Ada.Text_IO; use Ada.Text_IO;
 
with CORBA.Impl;
with CORBA.Object;
with CORBA.ORB;
 
with PortableServer.POA.Helper;
with PortableServer.POAManager;
 
with CorbaCBSG.CBSG.Helper;
with CorbaCBSG.CBSG.Impl;
with CorbaCBSG.CBSGBalancer;
 
with PolyORB.CORBA_P.CORBALOC;
 
-- Specify to PolyORB how to dea with tasks
with PolyORB.Setup.No_Tasking_Server;
pragma Warnings (Off, PolyORB.Setup.No_Tasking_Server);
 
procedure Registering_Servant is
begin
 
   declare
      -- Allows to get parameters as defined in Corba standard like InitialRef
      Argv : CORBA.ORB.Arg_List := CORBA.ORB.Command_Line_Arguments;
 
   begin
      -- Init our bus under ORB name
      CORBA.ORB.Init (CORBA.ORB.To_CORBA_String ("ORB"), Argv);
 
      declare
	 -- PortableObjectAdapter is where we store our objects
         Root_POA : PortableServer.POA.Local_Ref;
 
	 -- We declare a reference for our object
         Ref : CorbaCBSG.CBSG.Ref;
 
	 -- and its implementation
         Obj : constant CORBA.Impl.Object_Ptr := new CorbaCBSG.CBSG.Impl.Object;
 
	 -- we declare a reference to the balancer
	 Balancer : CorbaCBSG.CBSGBalancer.Ref;
 
      begin
	 CORBA.ORB.Initialize ("ORB");
	 if Argument_Count not in 1 .. 2 then
	    Put_Line
	      ("usage: registered_servant <IOR_string_from_server>");
	    return;
	 end if;
 
	 --  Get a reference on the distributed object through its IOR or corbaloc
	 CORBA.ORB.String_To_Object
	   (CORBA.To_CORBA_String (Ada.Command_Line.Argument (1)), Balancer);
 
	 -- Check the reference is correct
	 if CorbaCBSG.CBSGBalancer.Is_Nil(Balancer) then
	    Put_Line ("main : cannot invoke on a nil reference");
	    return;
	 end if; 
 
	 -- Get the root
	 Root_POA := PortableServer.POA.Helper.To_Local_Ref
	   (CORBA.ORB.Resolve_Initial_References
	      (CORBA.ORB.To_CORBA_String ("RootPOA")));
 
	 -- Start our POA
	 PortableServer.POAManager.Activate
	   (PortableServer.POA.Get_The_POAManager (Root_POA));
 
	 -- We create a ref to expose it
	 Ref := CorbaCBSG.CBSG.Helper.To_Ref(PortableServer.POA.Servant_To_Reference
					       (Root_POA, PortableServer.Servant (Obj)));
 
	 -- we display the IOR
	 Put_Line
	   ("'"
	      & CORBA.To_Standard_String (CORBA.Object.Object_To_String (Ref))
	      & "'");
	 New_Line;
 
	 --  and the CorbaLoc
	 Put_Line
	   ("'"
	      & CORBA.To_Standard_String
	      (PolyORB.CORBA_P.CORBALOC.Object_To_Corbaloc (Ref))
	      & "'");
 
	 -- Ask to register to the balancer
	 CorbaCBSG.CBSGBalancer.Register(Balancer, Ref);
 
	 --  Launch the server. CORBA.ORB.Run is supposed to never return,
	 --  print a message if it does.
 
	 CORBA.ORB.Run;
 
	 Put_Line ("ORB main loop terminated!");
      end;
   end;
exception
   when E : others =>
      Put_Line
        ("CBSG server raised " & Ada.Exceptions.Exception_Information (E));
      raise;
end Registering_Servant;

In this code, we launch our server with a parameter which is the IOR of our balancer. This parameter allows to get a reference on it in order to call the register function.
That's all for it.

Our Java client

This time, we will use a Java client to request bullshits.

import org.omg.CORBA.*;
import CorbaCBSG.*;
 
public class CBSGClient
{
    public static void main(String[] argv)
    {
	//First, init the ORB
	ORB orb = ORB.init(argv, null);
 
	org.omg.CORBA.Object obj = orb.string_to_object(argv[0]);
	CBSGBalancer cbsgBalancer = CBSGBalancerHelper.narrow(obj);
 
	try
	{
	    CBSG[] cbsgArray = cbsgBalancer.reserveSeveral(2);
 
	    for (int i=0; i < 2; i++)
	    {
		String returned_l = cbsgArray[i].createSentence();
		System.out.println("The generator " + i + " said : " + returned_l);
 
		// We release it
		cbsgBalancer.release(cbsgArray[i]);
	    }
	}
	catch (NoMoreCBSGAvailable ex)
	{
	    System.out.println("Ouch !! We can't reserve one CBSG");
	}
    }
}

Simple !!
I won't describe here how Java deals with Corba through helpers, Operations' classes.
Ok, I forgot one thing and you could say :

What about using sequences in Ada ?

Ok, we will implement a client in Ada to show it :)

with Ada.Command_Line; use Ada.Command_Line;
with Ada.Text_IO; use Ada.Text_IO;
 
with CORBA.ORB;
 
with CorbaCBSG.CBSGBalancer;
with CorbaCBSG.CBSG;
 
with PolyORB.CORBA_P.CORBALOC;
 
with PolyORB.Setup.No_Tasking_Server;
pragma Warnings (Off, PolyORB.Setup.No_Tasking_Server);
 
 
Procedure Balanced_Client is
 
   Argv : CORBA.ORB.Arg_List := CORBA.ORB.Command_Line_Arguments;
 
   -- We declare a reference to the balancer
   Balancer : CorbaCBSG.CBSGBalancer.Ref;
 
   -- The sequence of CBSG to call
   Callees : CorbaCBSG.CBSGSeq;
 
begin
   -- Init the ORB
   CORBA.ORB.Init (CORBA.ORB.To_CORBA_String ("ORB"), Argv);
 
   if Argument_Count not in 1 .. 2 then
      Put_Line
	("usage: balanced_client <IOR_string_from_server>");
      return;
   end if;
 
   -- Get our balancer through its corbaloc or IOR
   CORBA.ORB.String_To_Object
     (CORBA.To_CORBA_String (Ada.Command_Line.Argument (1)), Balancer);
 
   -- Check it's correct
   if CorbaCBSG.CBSGBalancer.Is_Nil(Balancer) then
      Put_Line ("main : cannot invoke on a nil reference");
      return;
   end if; 
 
   -- Ask several CBSG to the balancer
   Callees := CorbaCBSG.CBSGBalancer.ReserveSeveral(Balancer, 2);
 
   -- Call each one
   for Index in 1..CorbaCBSG.Length(Callees) loop
      declare
	 The_Cbsg : CorbaCBSG.CBSG.Ref := 
	   CorbaCBSG.CBSG.Convert_Forward
	   .From_Forward(
			 CorbaCBSG.Get_Element(Callees, Index)
			);
      begin
	 -- Call the element
	 Put_Line("The generator " & Positive'Image(Index) & " said : " & Corba.To_Standard_String(The_Cbsg.createSentence));
	 CorbaCBSG.CBSGBalancer.Release(Balancer, The_Cbsg);
      end;
   end loop;
 
end Balanced_Client;

The most difficult part is the last one... But, it's not that diffcult.
You just have to remember that :

Our sequence was declared inside the top-level part of the IDL
Our sequence contains forward objects instead of reference directly

So, for the first point, all methods declared for sequences^[3] are available in our top-level package.
For the second point, we will have to convert our forward objects to the ones we really want. This will be done with From_Forward function in the Convert_Forward package. As this conversion package deals with objects, it is declared in the object package and not at the top-level.

We now have a balancer, a CBSG able to register itself to the balancer and two clients.
It should work out-of-the-box if you run the programs on the same machine but if you want to run it across several machines^[4], you will have to use InitialRef or equivalent parameters.
I can't be more precise as, even if I tested it, I've lost the configuration I used :D
Maybe, I'll update this post to provide you the correct parameters. Stay tuned ;)

Notes

[1] Something I just forgot few minutes ago :D

[2] Using ValueType would be a different thing but it is not currently implemented in PolyORB

[3] in PolyORB.Sequences.Unbounded through Corba.Sequences.Unbounded

[4] Which must be the goal of such architecture :)

I've got the power (english version)

2013-04-02T10:47:00+02:00

This is a translation of an old post in french, see the original here.

No, I've not become Fred Almighty and that's happy, it would be a mess :D
In the scope of non-profit activities, I received a wonderful UPS that I had to configure for FreeBSD.

At the beginnning, to be honest, I was not really motivated to configure this beast for the Wonderful OS especially after seeing that all different tools where in Java^[1].
After having my server configured to access it from home^[2] and plugged to the UPS through the USB cable, I've been looking for a way to make it work.
A small query on Internet and I have found a small load monitor running of FreeBSD named Nut which is hosted by Eaton... This seems to be good while your UPS is a Eaton Ellipse ASR750 ;-)

A quick tour of supported hardware is a piece of cake and confirms that everything will be alright.
So, I install Nut through the classical way :

root@rcjserveur : ~> cd /usr/ports/sysutils/nut/ && make install clean

Configuration is not so hard even if I have to change few points like compared to this :
For ups.conf, keep it simple :

[eaton]
        driver = usbhid-ups
        port = auto
        desc = "EATON UPS"

hosts.conf

#
MONITOR eaton@localhost "UPS Eaton Ellipse"
# MONITOR su2200@10.64.1.1 "Finance department"
# MONITOR matrix@shs-server.example.edu "Sierra High School data room #1"

For upsd.users

Sorry, I won't give you this one, there are some credentials in it !!!

In upsmon.conf

...
MONITOR eaton@localhost 1 my_user my_password master
...
SHUTDOWNCMD "/sbin/shutdown -p +0"

Everything seemed to be ok but...
The main problem came from the rights on the USB as usual. In fact, at login time or at startup, rights are really generics.
Happily, FreeBSD is here to help you and give you the answer tanks to ''devd'' and to its configuration curiously named ''devd.conf''. For your information, I found this solution more elegant and more generic than using devfs.

attach 100 {
        match "vendor" "0x0463";
        match "product" "0xffff";
        action "/usr/sbin/chown -R -L uucp:uucp /dev/$device-name";
};

Off course, these values are not randomly chosen, a quick use of ''usbconfig'' gives you the hints

root@rcjserveur : ~> usbconfig -u 4 -a 2 dump_device_desc
ugen4.2: <ELLIPSE EATON> at usbus4, cfg=0 md=HOST spd=LOW (1.5Mbps) pwr=ON
  bLength = 0x0012 
  bDescriptorType = 0x0001 
  bcdUSB = 0x0110 
  bDeviceClass = 0x0000 
  bDeviceSubClass = 0x0000 
  bDeviceProtocol = 0x0000 
  bMaxPacketSize0 = 0x0008 
  idVendor = 0x0463 
  idProduct = 0xffff 
  bcdDevice = 0x0001 
  iManufacturer = 0x0001  <EATON>
  iProduct = 0x0002  <ELLIPSE>
  iSerialNumber = 0x0004  <BDCK520CF>
  bNumConfigurations = 0x0001

Tests were simple too. I just checked that I could see the charge of the machine while telling myself that for a shutdown script, I'll look at it later.
Well, as Murphy's law tells, it was checked by itself as there was a power outage on friday evening until monday morning. Seeking in the logs, I found the Holy Graal :

Mar 11 17:28:35 RCJServeur upsmon[32074]: UPS eaton@localhost on battery
...
Mar 11 17:42:16 RCJServeur upsmon[32074]: UPS eaton@localhost battery is low
Mar 11 17:42:16 RCJServeur upsmon[32074]: Executing automatic power-fail shutdown
Mar 11 17:42:16 RCJServeur upsmon[32074]: Auto logout and shutdown proceeding
Mar 11 17:42:21 RCJServeur shutdown: power-down by fred: 
Mar 11 17:42:23 RCJServeur upsd[32047]: mainloop: Interrupted system call

Great, the server shut down correctly when the UPS was out of power. Well done Fred, you've got the power !!!
What surprised me is that the server started up by itself when power came back and despite the fact that I did'nt configure anything for that :)
Well, this is not really a problem so I can sleep well :D

Notes

[1] I work with it all the day, so I won't play with it on my spare time also ;-)

[2] Won't tell you how, it would be too risky, bitthirsty hackers !!

Spreading bullshits

2013-03-24T22:32:00+01:00

I decided today to write a small cute tutorial to create the best of the best for scalability, for highly distributed and high reliability while being multi-platform, multi-language and potentially multi-paradigm... Well, the two first ones, ok but for the last, I don't really know and finally, I don't give a damn :D
At this point, with the number of buzzwords I used, tour tollmeter should explode !! :D
But, from now, I won't tell you anything else, you'll have to read what follows !!

What would be better to do the whole thing than web services ?
Well, it's simple, something else than web service :)
This other thing is an old stuff nobody wants to use anymore because it's too complicated, too heavy to set up and to code, here is CORBA !!

Well, after thinking about it, it's not a real CORBA tutorial because there are a lot on Internet but it's more a documented example for a small app done with vPolyORB for server-side and OmniORB for the C++ client-side.

The dispenser

It's as good as a movie title but what are we distributing ?
As I didn't want to build a whole app to distribute, I decided to use an existing application helping everyone on an almost daily basis. Here is the Corporate Bullshit Generator from my Ada friend Gautier.
For those who don't know already, this application provides excellent sentences to use in every good meeting with commercials, strategy managers and so on.
Let's go on the project page in order to download the source code^[1].

Small analysis of bullshits

To do some CORBA, we have to know what to distribute. The central package in CSBG is Corporate_Bullshit. It's a generic package to define the end of line characters and the sentence to use to simulate a dialog^[2].
So, what do we see ?

function Sentence return String;
 
function Workshop return String;
 
function Short_Workshop return String;
 
function Financial_Report return String;

Four functions allowing to create a string containing the set of bullshits. Let's be crazy, we will provide an interface for all of them.
In CORBA, it's quite simple, we will get the following IDL file :

module CorbaCBSG {
 
  interface CBSG{
    string createSentence();
    string createWorkshop();
    string createShortWorkshop();
    string createFinancialReport();
  };
};

Here, I preferred to use writing conventions in use for C++, Java and others rather than the ones used in Ada in order not to scare the coder that would prefer to write the client with one of these languages ;)
Well, finally, it's piece of cake ! :D

But this is only a first example...

Generation

Let's go the generation and implementation for server-side part.
For this reason, I recommand to create a directory corba containing a directory idl and directories Ada' and C++. The whole thing should be placed inside a directory csbg. The file csbg.idl defined will fit inside the idl'' directory.
Let's make serious things :

fred@coruscant :~/cbsg/corba/Ada $ iac -i ../idl/cbsg.idl

Eleven files are created. Only corbacbsg-cbsg-impl.ads and corbacbsg-cbsg-impl.adb will be interesting, the others are only CORBA plumbing. One important point though, the i option will overwrite your implementation if it exists already and also the spec if it contains specific fields.
In the spec file (ads file), there's nothing to change. In fact, our CORBA object doesn't hold a specific state as the CBSG does.
But, it's interesting to read this file as the reader will notice that generated methods does not use the standard String type we can find in Ada but a CORBA specific type. Our CORBA object will do the translation.
As you're really smart, I'll only give the implementation for createSentence function and how to declare the generic package Corporate_Bullshit, you'll manage to generalize on your own :

package Simple_Generator is new  Corporate_Bullshit(Paragraph => "",
						       Dialog_Mark => "");
 
   --------------------
   -- createSentence --
   --------------------
 
   function createSentence
     (Self : not null access Object)
     return CORBA.String
   is
      Generated_Sentence : String := Simple_Generator.Sentence;
   begin
      return CORBA.To_CORBA_String(Generated_Sentence);
   end createSentence;

Now that we've defined the behaviour of our object, it's time to statup the CORBA bus and expose an instance of our brand new class.
For now, we won't use one of the most used CORBA service, the Name Service. Our server will only expose an IOR, reference to our object.
For this server, the echo example provided with PolyORB will be enough :

with Ada.Exceptions;
with Ada.Text_IO; use Ada.Text_IO;
 
with CORBA.Impl;
with CORBA.Object;
with CORBA.ORB;
 
with PortableServer.POA.Helper;
with PortableServer.POAManager;
 
with CorbaCBSG.CBSG.Impl;
 
with PolyORB.CORBA_P.CORBALOC;
 
-- Allow to specify to PolyORB how to behave from a tasking point of view
with PolyORB.Setup.No_Tasking_Server;
pragma Warnings (Off, PolyORB.Setup.No_Tasking_Server);
 
procedure Server is
begin
 
   declare
      -- Allows to get the paramters such as those defined in the CORBA standard like InitialRef
      Argv : CORBA.ORB.Arg_List := CORBA.ORB.Command_Line_Arguments;
 
   begin
      -- Initiliaze our bus under the name ORB
      CORBA.ORB.Init (CORBA.ORB.To_CORBA_String ("ORB"), Argv);
 
      declare
	 -- The PortableObjectAdapter is where we register our objects
         Root_POA : PortableServer.POA.Local_Ref;
 
	 -- We declare a reference for our object
         Ref : CORBA.Object.Ref;
 
	 -- And its implementation
         Obj : constant CORBA.Impl.Object_Ptr := new CorbaCBSG.CBSG.Impl.Object;
 
      begin
 
         -- We get the Root POA
         Root_POA := PortableServer.POA.Helper.To_Local_Ref
           (CORBA.ORB.Resolve_Initial_References
	      (CORBA.ORB.To_CORBA_String ("RootPOA")));
 
	 -- We start it up
         PortableServer.POAManager.Activate
           (PortableServer.POA.Get_The_POAManager (Root_POA));
 
	 -- We create a reference in order to expose it
         Ref := PortableServer.POA.Servant_To_Reference
           (Root_POA, PortableServer.Servant (Obj));
 
	 -- We display the IOR
         Put_Line
           ("'"
	      & CORBA.To_Standard_String (CORBA.Object.Object_To_String (Ref))
	      & "'");
         New_Line;
 
         --  and a corbaloc
         Put_Line
           ("'"
	      & CORBA.To_Standard_String
	      (PolyORB.CORBA_P.CORBALOC.Object_To_Corbaloc (Ref))
	      & "'");
 
         --  Launch the server. CORBA.ORB.Run is supposed to never return,
         --  print a message if it does.
 
         CORBA.ORB.Run;
 
         Put_Line ("ORB main loop terminated!");
      end;
   end;
exception
   when E : others =>
      Put_Line
        ("CBSG server raised " & Ada.Exceptions.Exception_Information (E));
      raise;
end Server;

Even if this code seems complex, it's always the same each time we will expose an object in the bus.
We just have to compile :

fred@coruscant :~/cbsg/corba/Ada $ mkdir obj
fred@coruscant :~/cbsg/corba/Ada $ gnatmake server.adb -D obj -aI../.. `polyorb-config`

If everything went well, we just have to start the server

fred@coruscant :~/cbsg/corba/Ada $ ./server
'IOR:010000001700000049444c3a436f726261434253472f434253473a312e30000002000000000000005c000000010102000a0000003132372e302e302e3100f1761b0000002f30303030303030313154643637306239663031326565316538300001000000010000001c0000000100000001000100000000000001010002000000010101000201010003004f503c000000010100000c0000003139322e3136382e332e32007a3300001b0000002f30303030303030313154643637306239663031326565316538300000000000'

'corbaloc:iiop:1.2@127.0.0.1:30449//000000011Td670b9f012ee1e80'

if you want the server to listen on another address than 127.0.0.1, we just have to put it in polyorb.conf which must be at the place from which you run the server.

Waiter, please

Now that our server is wainting for a client, let's code it. First, a small simple Ada client as everything is reay for it. Once again, the echo example will be enough to create our client

with Ada.Command_Line;
with Ada.Text_IO;
with CORBA.ORB;
 
with CorbaCBSG.CBSG;
 
with PolyORB.Setup.Client;
pragma Warnings (Off, PolyORB.Setup.Client);
 
procedure Client is
   use Ada.Command_Line;
   use Ada.Text_IO;
   use type CORBA.String;
 
   Rcvd_Bullshits : CORBA.String;
   Bullshit_Generator : CorbaCBSG.CBSG.Ref;
 
begin
   CORBA.ORB.Initialize ("ORB");
   if Argument_Count not in 1 .. 2 then
      Put_Line
        ("usage: client <IOR_string_from_server>");
      return;
   end if;
 
   --  Get a reference on the distributed object through its IOR or corbaloc
   CORBA.ORB.String_To_Object
     (CORBA.To_CORBA_String (Ada.Command_Line.Argument (1)), Bullshit_Generator);
 
   -- check that the reference is correct
   if CorbaCBSG.CBSG.Is_Nil(Bullshit_Generator) then
      Put_Line ("main : cannot invoke on a nil reference");
      return;
   end if;
 
   Rcvd_Bullshits := CorbaCBSG.CBSG.createSentence(Bullshit_Generator);
 
   Put_Line ("The generator said : " & CORBA.To_Standard_String (Rcvd_Bullshits));
 
exception
   when E : CORBA.Transient =>
      declare
         Memb : CORBA.System_Exception_Members;
      begin
         CORBA.Get_Members (E, Memb);
         Put ("received exception transient, minor");
         Put (CORBA.Unsigned_Long'Image (Memb.Minor));
         Put (", completion status: ");
         Put_Line (CORBA.Completion_Status'Image (Memb.Completed));
      end;
end Client;

As usual, compilation :

fred@coruscant :~/cbsg/corba/Ada $ gnatmake client -D obj -aI../.. `polyorb-config `
fred@coruscant :~/cbsg/corba/Ada $ ./client 'corbaloc:iiop:1.2@127.0.0.1:30449//000000011Td670b9f012ee1e80'
The generator said : The business leaders embrace a growing execution by thinking outside of the box, whereas the steering committee delivers a top-down interoperability.

What to say other than superb !!

Ok, I promised a C++ client with OmniORB. As I always deliver the goods, here it is...
In the C++ directory, we begin by generating the needed files with the OmniORB IDL compiler.

fred@coruscant :~/cbsg/corba/C++ $ omniidl -bcxx ../idl/cbsg.idl

csbg.hh and csbg.cc get created. They contain at the same time stubs and skeletons. For the client-side, we will only use the stub part.
We create the client by taking ideas from the provided examples with OmniORB :

#include <cbsg.hh>
#ifdef HAVE_STD 
#include <iostream> 
#include <fstream> 
using namespace std; 
#else 
#include <iostream.h>
#endif 
 
////////////////////////////////////////////////////////////////////// 
int main(int argc, char** argv) 
{ 
  try 
    { 
      //ORB Initialisation
      CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); 
      if( argc != 2 ) 
	{ 
	  cerr << "usage: client <object reference>" << endl; 
	  return 1; 
	} 
 
      //We create the CORBA object from the provided string
      CORBA::Object_var obj = orb->string_to_object(argv[1]); 
 
      //We cast it to CBSG
      CorbaCBSG::CBSG_var cbsgRef = CorbaCBSG::CBSG::_narrow(obj);
 
      //We check that the object exists
      if( CORBA::is_nil(cbsgRef) ) 
	{ 
	  cerr << "Can't narrow reference to type CBSG (or it was nil)." << endl; 
	  return 1; 
	} 
 
      //And go, we call it
      CORBA::String_var bullshit = cbsgRef->createSentence();
      cout << "The generator said : " << bullshit << endl;
 
      //We stop the ORB
      orb->destroy(); 
    } 
  catch(CORBA::TRANSIENT&) 
    {
      cerr << "Caught system exception TRANSIENT -- unable to contact the " << "server." << endl; 
    } 
  catch(CORBA::SystemException& ex) 
    { 
      cerr << "Caught a CORBA::" << ex._name() << endl;
    }
  catch(CORBA::Exception& ex) 
    { 
      cerr << "Caught CORBA::Exception: " << ex._name() << endl;
    } 
  catch(omniORB::fatalException& fe) 
    {
      cerr << "Caught omniORB::fatalException:" << endl; 
      cerr << " file: " << fe.file() << endl; 
      cerr << " line: " << fe.line() << endl; 
      cerr << " mesg: " << fe.errmsg() << endl; 
    } 
  return 0; 
}

We compile and test :

fred@coruscant :~/cbsg/corba/C++ $ g++ -o client client.cpp cbsgSK.cc -I. -lomniORB4
fred@coruscant :~/cbsg/corba/C++ $ ./client 'corbaloc:iiop:1.2@127.0.0.1:30449//000000011Td670b9f012ee1e80'
The generator said : The granular low hanging fruit incentivises the steering committee.

Depending on the version of OmniORB, it could be necessary to include -lomnithread on the compilation command line.
And that's it !
Well, I promised high availability and tutti quanti but finally, I will keep it for the next time :)
Hope it pleased you.

Notes

[1] But just read interfaces, you would get a bullshit overdose

[2] This second parameter quite obscur is not used by Gautier, so caution :D

Distribution de conneries

2013-03-22T16:31:00+01:00

J'ai décidé aujourd'hui de faire un petit tuto sympa pour réaliser le top du top en matière de scalabilité^[1], de haute distribution ainsi que haute reliabilité^[2] tout en restant multi-plateforme, multi-langage et potentiellement multi-paradigme... Enfin, les deux premiers, c'est sûr, le troisième, j'en sais rien et je m'en tape :D
Normalement, là, avec le nombre de buzzwords utilisés, vous devriez déjà avoir le trollomètre au taquet !! :D
Mais je ne vous en dirai pas plus, il faut aller voir, LA SUITE !!!

Notes

[1] J'adore cet anglicisme tellement il est foireux

[2] Bien aussi, celui-là

Quoi de mieux pour réaliser tout ça que les web services ?
Et bien, c'est simple, autre chose que des web services !! :)
Cette autre chose est un vieux truc que plus personne ne veut utiliser car trop compliqué, trop lourd à mettre en place et à coder, j'ai nommé CORBA^[1] !!

Bon, après réflexion, ce ne sera pas un vrai tutoriel CORBA, car il y en a déjà sur Internet, mais plutôt un exemple documenté d'une petite application faite avec PolyORB pour ce qui est du serveur et OmniORB pour la partie C++ cliente.

Le distributeur

C'est beau comme un titre de films mais que distribuons-nous ?
N'ayant pas envie de recoder toute une application pour la distribuer, j'ai décidé de repartir d'une application existante et rendant régulièrement service. J'ai nommé le Corporate Bullshit Generator de mon ami adaïste Gautier.
Pour ceux qui ne connaîtraient pas encore, cette application fournit d'excellentes phrases à placer dans toute bonne réunion se déroulant en présence de commerciaux, grands statéguères etc.
Rendez-vous donc sur la page du projet afin de télécharger le code source^[2].

Petite analyse des bullshits

Pour faire du CORBA, il faut d'abord savoir ce que l'on va distribuer. Le paquetage central du CSBG est le Corporate_Bullshit. Il s'agit d'un paquetage générique dont le but est de définir les caractères de saut de lignes ainsi que la phrase à utiliser pour simuler un dialogue^[3].
Quoi qu'on voit ?

function Sentence return String;
 
function Workshop return String;
 
function Short_Workshop return String;
 
function Financial_Report return String;

Quatre fonctions permettant de créer une chaîne de caractères contenant l'ensemble des bullshits. Soyons fous, nous fournirons donc une interface vers les quatre.
En CORBA, c'est assez simple, cela donnera un fichier IDL comme montrer ci-dessous :

module CorbaCBSG {
 
  interface CBSG{
    string createSentence();
    string createWorkshop();
    string createShortWorkshop();
    string createFinancialReport();
  };
};

Ici, j'ai préféré respecter les conventions d'écriture en vigueur en C++, Java et consorts en lieu et place de celles d'Ada pour ne pas effrayer le programmeur qui voudrait écrire un client dans ces langages ;)
Au final, c'est bête comme chou ! :D

Mais ce n'est qu'un premier exemple...

Génération

Passons maintenant à la génération et à l'implémentation de la partie serveur.
Pour cela, je conseille la création d'un répertoire corba contenant un répertoire idl ainsi que des répertoires Ada et C++, le tout dans le répertoire du cbsg. Le fichier cbsg.idl définit au-dessus trouvera aisément sa place dans le répertoire idl.
Passons aux choses sérieuses :

fred@coruscant :~/cbsg/corba/Ada $ iac -i ../idl/cbsg.idl

Onze fichiers sont normalement créés. Seul les fichiers corbacbsg-cbsg-impl.ads et corbacbsg-cbsg-impl.adb vont nous intéresser, le reste étant de la tuyauterie CORBA. Un point toutefois important, l'option i écrasera votre implémentation si celle-ci existe déjà ainsi que sa spécification si elle contient des champs spécifiques.
Dans la spécification (fichier ads), il n'y a rien à changer. En effet, notre objet CORBA n'a pas d'état en soi tout comme le CBSG.
Par contre, il est intéressant de lire ce fichier car le lecteur attentif aura remarqué que les méthodes générées n'utilisent pas le type String standard d'Ada mais un type propre à CORBA. Notre objet CORBA fera donc la translation.
Comme vous êtes très forts, je ne donnerai que l'implémentation de la fonction createSentence ainsi que la déclaration du paquetage générique Corporate_Bullshit , vous généraliserez par vous-mêmes :

package Simple_Generator is new  Corporate_Bullshit(Paragraph => "",
						       Dialog_Mark => "");
 
   --------------------
   -- createSentence --
   --------------------
 
   function createSentence
     (Self : not null access Object)
     return CORBA.String
   is
      Generated_Sentence : String := Simple_Generator.Sentence;
   begin
      return CORBA.To_CORBA_String(Generated_Sentence);
   end createSentence;

Maintenant que nous avons défini le comportement de notre objet, il nous faut démarrer le bus CORBA et exposer une instance de notre toute nouvelle classe.
Pour le moment, nous n'utiliserons pas l'un des services primordiaux de CORBA, à savoir le Name Service. Notre serveur exposera donc seulement une IOR, référence vers notre objet.
Pour ce serveur, l'exemple echo fournit avec PolyORB suffit amplement :

with Ada.Exceptions;
with Ada.Text_IO; use Ada.Text_IO;
 
with CORBA.Impl;
with CORBA.Object;
with CORBA.ORB;
 
with PortableServer.POA.Helper;
with PortableServer.POAManager;
 
with CorbaCBSG.CBSG.Impl;
 
with PolyORB.CORBA_P.CORBALOC;
 
-- Permet de spécifier à PolyORB son type de fonctionnement
with PolyORB.Setup.No_Tasking_Server;
pragma Warnings (Off, PolyORB.Setup.No_Tasking_Server);
 
procedure Server is
begin
 
   declare
      -- Permet de récupérer les paramètres tels que définis dans le norme CORBA comme InitialRef
      Argv : CORBA.ORB.Arg_List := CORBA.ORB.Command_Line_Arguments;
 
   begin
      -- Initialisation de notre bus sous le nom ORB
      CORBA.ORB.Init (CORBA.ORB.To_CORBA_String ("ORB"), Argv);
 
      declare
	 -- Le PortableObjectAdapter est l'endroit où sont stockés nons objets
         Root_POA : PortableServer.POA.Local_Ref;
 
	 -- On déclare une référence pour notre objet
         Ref : CORBA.Object.Ref;
 
	 -- Et son implémentation
         Obj : constant CORBA.Impl.Object_Ptr := new CorbaCBSG.CBSG.Impl.Object;
 
      begin
 
         -- Récupération du POA racine du bus
	 -- Il s'agit d'une interface CORBA et utilise donc des chaines de caractères CORBA
	 -- que l'on traduit en référence d'objet
         Root_POA := PortableServer.POA.Helper.To_Local_Ref
           (CORBA.ORB.Resolve_Initial_References
	      (CORBA.ORB.To_CORBA_String ("RootPOA")));
 
	 -- On démarre notre POA
         PortableServer.POAManager.Activate
           (PortableServer.POA.Get_The_POAManager (Root_POA));
 
	 -- On crée une référence sur notre objet pour l'exposer
         Ref := PortableServer.POA.Servant_To_Reference
           (Root_POA, PortableServer.Servant (Obj));
 
	 -- Et on affiche un IOR
         Put_Line
           ("'"
	      & CORBA.To_Standard_String (CORBA.Object.Object_To_String (Ref))
	      & "'");
         New_Line;
 
         --  et une corbaloc
         Put_Line
           ("'"
	      & CORBA.To_Standard_String
	      (PolyORB.CORBA_P.CORBALOC.Object_To_Corbaloc (Ref))
	      & "'");
 
         --  Launch the server. CORBA.ORB.Run is supposed to never return,
         --  print a message if it does.
 
         CORBA.ORB.Run;
 
         Put_Line ("ORB main loop terminated!");
      end;
   end;
exception
   when E : others =>
      Put_Line
        ("CBSG server raised " & Ada.Exceptions.Exception_Information (E));
      raise;
end Server;

Même si ce code a l'air complexe, il est quasi identique pour toutes les fois où l'on doit exposer un objet sur le bus.
Il ne reste plus que la compilation :

fred@coruscant :~/cbsg/corba/Ada $ mkdir obj
fred@coruscant :~/cbsg/corba/Ada $ gnatmake server.adb -D obj -aI../.. `polyorb-config`

Si tout c'est bien passé, il ne reste qu'à lancer notre serveur

fred@coruscant :~/cbsg/corba/Ada $ ./server
'IOR:010000001700000049444c3a436f726261434253472f434253473a312e30000002000000000000005c000000010102000a0000003132372e302e302e3100f1761b0000002f30303030303030313154643637306239663031326565316538300001000000010000001c0000000100000001000100000000000001010002000000010101000201010003004f503c000000010100000c0000003139322e3136382e332e32007a3300001b0000002f30303030303030313154643637306239663031326565316538300000000000'

'corbaloc:iiop:1.2@127.0.0.1:30449//000000011Td670b9f012ee1e80'

vous voulez que le serveur écoute sur autre chose que 127.0.0.1, il suffit de le préciser dans le fichier polyorb.conf qui devra se trouver à l'endroit d'où vous lancez le serveur.

Serveur, s'il vous plaît

Maintenant que notre serveur attend le client, codons-le. D'abord un petit client tout simple en Ada vu que tout est prêt pour cela. Encore une fois, l'exemple echo fourni nous suffira pour créer notre client

with Ada.Command_Line;
with Ada.Text_IO;
with CORBA.ORB;
 
with CorbaCBSG.CBSG;
 
with PolyORB.Setup.Client;
pragma Warnings (Off, PolyORB.Setup.Client);
 
procedure Client is
   use Ada.Command_Line;
   use Ada.Text_IO;
   use type CORBA.String;
 
   Rcvd_Bullshits : CORBA.String;
   Bullshit_Generator : CorbaCBSG.CBSG.Ref;
 
begin
   CORBA.ORB.Initialize ("ORB");
   if Argument_Count not in 1 .. 2 then
      Put_Line
        ("usage: client <IOR_string_from_server>");
      return;
   end if;
 
   --  Récupération d'une référence sur l'objet distribué par son IOR ou corbaloc
   CORBA.ORB.String_To_Object
     (CORBA.To_CORBA_String (Ada.Command_Line.Argument (1)), Bullshit_Generator);
 
   -- On vérifie que la référence est correcte
   if CorbaCBSG.CBSG.Is_Nil(Bullshit_Generator) then
      Put_Line ("main : cannot invoke on a nil reference");
      return;
   end if;
 
   Rcvd_Bullshits := CorbaCBSG.CBSG.createSentence(Bullshit_Generator);
 
   Put_Line ("The generator said : " & CORBA.To_Standard_String (Rcvd_Bullshits));
 
exception
   when E : CORBA.Transient =>
      declare
         Memb : CORBA.System_Exception_Members;
      begin
         CORBA.Get_Members (E, Memb);
         Put ("received exception transient, minor");
         Put (CORBA.Unsigned_Long'Image (Memb.Minor));
         Put (", completion status: ");
         Put_Line (CORBA.Completion_Status'Image (Memb.Completed));
      end;
end Client;

Comme d'habitude, compilation :

fred@coruscant :~/cbsg/corba/Ada $ gnatmake client -D obj -aI../.. `polyorb-config `
fred@coruscant :~/cbsg/corba/Ada $ ./client 'corbaloc:iiop:1.2@127.0.0.1:30449//000000011Td670b9f012ee1e80'
The generator said : The business leaders embrace a growing execution by thinking outside of the box, whereas the steering committee delivers a top-down interoperability.

Que dire de plus que magnifique !!

Ok, j'avais promis un client C++ avec OmniORB. Comme je tiens toujours mes promesses, le voici...
Dans le répertoire C++, on commence donc par générer les fichiers nécessaires avec le compilateur d'IDL d'OmniORB.

fred@coruscant :~/cbsg/corba/C++ $ omniidl -bcxx ../idl/cbsg.idl

Les fichiers cbsg.hh et cbsg.cc sont créés. Ils contiennent à la fois les stubs et les skeletons. Dans le cadre du client, on n'utilisera que la partie stub.
on crée donc le client en s'inspirant des exemples fournis avec OmniORB :

#include <cbsg.hh>
#ifdef HAVE_STD 
#include <iostream> 
#include <fstream> 
using namespace std; 
#else 
#include <iostream.h>
#endif 
 
////////////////////////////////////////////////////////////////////// 
int main(int argc, char** argv) 
{ 
  try 
    { 
      //Initialisation de l'ORB
      CORBA::ORB_var orb = CORBA::ORB_init(argc, argv); 
      if( argc != 2 ) 
	{ 
	  cerr << "usage: client <object reference>" << endl; 
	  return 1; 
	} 
 
      //On crée un objet CORBA à partir de la chaine fournie
      CORBA::Object_var obj = orb->string_to_object(argv[1]); 
 
      //Et le castons en CBSG
      CorbaCBSG::CBSG_var cbsgRef = CorbaCBSG::CBSG::_narrow(obj);
 
      //On vérifie que l'objet existe
      if( CORBA::is_nil(cbsgRef) ) 
	{ 
	  cerr << "Can't narrow reference to type CBSG (or it was nil)." << endl; 
	  return 1; 
	} 
 
      //Et hop, on appelle
      CORBA::String_var bullshit = cbsgRef->createSentence();
      cout << "The generator said : " << bullshit << endl;
 
      //On arrête l'ORB
      orb->destroy(); 
    } 
  catch(CORBA::TRANSIENT&) 
    {
      cerr << "Caught system exception TRANSIENT -- unable to contact the " << "server." << endl; 
    } 
  catch(CORBA::SystemException& ex) 
    { 
      cerr << "Caught a CORBA::" << ex._name() << endl;
    }
  catch(CORBA::Exception& ex) 
    { 
      cerr << "Caught CORBA::Exception: " << ex._name() << endl;
    } 
  catch(omniORB::fatalException& fe) 
    {
      cerr << "Caught omniORB::fatalException:" << endl; 
      cerr << " file: " << fe.file() << endl; 
      cerr << " line: " << fe.line() << endl; 
      cerr << " mesg: " << fe.errmsg() << endl; 
    } 
  return 0; 
}

On compile et on teste

fred@coruscant :~/cbsg/corba/C++ $ g++ -o client client.cpp cbsgSK.cc -I. -lomniORB4
fred@coruscant :~/cbsg/corba/C++ $ ./client 'corbaloc:iiop:1.2@127.0.0.1:30449//000000011Td670b9f012ee1e80'
The generator said : The granular low hanging fruit incentivises the steering committee.

Suivant la version d'OmniORB, il peut être nécessaire de compléter la ligne de compilation avec -lomnithread.
Et voilà !
Bon, j'avais promis de la haute disponibilité et tutti quanti mais finalement, on va garder ça pour la prochaine fois :)
En espérant que cela vous a plu.

Notes

[1] Désolé mais la page en français est beaucoup trop incomplête :(

[2] Mais ne lisez que les interfaces, vous risqueriez de choper une overdose de bullshits

[3] Ce second paramètre assez obscure n'est pas utilisé par Gautier donc prudence :D

Merci de fermer les portes !

2013-02-13T14:17:00+01:00

J'aurais pu sous-titrer ce billet Quand la confiance ne règne plus :-/

Il m 'avait déjà été demandé par le passé de sécuriser l'accès à un serveur Subversion mais vu les effets de bord, j'étais revenu en arrière, histoire de pas embêter mes petits camarades développeurs.
Comme toutes les choses ont une fin, c'est reparti de plus belle.
Heureusement, cette fois-ci, j'ai réussi à m'y coller, non sans avoir foutu un beau bordel pendant quelques heures.
Je vais quand même tenter de vous expliquer ce qu'il y avait à faire et comment je suis arrivé à mes fins.
Ça vous semblera peut-être très simple mais il y avait des pièges.
Imaginons un référentiel Subversion ayant la structure suivante :

/
├── Projet1
│   ├── branches
│   ├── tags
│   └── trunk
└── Projet2
    ├── branches
    ├── tags
    └── trunk

Un exemple simple de fichier d'accès est le suivant :

[groups]
projet1_devs=john, joe
projet1_admins=john
projet2_devs=jane, joe
projet2_admins=jane

[/]
* = r

[Projet1]
@projet1_devs = r

[Projet1/tags]
@projet1_admins = rw
@projet1_devs = r

[Projet1/branches]
@projet1_devs = rw

#Et ainsi de suite pour chaque projet

Jusque là, c'est pas trop grave mais tous les développeurs peuvent voir le code de chaque projet mais ne peuvent pas y écrire, on est typiquement dans le cas classique tel que décrit dans la doc.
Tant que l'on a confiance, pas de problème mais quand le doute vous habite, ça va plus.
Allons-y, fermons les portes !

Le premier réflexe est de retirer la partie liée au /... C'est une bonne idée mais dont le principal effet de bord est de gêner les outils de navigation dans le référentiel et qui oblige le développeur à connaître l'URL complète vers son projet.
Alors comment faire pour continuer à pouvoir browser tranquillement mais que dans les projets où on a les droits ?
Et bien, au lieu de mettre des droits, on en retire explicitement :

[groups]
projet1_devs=john, joe
projet1_admins=john
projet2_devs=jane, joe
projet2_admins=jane

[/]
* = r

[Projet1]
* =
@projet1_devs = r

[Projet1/tags]
* =
@projet1_admins = rw
@projet1_devs = r

[Projet1/branches]
* = 
@projet1_devs = rw

#Et ainsi de suite pour chaque projet

Vous avez remarqué la subtilité ?
Pour chaque section de projet, il suffit de retirer les droits mis à tous.
Bon, c'est simple mais fallait y penser.

Bissection !

2012-12-20T22:14:00+01:00

non, je n'ai pas décidé de faire des expériences sur des animaux !
Non, je n'ai pas décidé de me faire greffer un deuxième organe sexuel, le mien me suffit^[1].
J'ai décidé de faire un petit billet sur cette fonctionnalité que l'on trouve dans certains logiciels de gestion de versions qui n'est pas mal car elle aide à faire la recherche de la version qui a introduit une régression dans un logiciel.
D'ailleurs, il est normal de la trouver dans Monotone, Git et Mercurial vu que les historiques ne sont pas forcément linéaires.

Notes

[1] Plus, ce serait inconvenant :D

Pour ceux qui ne le sauraient pas, je suis fan de ''Monotone'', un beau logiciel de gestion des versions qui fut, d'après la légende, une source d'inspiration pour un certain Linus T. au moment de créer un autre logiciel dont j'ai parlé ici.

Mais là, ce n'est pas pour casser du sucre sur le dos des autres VCS que j'écris mais pour présenter une fonctionnalité intéressante de Monotone, j'ai nommé le ''bisecting''.
But de l'opération ? Retrouver LA version qui a introduit une ou plusieurs régressions dans un logiciel.
Allons-y gaiement pour la démo !
Toutes les étapes seront détaillées mais il est possible d'utiliser la base de données attachée à ce billet.

Tout d'abord, on initialise une base de données Monotone.

fred@dagobah:~/Dev$ mtn --db=bisect_test.mtn db init

Rien de monstrueux alors on continue en créant notre projet

fred@dagobah:~/Dev$ mtn --db=bisect_test.mtn --branch=bisect_test setup bisect_test

Là encore, si vous suivez le tutorial de Monotone, toujours rien d'extraordinaire. Ajoutons un peu de code pour notre première version dans le répertoire bisect_test :

with Ada.Text_Io; use Ada.Text_Io;
 
procedure Bisect is
begin
   Put_Line("Hello world");
end Bisect;

Ok, c'est nul :)
On ajoute et on committe

fred@dagobah:~/Dev$ mtn add bisect.adb
fred@dagobah:~/Dev$ mtn ci

Après avoir saisi notre message et notre mot de passe, on a notre version. On continue :

with Ada.Text_Io; use Ada.Text_Io;
 
procedure Bisect is
 
   type My_Type is range 12..21;
 
   My_Var : My_Type := 12;
 
begin
   Put_Line("Hello world");
   Put_Line("My_Var=" & My_Type'Image(My_Var));
end Bisect;

Rebelote, on committe et on refait une modif... Bon, je vais pas tout mettre là mais ce qui est intéressant, c'est d'introduire une erreur et de refaire une version après. Voilà la version finale qui finalement compile mais comme le dit le compilateur, ça va foirer :)
Merci Ada !

with Ada.Text_Io; use Ada.Text_Io;
 
procedure Bisect is
 
   type My_Type is range 12..21;
 
   My_Var : My_Type := 11;
 
begin
   Put_Line("Hello world");
   -- Put_Line("My_Var=" & My_Type'Image(My_Var));
end Bisect;

Le problème, c'est que cela n'a pas été fait dans cette révision mais une ou plusieurs révisions avant.
Vite, retrouvons le coupable sans faire de recherche par lecture du code mais par le test.
On commence par marquer la révision courante comme foireuse :

fred@dagobah:~/Dev$ mtn bisect bad
mtn: bissection débutée à la révision « 99c46344761c157cabd4e8e41e9fb6d3a0442a92 frederic.praca@free.fr 20/12/2012 21:51:39 »
mtn: révisions en cours de bissection ; 0 bonnes, 1 mauvaises, 0 sautées. Veuillez spécifier les bonnes révisions pour débuter la recherche.

Bien sûr, vos révisions n'auront pas forcément les mêmes identifiants.
Maintenant, on retourne à la version que l'on sait fonctionner pour la marquer comme correcte :

fred@dagobah:~/Dev/bisect_test$ mtn update -r 5e78416bc66278692a30f1a807aa00b25f31ca56
mtn: sélection de la cible 5e78416bc66278692a30f1a807aa00b25f31ca56 pour la mise à jour
mtn: [gauche]  75b7d43d6a0d02baa366d48984c259a8f6df755e
mtn: [droite]  5e78416bc66278692a30f1a807aa00b25f31ca56
mtn: mise à jour de « bisect.adb »
mtn: mise à jour vers la révision de base 5e78416bc66278692a30f1a807aa00b25f31ca56
fred@dagobah:~/Dev/bisect_test$ mtn bisect good
mtn: 4 révisions en cours de bissection ; 1 bonnes, 1 mauvaises, 0 sautées, 2 restantes
mtn: mise à jour vers 2aaa51f8afa82b23d85c95843ff4f75efcd3a2b4 frederic.praca@free.fr 20/12/2012 21:51:19
mtn: mise à jour de « bisect.adb »

Et voilà, on vient de préparer la dichotomie. Une petite vérification

fred@dagobah:~/Dev/bisect_test$ mtn bisect status
mtn: 4 révisions en cours de bissection ; 1 bonnes, 1 mauvaises, 0 sautées, 2 restantes
mtn: avertissement : prochaine révision pour le test de bissection est e941bd9f9386dd74860eba21a43b35c064c41425
mtn: avertissement : toutefois, cet espace de travail est actuellement à 2aaa51f8afa82b23d85c95843ff4f75efcd3a2b4
mtn: avertissement : exécutez « bisect update » pour mettre à jour vers cette révision avant de tester

L'outil nous dit même comment faire, si c'est pas du luxe !! :)
Alors, on y va

fred@dagobah:~/Dev/bisect_test$ mtn bisect update
mtn: 4 révisions en cours de bissection ; 1 bonnes, 1 mauvaises, 0 sautées, 2 restantes
mtn: mise à jour vers e941bd9f9386dd74860eba21a43b35c064c41425 frederic.praca@free.fr 20/12/2012 21:50:33
mtn: mise à jour de « bisect.adb »

Si vous avez bien regardé la base de données fournie ou votre propre base, vous vous rendrez compte que la version vers laquelle on a mis à jour n'est pas juste la suivante mais celle qui se trouve au milieu des révisions, de la dichotomie quoi !
On teste et comme ça marche, on le dit à l'outil.

fred@dagobah:~/Dev/bisect_test$ mtn bisect good
mtn: 4 révisions en cours de bissection ; 2 bonnes, 1 mauvaises, 0 sautées, 1 restantes
mtn: mise à jour vers 2aaa51f8afa82b23d85c95843ff4f75efcd3a2b4 frederic.praca@free.fr 20/12/2012 21:51:19
mtn: mise à jour de « bisect.adb »

Et là encore, on se retrouve à mi-chemin entre la dernière bonne et la mauvaise.
Cette fois-ci, on la teste et... Bang !!! Ça part au tapis !!
Encore une fois, on le dit à l'outil

fred@dagobah:~/Dev/bisect_test$ mtn bisect bad
mtn: 4 révisions en cours de bissection ; 2 bonnes, 2 mauvaises, 0 sautées, 0 restantes
mtn: bissection terminée à la révision « 2aaa51f8afa82b23d85c95843ff4f75efcd3a2b4 frederic.praca@free.fr 20/12/2012 21:51:19 »

Et là... Youpi !!! La bissection est terminée, la première version qui a introduit l'erreur est trouvée quand la dernière révision restante est marquée comme mauvaise.
Maintenant, il y a plusieurs options :

Corriger et committer en créant une divergence
Désapprouver avec disapprove la version foireuse

Enfin, il ne faut pas oublier de faire un mtn bisect reset pour retirer les informations de bissection.
Voili, voilou, une bonne façon de retrouver des régressions :D
Amusez-vous bien !

A mort les Spammeeeeeeerrrrrrsssss !!!!!

2012-11-29T16:06:00+01:00

Je suis depuis deux jours la cible de spammers dans les commentaires de mes billets.
C'est pas bien méchant puisqu'il s'agit juste de faire de la pub pour leur site Web de poker en ligne qui n'est même pas du strip-poker.
Ce qui me gêne plus, c'est qu'en fait, j'avais activé toute une série de plugins d'antispam qui sont fournis avec Dotclear mais que ça passait quand même.
En regardant de plus près chacun des plugins dont Akismet, je me suis rendu compte que ceux-ci ne fonctionnaient plus !!
Un coup de moteur de recherches et hop, j'ai eu confirmation de mes craintes.
Tout plugin cherchant à se connecter à un site tiers ne peut le faire en raison des restrictions chez Free.
Pour l'instant, j'ai essayé de gérer par filtrage d'adresses IP mais bon, c'est lourdingue :)
Voilà qui me conduit à l'installation d'un petit outil de captcha qui je l'espère ne vous ennuiera pas trop :-/
D'habitude, j'aime pas trop les captcha parce que c'est difficile à lire et pas franchement daltonien-friendly. Au moins, avec celui-là, je suis tranquille de ce côté-là.

A l'abri dans ma ''Git''-oune

2012-11-26T15:33:00+01:00

D'après Wikipedia, le terme guitoune désigne une tente ou un abri de fortune.
Du coup, y a un petit côté camping au mieux ou au pire, un truc fait de bric et de broc.
Ce que j'aime bien avec la tente, c'est le petit côté communautaire si la tente est grande, un peu comme une yourte. En plus, la tente, c'est le truc où on a l'impression d'être à l'écart du monde^[1] au milieu de nulle part à profiter de la nature, à s'inventer une existence hors des carcans de notre société uniformisante.
Il y a aussi la tente indienne dans laquelle les personnes importantes du clan se retrouvent autour du shaman qui prédit l'avenir et donne les grandes orientations après avoir bien tiré sur le calumet.
Finalement, tout ça représente assez bien ce dont je vais parler maintenant.
Je vous préviens, c'est dense et chiant à lire :D

Notes

[1] ok, sauf au mois d'août dans un camping des Landes ou de la Côte d'Azur :D

Je vous l'avais promis donc je le fais. Parlons de Git.

Lingua Franca!!

Quand on vit dans une grande tente avec tout pleins de copains ou dans un abri de fortune^[1], il est normal de penser à créer une nouvelle société et à adopter de nouveaux rites.
Le mieux est même de prendre le contre-pied total de ce que l'on faisait dans sa vie d'avant.
De là à créer une nouvelle langue, il n'y a qu'un pas... Et ce pas, le créateur de Git l'a franchi^[2].
Vous voulez des exemples ? Que dire, des preuves ???!!!
Histoire de rigoler, faisons un tour sur la page Wikipedia anglaise traitant de la gestion des versions dans sa partie sur le vocabulaire commun à ces outils. En effet, deux exemples très intéressants se cachent là-dedans.

Checkout
Update

A tout seigneur, tout honneur, commençons par Checkout qui se trouve être le premier dans l'alphabet. Que nous dit la définition ?

A check-out (or co) is the act of creating a local working copy from the repository. A user may specify a specific revision or obtain the latest. The term 'checkout' can also be used as a noun to describe the working copy.

Ce terme commun, que l'on retrouve dans moultes systèmes de gestion de version, est utilisé pour désigner l'action de récupérer une révision spécifique depuis le référentiel. Il se trouve que c'est effectivement ce que fait cette commande quand on utilise Subversion, Clearcase, CVS, bazaar^[3] ou Monotone.
Par contre, avec Mercurial, Darcs et finalement le grand inspirateur Git, l'équivalent, c'est la commande clone. Pourquoi pas ?
Là où moi, ça me stresse, c'est quand on ré-utilise ce terme pour faire autre chose.
Ben, tiens, justement, en cherchant la commande revert, spécifique à Subversion, Monotone et Mercurial, je me suis rendu compte que sous Git, on utilise... Checkout. Là aussi, pourquoi pas ?
Le seul truc, c'est que cela permet de le faire sur un seul fichier à la fois donc en toute logique, on utilisera la commande reset pour l'ensemble des modifications non committées dans le référentiel.
Finalement, quand un truc a été committé, il y a moyen de réparer grâce à revert... Et oui, enfin, elle existe cette foutue commande !!!
Malgré la petite digression, continuons parce que ce mot Checkout vaut le coup !
Le switch et l'update de Subversion, Mercurial et Monotone, qui permettent de permuter sa copie de travail vers une autre branche, sont devenus, une fois encore, une autre utilisation de Checkout !!
Bon, pourquoi pas ?^[4]
Voilà, c'est fini pour Checkout, passons au suivant update.
La définition, s'il vous plait ?

An update (or sync) merges changes made in the repository (by other people, for example) into the local working copy. Update is also the term used by some CM tools (CM+, PLS, SMS) for the change package concept (see changelist).

Là, au moins, Git est totalement cohérent avec lui-même. Quand on invente une nouvelle langue, le mieux, c'est de retirer des pans entiers de la langue d'origine.
On aura bien vu que globalement, checkout fait ce que fait update fait chez les autres et même plus.

''Lingua Franca'' était donc un titre bien choisi, une langue faite d'emprunts et connaissant de multiples variations :D

J'ai comme une intuition!!

Vous aurez bien remarqué dans le paragraphe précédent à quel point l'utilisation de git est intuitive et constitue bien une évolution des outils l'ayant précédé. Comme c'est une évolution, regardons les seules nouveautés auxquelles j'ai eu à faire où dont j'ai entendu parler.
D'abord le stash, c'est quoi donc ? C'est un coin de git où on stocke temporairement ce qu'on était en train de faire pour attaquer autre chose C'est une sorte de brouillon que l'on met sur le bord de la table parce que Jean-Claude a un truc super urgent à nous faire faire sur la dernière version.
D'aucun diraient que ce n'est pas grave ils ont une deuxième working copy pointant justement sur la dernière version. Ben non, quand on fait du git, on fait tout au même endroit et on commence plein de trucs en même temps. En effet, l'être humain, il est super fort et il sait s'organiser donc il stashe et il dé-stashe comme un bête^[5]. Et zou, voilà, après dé-stashe, le codeur il retourne faire ce qui lui plaisait tranquillement... Faut pas l'emmerder le codeur !!
Allez, un lien sur le stashing.

Le codeur, il est très fort mais des fois, malgré ses grandes capacités d'organisation, il fait des trucs pas jolis, jolis et il aimerait pas que ça se voit de trop. D'ailleurs, il aime bien aussi montrer qu'il est super fort et qu'il sait commencer des modifications avant que la fonctionnalité existe. Heureusement, git, il a pensé à son ego au codeur, il a la commande rebase.
Cette commande magnifique lui permet de montrer, comme dans l'exemple ici, qu'il a même pas eu besoin de faire de merge et ainsi il peut garder un bel historique bien linéaire avec le poil soyeux. Ben oui, on a beau faire du distribué et dire que on peut faire des branches comme on veut et forker comme des dingues, montrer qu'on a fait une branche qu'on a dû merger, c'est mal.
Si en plus, comble du sale, on a fait tout pleins de commits pas très bien ordonnés, ça va se voir ?
Et non, rebase est ton ami, toi codeur pas toujours très propre sur toi !!
Un petit coup de ''rebase -i'' et le tour est joué !!
Bon, certains verraient ça comme une modification de l'historique mais là, c'est une fonctionnalité... Au risque de choquer, y a guère que les révisionnistes qui ré-arrangent l'histoire... Enfin, bon, quand on lit que Linus regardait Monotone de très près pour finalement cracher dessus comme un goret^[6] (voir là, on se dit que la ré-écriture de l'histoire, c'est bien une fonctionnalité :-(

Je vais finir par un ou deux trucs auquels j'ai eu un peu de mal à me faire.
Si vous voulez committer quelque chose, il faut toujours faire un add avant. C'est con mais c'est comme ça, Git ne le tracera pas tout seul. Il faut placer vos changements dans le staging area^[7] qui est au final une sorte d'index où vous préparez vos commits. Pour moi, le gros inconvénient de la chose est que si on committe plusieurs centaines de fichiers, on peut louper qu'un fichier n'a pas été ajouté. Pire, si vous modifiez puis ajouté puis re-modifiez, il faut refaire un add.

Et enfin, le ponpon pour la fin. CVS ne savait pas gérer les répertoires correctement dans l'historique et tracer les changements effectués sur ceux-ci ce qui a conduit à l'utilisation de Subversion. Et bien, sachez, mes chers amis, que git ne sait pas le faire non plus !!
Enfin, autant tout le monde hurlait quand CVS ne savait pas le faire, autant on n'entend plus personne là-dessus quand il s'agit de git...

Conclusion!!

Bon, mon expérience avec git, sans avoir été désagréable, n'a pas non plus été la révolution annoncé en termes de gestion de versions. Se familiariser avec la gestion de versions distribuée est déjà une étape en soi pour ce qui est de la compréhension de l'architecture donc si on doit rajouter à ça, l'apprentissage d'un outil qui, bien que très puissant, n'est absolument pas intuitif, bonjour les dégâts.
J'aurais pu parler de la complexité de l'outil vu que le nombre de commandes, d'options, de comportements différents pour une même commande est assez effarant mais je préfère mettre ça sur le compte des nombreuses fonctionnalités. Pour l'anecdote, j'ai un jour lu sur un blog que git ne se composait que de 3 exécutables^[8] mais soyons un peu honnêtes, git comporte 21 sous-commandes dont les options peuvent modifier le comportement de façon drastique.
Enfin, il y a une mention spéciale pour les pages de manuel pour leur clarté toute relative mais qui heureusement sont truffées d'exemples.

Bon, quelques recommandations :

lisez le git book
faites des choses simples
utilisez l'outil pour ce qu'il est, une gestion de versions et donc un outil d'aide au développeur pas une fin en soi

Voilà, c'est fini, j'en suis crevé tiens !!

Notes

[1] Comme dans les babas-cool

[2] Vous remarquerez que pour éviter de rameuter un troupeau de zealot, je ne donne pas son nom :)

[3] A vérifier quand même tellement la doc est obscure sur ce point

[4] Vous remarquerez qu'on se rapproche de plus en plus du sketch de la chauve-souris de Bigard avec son Bon bah, admettons !!

[5] Ou K2R qui est bien connu pour être un grand destasheur

[6] Si Linus était fair-play, ça se saurait !

[7] qui n'a rien à voir avec le stash

[8] contre plus d'une centaines dans les premières versions !!

C'est moi que j'ai la plus grosse !!

2012-11-23T15:26:00+01:00

Bien que ce soit la vérité, ce n'est pas de ce que tu crois, ô lecteur pervers et lubrique, que je vais parler.
Certes, il y a analogie mais je viens te parler ici et maintenant d'un site souvent fréquenté et peu critiqué... Pourtant, il mériterait de l'être.

Si c'est pas du teasing ça !!!

Ce site, c'est le Computer Language Benchmarks Game.
Les non-initiés disent déjà :

Cékoidonk ??

Simple, c'est une comparaison de langages de programmation pour des programmes identiques sur des machines identiques... Enfin, ça, c'est la théorie !
Regardons d'un peu plus près.

Déjà, ça part mal puisque quatre types de machines servent aux tests, leur différence étant sur le nombre de bits et le nombre de cœurs.
On peut se dire que déjà la phrase qui dit :

We are trying to show the performance of various programming language implementations - so we ask that contributed programs not only give the correct result, but also use the same algorithm to calculate that result.

Va largement foirer quand on voit la différence qu'il y a entre penser un programme en mono-tâche ou en multi-tâche.
Toujours dans le programme Mandelbrot, si l'on y prête bien attention, on voit que le C ne possède rien que 7 entrées^[1], l'Ada 3 et le C++ 8.
Diantre !!!! On peut donc écrire le même algorithme de 8 façons différentes ???
A part, en changeant le nom des variables et l'ordre de certaines lignes, c'est quand même chaud.
Alors qu'est-ce qu'il se passe ?
Prenons la version C arrivant en premier. Attention, ça va aller très vite

#pragma omp parallel for
    for (i = 0; i < N; i+=2) {
        v2df Crv = { (i+1.0)*inverse_w-1.5, (i)*inverse_w-1.5 };
        Crvs[i >> 1] = Crv;
    }

C'est quoi ce pragma ? Et bien, c'est simple, il s'agit de l'utilisation d'OpenMP.
La question que l'on est en droit de se poser est :

Est-ce vraiment le même algo que la version standard en C ?

D'ailleurs, elle contient quoi la version standard ?

for (i = 0; i < NWORKERS; i++)
        pthread_create(&ids[i], NULL, worker, NULL);

Des threads !!! Ben, ça fait pas non plus partie de la norme C tout ça.

Et en Ada, ça donne quoi ? Et bien, sur cet exemple-là, ça va mais ce n'est pas le cas de celui-là où on trouve, sans complexe

pragma Import (Intrinsic, "+", "__builtin_ia32_addpd");
   pragma Import (Intrinsic, "*", "__builtin_ia32_mulpd");
   pragma Import (Intrinsic, "/", "__builtin_ia32_divpd");

ou comment faire des appels système non prévu dans le langage^[2].

Bon, je ne vais pas décortiquer tous les exemples mais cela reflète bien la guerre sainte des langages.
Malgré les consignes demandant de suivre le même algorithme, une grande partie du code fourni contient des éléments afin d'optimiser à mort le code, quitte à le rendre illisible, mais à gagner la guerre.

Ceci dit, après mon excellent ticket sur Ruby, je peux quand même dire que les langages de script sont à la ramasse mais c'est NORMAL !!!
On ne leur demande pas de la performance.

Notes

[1] si j'ai bien regardé

[2] bien que l'utilisation d'Import le soit

Release often... Enfin, presque

2012-11-21T00:48:00+01:00

Bon, je sais plus trop si je vous ai déjà filé une version de mon excellent petit soft de gammes et accords que j'ai décidé de nommer Scalada.
Comme mon pote Albert^[1] me guette, voici donc cette masterpiece of code :D
C'est sous licence BSD modifiée, histoire d'être compatible GPL et c'est fourni en l'état.
Mais comme je suis gentil, vous trouverez à la fois l'archive proprement dite ainsi que le référentiel Monotone^[2] pour naviguer dans l'historique et voir ainsi mes errements.
Vous pourrez même contribuer activement... Si je veux bien accepter vos pull requests :)

Notes

[1] Zheimer dit Al Zheimer

[2] En version 1.0 me semble-t-il