It is very simple, and shall just enable you to get started.
The test is made for the "Komplexpraktikum" / kpr / kpr2007 / complex lab course, offered by the operating systems chair
at TU-Dresden

The commands are in (), file contents are between
-------
-------

1. Change into "kpr2007/build" directory (cd kpr2007/build)

2. Type "make" to build the complete environment. It should complete without errors. (make)

3. Change into "kpr2007/src/kpr" directory. (cd ../src/kpr)

4. Create a directory that corresponds to your planned package. (mkdir server-demo)

5. Change into your new directory

6. The easiest way to start writing your server, is taking the package template, provided by the build system.
   To do so run the script in kpr2007/src/mk/tmpl/inst (../../mk/tmpl/inst)

7. You have now a basic skeleton to start. Check with (ls). 
   The directory "include" takes your include files, that are going to be used by clients.
   The directory "lib" contains the libraries, that are going to be used by the clients. They handle the protocoll and IPC.
   	You export IPC and protocol functionality into libraries, because you do not want to 
	implement this for each client that want to use the server again, and again, and again,....
   The directory "server/src" takes the main server program code

8. Change into "server/src" directory. (cd server/src), and edit the server code [in this case only "main.cc"] with your favourite editor. 
   I use vim-editor, and it is really worth learing using it.
   This demo server will wait for clients. As soon, as they send him a number via ipc, the server increases it, and sends it back.
   Although the file is called ".cc", I use plain C, because I dislike C++
   -----------main.cc-------
    #include     // you need it for basic type definitions
    #include  // use this for easier D-bugging
    #include     // this provides the basic ipc function calls

    //#include "demo.h"           // put your own include files into local directory

    int main()
    {
 
       fiasco_register_thread_name( l4_myself(), "DEMO" ); // Have a name appear in the debugger
 
       l4_threadid_t  id;		// This is a threadid
       l4_umword_t    rcv0, rcv1;	// Those are the 32 Bit-words
       l4_msgdope_t   result;		// This is to store wether an IPC went wrong or not
 
       for(;;) { //endless loop. We wait until a client appears
  
          // This is the simplest way of IPC: short IPC. You can transfer 2x32 bit
          // values. Take a look at documentation to get further information at
          // kpr2007/doc/html/l4sys-l4v2/index.html -> API -> IPC
          l4_ipc_wait( &id, L4_IPC_SHORT_MSG, &rcv0, &rcv1, L4_IPC_NEVER, &result);
  
          if( L4_IPC_IS_ERROR(result) ) {     // Just in case there is an error. It should not happen.
             return -1;                       // add better errorcode here, please
          }                                   // look into documentation. Result carries a lot information.
  
          // We answer the client. 2nd 32 bit are 0 in this case.
             // ! no error checking, etc. We suppose nice behaviour in this example
          l4_ipc_send( id, L4_IPC_SHORT_MSG, rcv0+1, 0, L4_IPC_NEVER, &result);
  
       }
 
      return 0;
    }
   -----------main.cc------- 



9. Change into "include" dir, and edit the servers include files [in this case "demo.h"]
   The include files are used by the clients later, and should provide the header to the library functions.
   ----------demo.h----------
   #ifndef __DEMO_H_ //to prevent double includes
   #define __DEMO_H_
  
   unsigned long call_demo_server( unsigned long ); // this function will be used by clients, later

   #endif
   ----------demo.h----------

A. Now change into "lib/src" directory (cd ../lib/src). Edit "libdemoserver.cc"
   --------libdemoserver.cc---------
   #include 
   #include 
   #include  //our demofile

   int call_demo_server( unsigned long a ){
	l4_threadid_t 	id;
	l4_umword_t 	rcv0,rcv1;
	l4_msgdope_t	result;

	id.id.task = 8; 	// This is a hack, to address the first task started by the system.
	id.id.lthread = 0;	// In future you can use your nameserver for this.

	// We send a message a message to task number 8.0, using short IPC.
	// the first register is filled with a, the second is 0
	l4_ipc_send( id, L4_IPC_SHORT_MSG, a, 0, L4_IPC_NEVER, &result);

	if (L4_IPC_IS_ERROR(result)) {
		return -1;	// Improve the errorhandling in your programs
	}
	
	// we only wait for a special answer -> receive
	// see documentation for explanation
	l4_ipc_receive( id, L4_IPC_SHORT_MSG, &rcv0, &rcv1, L4_IPC_NEVER, &result);

	return rcv0;	
   }
   
   --------libdemoserver.cc---------

B. Edit the "Makefile".
   --------Makefile---------------
   
   PKGDIR?= ../..
   L4DIR ?= $(PKGDIR)/../..
   
   # the name of your library
   TARGET  = lib$(PKGNAME).a
   
   # list your .c files here
   SRC_C   =
   SRC_CC  = libdemoserver.cc # here is the change you should make
   # if your library implements the client side of an idl defined in an
   # idl-file of your package, list the idl file name(s) here (no path needed)
   CLIENTIDL =
   
   include $(L4DIR)/mk/lib.mk
   --------Makefile---------------

C. Now the programming is done. Change to "kpr2007/build" directory. Type (make l4kpr) to only let the kpr packages build.
   Have a look into the "Makefile" to see, how to build single packages.


D. The server is done. We now implement the client. For this, please create a new package, "client-demo" in "kpr2007/src/kpr/"
   (mkdir client-demo; cd client-demo; ../../mk/tmpl/inst; cd server/src). Edit the code for the client. 
   Also change the "Makefile", that it includes the server-demo library.
   ----------main.cc----------
   #include 

   main(){

	   unsigned long a = call_demo_server(5);

	   return a;
   }
   ----------main.cc----------

E. Change back into the build directory. Let the client-demo package build. If you made no changes to the Makefile go with
   (make l4kpr) again. Edit "start"-script. 
   -----------main.cc---------
   #!/bin/sh

   FILES="local_rm server-demo client-demo"    #we only need root_rm (region manager for root-server) and our client/server
   ROOTARGS="rom/server-demo rom/client-demo"  # here as well
   #ROOTARGS="rom/aw-example-ipc2"

   FIASCODIR=./fiasco
   FIASCO=${FIASCODIR}/fiasco
   BINDIR=./l4/bin/x86_586/l4v2

   for f in ${FILES}; do
     ARGS="${ARGS} -l ${BINDIR}/$f"
     done


     ${FIASCO} -I ${FIASCODIR}/irq0 -S ${BINDIR}/sigma0 \
               -F ${FIASCODIR}/ux_con \
	       -R ${BINDIR}/root-server" ${ROOTARGS}" \
		${ARGS} -G800x600@16
   ----------main.cc----------

F. You are done. You have done the first short IPC client/server couple with L4/Fiasco. congratulations.
   You start everything by being in the build dir and entering (./start). The output of our program is ''. 
   But it works. Programming the output is your part.

10. Now go on, read documentation, _read source_ [you won't come around this], program, try, debug 
   - do just anything to get closer to L4/fiasco. Learn about long ipc, memory mapping, etc.