The JavaScript Disciplines
Discipline 1: AJAX with XHR
Discipline 2: Dynamic JS with PHP
Discipline 3: Include External JS
Discipline 4: Cookies and Variables
Discipline 5: removeNode vs. removeChild
Discipline 6: Native Javascript Ninjutsu: DOMinating iframes

"XDRTB.org is an extraordinary effort to tell the story of extremely drug-resistant tuberculosis (XDR-TB) and TB through powerful photographs taken by James Nachtwey. XDR-TB, or extremely drug-resistant tuberculosis, is a new and deadly mutation of tuberculosis. Similar in creation to multidrug-resistant tuberculosis (MDR-TB) but more extreme in its manifestation, it arises when common tuberculosis goes untreated or standard TB drugs are misused. James’ photographs represent these varying strains. Learn more about TB, MDR-TB and XDR-TB, and learn how you can take action to stop this deadly disease."

Imports

Before starting about conversions and other problems I would like to add a note on imports of packages as this was one of the things that I was struggling in combination with the type conversion. There are several import possibilities. The most basic one is to import the package by just using the import statement. This just imports the package as is with private visibility to the module. It is possible to define the visibility by adding a prefix to the import statement. These prefix can be the same as for functions and methods. Additionally it is possible to create a new namespace for the imported symbols. That way you can access the imported functions with your own given identifier, which can be helpful for clarity and for separation of interfaces that use multiple overridden classes. Another possibility to avoid name collisions is to use static imports. In case a static import is made the package needs to be accessed by its fully qualified name, eg. tango.text.convert.Integer.format(). Below you see some import examples with comments:

// basic import; has private visibility by default import tango.text.convert.Integer; // basic import with public visibility public import tango.text.convert.Integer; // renamed imports private import Integer = tango.text.convert.Integer; private import Float = tango.text.convert.Float; // selective Imports, that imports only the format function private import tango.text.convert.Integer : format; // selective Imports, that imports only the format // function and makes them available as convert private import Integer = tango.text.convert.Integer : convert = format; //static import, means to always use the fully // qualified name of the symbol static tango.text.convert.Integer;

Type conversions

Tango provides some helpful functions, for handling type conversions. They can be found in the Tango.text package and allow easy conversions between types, while still providing enough parameter to convert types very specifically if needed. I took me some time to figure out how to use the package as documentation and examples are scarce. So here are some examples how to easily convert integer in strings and back. I used to import the package with renamed import to have a clear separate namespace.

private import Integer = tango.text.convert.Integer; char[] cnumber = "12"; int number; // convert string into integer number = Integer.parse(cnumber); // convert integer into string cnumber = Integer.toString(number);

Function returns

This is another issue which I became quite used to with PHP. In PHP it is easy to return an object, array, integer, string or whatever you want with a function, but at the same time you can return also a bool. It is not specified what you return from a function, because nothing is typed. So it became common practice to me to return false instead of the actual value, if something went wrong in the function. This way I used to handle the errors, because I could handle the error where the function was called, instead of handling it in the function itself.
This is not working that way in the D, because everything is typed ;). So you need to specify what type is returned by the function. In consequence it means I need to reconsider my error handling strategy. Everything needs to be handled within the function itself.

Dynamic Arrays

Although there are dynamic arrays in D, they don't behave like dynamic array's in PHP. I was used to fill PHP arrays with the following code:

foreach($names as $name) { $surnames[] = $name['surname']; }

But in D dynamical arrays are not as dynamic as in PHP. You can create dynamic arrays, but the only difference to static arrays is that you can read and write the length of the array. It is not possible to easily add a new element to array. You need to change the size of the array first to add a new element. This is a bit clumsy, but there are solutions. Tango provides a package called collections tango.util.collection, where several different collection implementations, which are similar to some from Java. There are basically four different implementations: Bags, Set, Sequences and Maps. To solve my problem I used sequences. You can see the example below:

private import tango.util.collection.ArraySeq; for (int i=0; i<10; ++i) { ArraySeq!(int) sequence = new ArraySeq!(int); sequence.append(i); } // get the 4th element (remember the 0) int number = sequence.get(3); // converting sequence into array int sequence_array[] = sequence.toArray(); int length = sequence_array.length;

I couldn't find a method in the sequence implementation that returns the length of the sequence. This is why I needed to convert the sequence in an array in order to get the length, which I needed for another for loop.

Object Orientation

One last bit at the end. What I found a bit strange was that it was possible to reference to methods within a class without the this statement. It didn't made a difference calling a function with this or not.

class SomeClass { uint limit = 1000; public int doSomething() { long some_id; // without this statement some_id = _doLoop(); // with this statement some_id = this._doLoop(); // leads to exact the same } private int _doLoop() { // do something } }

Basic Installation

The easiest way to install D is to use the Tango compilation. It includes the compiler and the Tango general-purpose companion library for the most basic tasks. The compiler as well as the library are open source.

1. Download the Tango package, which you find here:
   http://www.dsource.org/projects/tango/wiki/DmdDownloads.
2. The next step is to copy the content of the tar.gz file to: /usr/local/dmd
3. In order to use the dmd compiler from everywhere you need to either create a new .bash_profile or to add the following lines to the .bash_profile file:
   
   PATH=$PATH:/usr/local/dmd/bin
export PATH

   
   Alternatively you can create symlinks for all programs within the /usr/local/dmd/bin directory in the /usr/bin/ directory.
4. Now you should download and install the DSSS (the D Shared Software System), which helps you to build your programs and helps installing, configuring and acquiring additional D software. It is comparable to Perl's CPAN and PHP' PEAR system.
   You can download DSSS from:
   http://svn.dsource.org/projects/dsss/downloads/.
   
5. Copy the content of the tar.gz file to /usr/local/dmd.
6. In order to use DSSS with Tango you need to customize the following file:
   usr/local/dmd/etc/rebuild/default
   
   Replace
   
   profile=dmd-posix
   
   with
   
   profile=dmd-posix-tango
   
7. That's it. You should now be able to write your own D code and compile it to a program.

MySQL Support

In order to connect to mysql you need to install the DDBI (D DBI), a database independent interface for the D programming language.

1. First you need to download the latest D DBI sources from the SVN server. I couldn't get in running with the download on the web page.
   Go to the directory where you store or your installation files or your home directory and type in:
   
   svn co http://svn.dsource.org/projects/ddbi/trunk
   
   This will get all the necessary files from the SVN repository.
2. The only thing you need to do to install the D DBI is to copy the complete directory into the lib/import directory of your D directory. If you followed the installation steps above this would be /usr/local/dmd/lib/import/.
   
   cp /install/D/ddbi/trunk /usr/local/dmd/lib/import
3. That's basically it. The only think you need to to now is to tell DSSS where your mysql client library is. Normally you use the following line:
   
   dsss build -version=dbi_mysql -L/usr/local/mysql/lib/mysql/mysqlclient.so.15.0.0
   
   If you use a MySQL version newer then 5.0 you need to add another version info:
   
   dsss build -version=MySQL_51 -version=dbi_mysql -L/usr/local/mysql/lib/mysql/mysqlclient.so.15.0.0

MySQL Example

1. Create a project directory where you want to store your code
2. Create a DSSS config file with this project directory, with the following content:
   
   name=mysql [mysql.d] target=mysql_test
   
   
3. Create a source file with the following sample code:
   
   import dbi.mysql.MysqlDatabase; import dbi.Row; import tango.io.Stdout; int main () { Stdout("Connecting to mysql database").newline; MysqlDatabase db = new MysqlDatabase(); db.connect("host=****;dbname=****", "****", "****"); Row[] rows = db.queryFetchAll("SELECT * FROM example"); foreach( Row row; rows) { Stdout("example: ")(row["****"]).newline; } db.close(); return 0; }
   
   
4. If the file is save run dsss build within the project directory:
   
   dsss build -version=dbi_mysql -L/usr/local/mysql/lib/mysql/mysqlclient.so.15.0.0
5. If compilation is finished you should find an executable file called mysql_test within your project directory.