The software developers at ECA Technologies specialize in designing the applications to meet a company's specific needs and business requirements. Using proven practices that allow for successful project completion, ECA Technologies delivers best software solutions that far exceed customer expectations. ECA specializes in custom software development services in USA and Canada. Also is in partnership with Web Design Mississauga company for optimum solutions.

Top 10 Most Usable Content Management Systems

Posted by admin | Uncategorized | Tuesday 22 December 2009 12:53 am

1. WordPress

What is there left to say about WordPress that hasn’t already been said? The PHP blogging platform is far and away the most popular CMS for blogging, and probably the most popular CMS overall. It’s a great platform for beginners, thanks to their excellent documentation
and super-quick installation wizard. Five minutes to a running CMS is pretty good. Not to mention the fact that the newest versions auto-update the core and plugins from within the backend, without having to download a single file.

For those users not familiar with HTML or other markup language, a WYSIWYG editor is provided straight out of the box. The backend layout is streamlined and intuitive, and a new user should be able to easily find their way around the administration section. Wordpres also comes with built-in image and multimedia uploading support.

For developers, the theming language is fairly simple and straightforward, as well the Plugin API.

The WordPress Community is a faithful and zealous bunch. WordPress probably has the widest base of plugins and themes to choose from. A great part about the WordPress community is the amount of help and documentation online you can find on nearly every aspect of customizing WordPress. If you can dream it, chances are it’s already been done with WordPress and documented somewhere.

2. Drupal

Drupal is another CMS that has a very large, active community. Instead of focusing on blogging as a platform, Drupal is more of a pure CMS. A plain installation comes with a ton of optional modules that can add lots of interesting features like forums, user blogs, OpenID, profiles and more. It’s trivial to create a site with social features with a simple install of Drupal. In fact, with a few 3rd party modules you can create some interesting site clones with little effort.

One of Drupal’s most popular features is the Taxonomy module, a feature that allows for multiple levels and types of categories for content types.

Drupal also has a very active community powering it, and has excellent support for plugins and other general questions.

3. Joomla!

Joomla is a very advanced CMS in terms of functionality. That said, getting started with Joomla is fairly easy, thanks to Joomla’s installer. Joomla’s installer is meant to work on common shared hosting packages, and is a very straightforward considering how configurable the software is.

Joomla is very similar to Drupal in that it’s a complete CMS, and might be a bit much for a simple portfolio site. It comes with an attractive administration interface, complete with intuitive drop-down menus and other features. The CMS also has great support for access control protocols like LDAP, OpenID and even Gmail.com.

The Joomla site hosts more than 3,200 extensions, so you know the developer community behind the popular CMS is alive and kicking. Like WordPress, you can add just about any needed functionality with an extension. However, the Joomla theme and extension community relies more on paid plugins and themes, so if you’re looking for customizations, be ready to pay.

4. ExpressionEngine

ExpressionEngine (EE) is an elegant, flexible CMS solution for any type of project. Designed to be extensible and easy to modify, EE sets itself apart in how clean and intuitive their user administration area is. It takes only a matter of minutes to understand the layout of the backend and to start creating content or modify the look. It’s fantastic for creating websites for less-than-savvy clients that need to use the backend without getting confused.

ExpressionEngine is packed with helpful features like the ability to have multiple sites with one installation of software. For designers, EE has a powerful templating engine that has custom global variables, custom SQL queries and a built in versioning system. Template caching, query caching and tag caching keep the site running quickly too.

One of my favorite features of EE that is the global search and replace functionality. Anyone who’s ever managed a site or blog knows how useful it is to change lots of data without having to manually search and open each page or post to modify it.

ExpresssionEngine is quite different than other previously-mentioned CMS in that it’s paid software. The personal license costs $99.95, and the commercial license costs $249.99.

5. TextPattern

Textpattern is a popular choice for designers because of its simple elegance. Textpattern isn’t a CMS that throws in every feature it can think of. The code base is svelte and minimal. The main goal of Textpattern is to provide an excellent CMS that creates well-structured, standards-compliant pages. Instead of providing a WYSIWYG editor, Textpattern uses textile markup in the textareas to create HTML elements within the pages. The pages that are generated are extremely lightweight and fast-loading.

Even though Textpattern is deliberately simple in design, the backend is surprisingly easy to use and intuitive. New users should be able to find their way around the administration section easily.

While Textpattern may be very minimal at the core level, you can always extend the functionality by 3rd party extensions, mods or plugins. Textpattern has an active developer community with lots of help and resources at their Textpattern.org site.

6. Radiant CMS

The content management systems that we’ve listed so far are all PHP programs. PHP is the most popular language for web development, but that doesn’t mean we should overlook other popular web languages like Ruby. Radiant CMS is a fast, minimal CMS that might be compared to Textpattern. Radiant is built on the popular Ruby framework Rails, and the developers behind Radiant have done their best to make the software as simple and elegant as possible, with just the right amount of functionality. Like Textpattern, Radiant doesn’t come with a WYSIWYG editor and relies on Textile markup to create rich HTML. Radiant also has it’s own templating language Radius which is very similar to HTML for intuitive template creation.

7. Cushy CMS

Cushy CMS is a different type of CMS altogether. Sure, it has all the basic functionality of a regular content management system, but it doesn’t rely on a specific language. In fact, the CMS is a hosted solution. There are no downloads or future upgrades to worry about.

How Cushy works is it takes FTP info and uploads content on to the server, which in turn the developer or the designer can modify the layout, as well as the posting fields in the backend, just by changing the style classes of the styles. Very, very simple.

Cushy CMS is free for anyone, even for professional use. There is an option to upgrade to a pro account to use your own logo and color scheme, as well as other fine-grain customizations in the way Cushy CMS functions.

8. SilverStripe

SilverStripe is another PHP CMS that behaves much like WordPress, except has many more configurable options and is tailored towards content management, and not blogging. SilverStripe is unique because it was built upon its very own PHP framework Saphire. It also provides its own templating language to help with the design process.

SilverStripe also has some interesting features built in to the base, like content version control and native SEO support. What’s really unique with SilverStripe is that developers and designers can customize the administration area for their clients, if need be. While the development community isn’t as large as other projects there are some modules, themes and widgets to add functionality. Also, you’ll want to modify the theme for each site, as SilverStripe doesn’t provide much in terms of style, to give the designer more freedom.

9. Alfresco

Alfresco is a JSP is a beefy enterprise content management solution that is surprisingly easy to install. A really useful feature of Alfresco is the ability to drop files into folders and turn them into web documents. Alfresco might be a little bit more work than some of the other CMS and isn’t as beginner-friendly, it certainly is quite usable given the massive power of the system. The administration backend is clean and well-designed.

While Alfresco might not be a great choice for most simple sites, it’s an excellent choice for enterprise needs.

10. TYPOlight

TYPOlight seems to have the perfect balance of features built into the CMS. In terms of functionality, TYPOlight ranks with Drupal and ExpressionEngine, and even offers some unique bundled modules like newsletters and calendars. Developers can save time with the built-in CSS generator, and there are plenty of resources for learning more about the CMS.

If there is a downside to TYPOlight, it’s that it has so many features and configurable options. Even though the backend is thoughtfully organized, there are still a lot of options to consider. But if you’re wanting to build a site with advanced functionality and little extra programming, TYPOlight could be a great fit.

Java programming language

Posted by admin | Systems Applications | Tuesday 22 December 2009 12:48 am

virtual machine, a program written in native code on the host hardware that translates generic Java bytecode into usable code on the hardware. Further, standardized libraries are provided to allow access to features of the host machines (such as graphics and networking) in unified ways. The Java language also includes support for multi-threaded programs–a necessity for many networking applications.

The first implementations of the language used an interpreted virtual machine to achieve portability, and many implementations still do. These implementations produce programs that run more slowly than the fully-compiled programs created by the typical C++ compiler and some later Java language compilers, so the language suffered a reputation for producing slow programs. More recent implementations of the Java VM produce programs that run much faster, using multiple techniques.

The first of these is to simply compile directly into native code like a more traditional compiler, skipping bytecodes entirely. This achieves great performance, but at the expense of portability. Another technique, the just-in-time compiler or “JIT”, compiles the Java bytecodes into native code at the time the program is run. More sophisticated VMs even use dynamic recompilation, in which the VM can analyze the behavior of the running program and selectively recompile and optimize critical parts of the program. Both of these techniques allow the program to take advantage of the speed of native code without losing portability.

Portability is a technically difficult goal to achieve, and Java’s success at that goal is a matter of some controversy. Although it is indeed possible to write programs for the Java platform that behave consistently across many host platforms, the large number of available platforms with small errors or inconsistencies led some to parody Sun’s “Write once, run anywhere” slogan as “Write once, debug everywhere”.

Secure execution of remote code

The Java platform was one of the first systems to provide wide support for the execution of code from remote sources. An applet could run within a user’s browser, executing code downloaded from a remote HTTP server. The remote code runs in a highly restricted “sandbox”, which protects the user from misbehaving or malicious code; publishers could apply for a certificate that they could use to digitally sign applets as “safe”, giving them permission to break out of the sandbox and access the local filesystem and network, presumably under user control.

Evaluation

In most people’s opinions, Java technology delivers reasonably well on all these goals. The language is not, however, without drawbacks.

Java tends to be more high-level than similar languages (such as C++), which means that the Java language lacks features such as hardware-specific data types, low-level pointers to arbitrary memory addresses, or programming methods like operator overloading. Although these features are frequently abused or misused by programmers, they are also powerful tools. However, Java technology includes Java Native Interface (JNI), a way to call native code from Java language code. With JNI, it is still possible to use these features.

Some programmers also complain about its lack of multiple inheritance, a powerful feature of several object-oriented languages, among others C++. The Java language separates inheritance of type and implementation, allowing inheritance of multiple type definitions through interfaces, but only single inheritance of type implementation via class hierarchies. This allows most of the benefits of multiple inheritance while avoiding many of its dangers. In addition, through the use of concrete classes, abstract classes, as well as interfaces, a Java language programmer has the option of choosing full, partial, or zero implementation for the object type he defines, thus ensuring maximum flexibilty in application design.

There are some who believe that for certain projects, object orientation makes work harder instead of easier. This particular complaint is not unique to the Java language but applies to other object-oriented languages as well.

Language

An example of a hello world program in the Java language follows:

public class HelloWorld {
public static void main(String[] args) {
System.out.println(“Hello world!”);
}
}

Control structures

Loops

while (Boolean expression) {
statement(s)
}

do {
statement(s)
} while (Boolean expression);

for (initialisation ; termination condition ; incrementing expr) {
statement(s)
}

Conditional statements

if (Boolean expression) {
statement(s)
}

if (Boolean expression) {
statement(s)
} else {
statement(s)
}

With else if arbitrarily complex if-then-constructions may be built.

if (Boolean expression) {
statement(s)
} else if (Boolean expression) {
statement(s)
} else if (Boolean expression) {
statement(s)
} else {
statement(s)
}

switch (integer expression) {
case constant integer expr:
statement(s)
break;

default:
statement(s)
break;
}

Exception handling

try {
statement(s)
} catch (exception type) {
statement(s)
} catch (exception type) {
statement(s)
} finally {
statement(s)
}

Goto statements

It is possible to put a label before any statement

myLabel: aJavaStatement;

The command

break;

terminate the current loop.

The label may be used to jump out of a inner for, while or do-loop

break myLabel;

A continue-expression terminates the current interation step and starts the next one

continue;

In addition with

continue label;

program control may be handed directly to an outer loop.

The statement

return;

terminates a method.

With

return aValue;

aValue may be given back to the calling method.

Primitive data types

Variable Type Description
byte 8-bit signed (two’s complement) integer
short 16-bit signed (two’s complement) integer
int 32-bit signed (two’s complement) integer
long 64-bit signed (two’s complement) integer
float 32-bit single-precision floating point (IEEE 754 standard)
double 64-bit double-precision floating point (IEEE 754 standard)
char 16-bit single Unicode character
boolean true or false

Characters use the 16-bit Unicode encoding. It contains all of the usual characters, but also includes character sets for many languages other than English, including Greek, Cyrillic, Chinese, Arabic, etc. Java programs can use all of these characters, although most editors do not have built-in support for character sets other than the usual ASCII characters. Arrays and strings are not primitive types: they are objects.

Versions

* JDK 1.0 1996, Solaris, Windows, MacOS Classic, Linux
* JDK 1.1 1997, Solaris, Windows, MacOS Classic, Linux
* JDK 1.2 1998, Solaris, Windows, Linux, ?
* JDK 1.3 2000 (also known as Java 2), Solaris, Windows, MacOS X, Linux
* JDK 1.4 2002, Solaris, Windows, MacOS X, Linux
* JDK 1.5 2003 (yet to be released)

Java was initially released as the Java Development Kit 1.0 (JDK 1.0). This included the Java runtime (the virtual machine and the class libraries), and the development tools (e.g. the Javac compiler). Later, Sun also provided a runtime-only package, called the Java Runtime Environment (JRE). The first name stuck, however, so usually people refer to a particular version of Java by its JDK version (e.g. JDK 1.4). The JDKs of version 1.2 and later versions are often called Java 2 as well. For example, the official name of JDK 1.4 is The Java(TM) 2 Platform, Standard Edition version 1.4.

The language as such has been stable since JDK 1.0; the class libraries that come with the JDK got larger and have changed in some parts. Extensions and architectures closely tied to the Java programming language include: J2EE, J2ME, JNDI, JSML, JDBC, JAIN, JDMK[?], Jini[?], Jiro[?], JXTA, JavaSpaces[?], JMI[?].

1.5 (codename[?] Tiger) is scheduled to be released in late 2003. Major changes include:

* Generics – Provides compile-time type safety for collections and eliminates the drudgery of casting.
* Autoboxing/unboxing – Eliminates the drudgery of manual conversion between primitive types (such as int) and wrapper types (such as Integer).
* Metadata – Lets you avoid writing boilerplate code, by enabling tools to generate it from annotations in the source code. This leads to a “declarative” programming style where the programmer says what should be done and tools emit the code to do it.

(from [1] (http://java.sun.com/features/2003/05/bloch_qa))

Interpreted version

There is an interpreted version of Java called beanshell which may be used as a shell scripting language. The interpreter may be embedded in a Java application to make it scriptable.

A good starting point for learning Java is the Sun tutorial on Java Programming, found at http://java.sun.com/docs/books/tutorial/.

Another very helpful page for beginners and experts alike is the current Java Syntax page for the latest Java API, Java 2 v1.4.2, also from the Sun site, found at http://java.sun.com/j2se/1.4.2/docs/api/

See also

* Java platform
* Java API
* Java virtual machine
* gcc (includes a Java to machine language compiler)
* Comparison of Java to C++.
* JINI
* Eclipse (Open source IDE)
* NetBeans (Another open source IDE)
* Optimization of Java

PHP programming language

Posted by admin | Systems Applications | Tuesday 22 December 2009 12:46 am

The computer language PHP (originally “Personal Home Page”, but now a recursive acronym for “PHP Hypertext Preprocessor”) is a widely used open-source programming language used primarily for server-side applications, to develop dynamic web content such as the Wikipedia software. It can be seen as an open source alternative to Microsoft’s Active Server Pages (ASP) system and to the similar CGI/Perl system.

Its ease of use and similarity with the most common structured programming languages, most notably C, Java and Perl, allows most experienced programmers to start developing complex applications with a minimal learning curve. It also enables experienced developers to get involved with dynamic web content applications without having to learn a whole new set of functions and practices.

One of the more attractive parts of PHP is that it is not only a scripting language. Because it has been designed from the start to be modular, the PHP core system has been used to develop desktop applications that are close to the same performance as traditional C++ compiled applications, and it can be used from the command line just like Perl or Python.

PHP allows, among other things, easy interaction with a very large number of relational database systems (Oracle[?], DB2, MySQL, PostgreSQL, etc.), while maintaining a simple and straightforward syntax. PHP runs on every major operating system, including Unix, Linux, Windows, and Mac OS X and can interact with all major web servers. The PHP website (php.net) has some of the best documentation pages of any project, and has lots of help with setting up PHP on obscure operating systems and web-servers. The Linux, Apache, MySql, PHP (LAMP) architecture has become very popular in the industry for deploying reliable, scalable and secure web applications.

PHP is the result of the collective efforts of many contributors. It is licensed under a BSD-style license, the PHP license (http://www.php.net/license/3_0.txt).

Table of contents
1 PHP’s Libraries
2 History
3 Popularity of PHP
4 Related Articles
5 External Links

PHP’s Libraries

PHP, unlike ASP and Perl, has some of the largest free and open-source libaries included with the core build. PHP is a fundamentally internet-aware system and as such there are modules built in for accessing FTP servers, all manners of database servers, LDAP servers and much more. What’s more the most used functions such as printf(), str_replace(), preg_match() from C are all available from PHP.

PHP has a wide variety of extensions such as support for the Windows API, Process Management on Linux, cURL support, ZIP and GZip support. Some of the more unique features are PDF generation, Shockwave Flash generation (on the fly), integration with IRC and much more besides.

History

PHP was originally designed as a wrapper around Perl by Rasmus Lerdorf in 1994 to display his resume information, and collect some data, such as how many hits it was generating. Others first used “Personal Home Page Tools” in 1995, which Lerdorf had combined with his own Form Interpreter to create PHP/FI. Zeev Suraski and Andi Gutmans rewrote the parser in 1997, forming the basis of PHP 3. They also changed the name to its current recursive form. After months in beta, the development team officially released PHP/FI 2 in November 1997. Public testing of PHP 3 began immediately and the official launch came in June 1998. Suraski and Gutmans started a new rewrite of PHP’s core, producing the Zend engine in 1999. In May 2000, PHP 4 powered by the Zend Engine was released. Development continues toward PHP 5 with Zend Engine 2.

Popularity of PHP

PHP is one of the most popular server-side scripting systems on the Web. It’s been widely adopted since the release of version 4, which was the first version powered by the powerful Zend Engine from Zend Technologies[?].

According to Netcraft’s (http://www.netcraft.com/info) April 2002 survey, PHP is now the most-deployed server-side scripting language, running on around 9 million of the 37 million sites in their survey. This is confirmed by PHP.net’s own figures (http://www.php.net/usage.php), which show PHP usage measured on a per-domain basis growing at around 5% per month.

PHP is not, however, the most commonly used tool if measurements are made on a per-page basis. Another estimate in March 2002, based on searching for Web pages by their suffix, places PHP in second place at 30% of measured pages, behind 48% using Microsoft’s ASP, but also shows PHP growing rapidly in market share. However, this method is notoriously inaccurate for measuring PHP popularity as some PHP systems dispense with the file names, using only directories.

15 Exercises for Learning a new Programming Language

Posted by admin | Systems Applications | Tuesday 22 December 2009 12:45 am

I’ve working knowledge of a bunch of programming languages but job demands to learn a new language frequently in a short time. Instead of reading hundreds manual/book pages, I quickly read 10-15 pages of tutorial or primer. (As you know google is the best search engine to look for such stuff). I keep printed copy of the language syntax reference card handy. (There are many reference cards available over internet. Type in ’language to learn’ + ’reference card’ in google.)

First of all, get familiar with Compiler, compiler option, editor shortcuts or integrated development environment (IDE). Start with a simple ’Hello World’ program. Compile it. Use basic functionalities of debugger like setting break points, printing variable values, moving to the next or specific position, stopping debugger etc.

To grasp basics of a new language quickly, here are the exercises I use. Remember some programs may not good for beginners.

(1) Display series of numbers (1,2,3,4, 5….etc) in an infinite loop. The program should quit if someone hits a specific key (Say ESCAPE key).

(2) Fibonacci series, swapping two variables, finding maximum/minimum among a list of numbers.

(3) Accepting series of numbers, strings from keyboard and sorting them ascending, descending order.

(4) Reynolds number is calculated using formula (D*v*rho)/mu Where D = Diameter, V= velocity, rho = density mu = viscosity Write a program that will accept all values in appropriate units (Don’t worry about unit conversion) If number is < 2100, display Laminar flow, If it’s between 2100 and 4000 display ’Transient flow’ and if more than ’4000’, display ’Turbulent Flow’ (If, else, then…)

(5) Modify the above program such that it will ask for ’Do you want to calculate again (y/n), if you say ’y’, it’ll again ask the parameters. If ’n’, it’ll exit. (Do while loop)

While running the program give value mu = 0. See what happens. Does it give ’DIVIDE BY ZERO’ error? Does it give ’Segmentation fault..core dump?’. How to handle this situation. Is there something built in the language itself? (Exception Handling)

(6) Scientific calculator supporting addition, subtraction, multiplication, division, square-root, square, cube, sin, cos, tan, Factorial, inverse, modulus

(7) Printing output in different formats (say rounding up to 5 decimal places, truncating after 4 decimal places, padding zeros to the right and left, right and left justification)(Input output operations)

(8) Open a text file and convert it into HTML file. (File operations/Strings)

(9) Time and Date : Get system time and convert it in different formats ’DD-MON-YYYY’, ’mm-dd-yyyy’, ’dd/mm/yy’ etc.

(10) Create files with date and time stamp appended to the name

(11) Input is HTML table, Remove all tags and put data in a comma/tab separated file.

(12) Extract uppercase words from a file, extract unique words

(13) Implement word wrapping feature (Observe how word wrap works in windows ’notepad’)

(14) Adding/removing items in the beginning, middle and end of the array.

(15) Are these features supported by your language: Operator overloading, virtual functions, references, pointers etc.

Is there something called ’namespace / package / module’ supported by your language? (Name mangling) -

10 Most Bizarre Programming Languages Ever Created

Posted by admin | Systems Applications | Tuesday 22 December 2009 12:42 am

There is nothing more frustrating for a web developer than spending hours at a time fixing a bug that should just work. Often I’ll get stuck in a programming state that feels like I have absolutely no idea what I’m doing, as if the language I’m using (CSS, PHP, whatever), is actually a foreign language.

1. Ook!
If you’ve ever felt like a monkey just banging away at a keyboard, then Ook! will make you feel right at home. It’s a language designed primarily for primates, specifically the orangutan. With Ook! you only use three syntax elements:

* Ook.
* Ook?
* Ook!

Here are a few examples of Ook! in action:

1. Ook. Ook?
2. Move the Memory Pointer to the next array cell.

Ook. Ook?
Move the Memory Pointer to the next array cell.

1. Ook? Ook.
2. Move the Memory Pointer to the previous array cell.

Ook? Ook.
Move the Memory Pointer to the previous array cell.

1. Ook. Ook.
2. Increment the array cell pointed at by the Memory Pointer.

Ook. Ook.
Increment the array cell pointed at by the Memory Pointer.

1. Ook! Ook!
2. Decrement the array cell pointed at by the Memory Pointer.

Ook! Ook!
Decrement the array cell pointed at by the Memory Pointer.

1. Ook. Ook!
2. Read a character from STDIN and put its ASCII value into the cell pointed at by the Memory Pointer.

2. Piet
For those appreciative of fine art, Piet is a language that you’ll surely enjoy. Inspired by the abstract artist Piet Mondrian, Piet is a programming language that converts programs into abstract geometric paintings. Programs are made up of 20 different colors, and then read by the compiler based on hex values to run a program.Check out some of the crazy examples that Piet programmers have come up with.

3. Whitespace
Unfortunately, the name for this programming language is exactly what it does: Whitespace creates programs based off of… whitespace. The Whitespace website has a great description of how the language works.

Most modern programming languages do not consider white space characters (spaces, tabs and newlines) syntax, ignoring them, as if they weren’t there. We consider this to be a gross injustice to these perfectly friendly members of the character set. Should they be ignored, just because they are invisible? Whitespace is a language that seeks to redress the balance. Any non whitespace characters are ignored; only spaces, tabs and newlines are considered syntax.

. LOLCODE
LOLCODE is my personal favorite among esoteric languages. The language is based off of the LOLCats phenomenon, and uses LOLCats syntax to make programs run. Or something like that.Just looking at a sample bit of an LOLCODE program will explain why it’s a fan favorite.
view plaincopy to clipboardprint?

1. HAI
2. CAN HAS STDIO?
3. PLZ OPEN FILE “LOLCATS.TXT”?
4. AWSUM THX
5. VISIBLE FILE
6. O NOES
7. INVISIBLE “ERROR!”
8. KTHXBYE

5. Shakespeare
Shakespeare is not as simple as LOLCODE to wrap your head around. In case you haven’t figured it out yet, Shakespeare is a programming language based on the writings of the great playwright. Each program contains a title, acts, scenes and characters to make brilliant source code that’s actually fun to read.Here’s Act I, Scene I of “Hello World”:
view plaincopy to clipboardprint?

1. The Infamous Hello World Program.
2.
3. Romeo, a young man with a remarkable patience.
4. Juliet, a likewise young woman of remarkable grace.
5. Ophelia, a remarkable woman much in dispute with Hamlet.
6. Hamlet, the flatterer of Andersen Insulting A/S.
7.
8. Act I: Hamlet’s insults and flattery.
9.
10. Scene I: The insulting of Romeo.
11.
12. [Enter Hamlet and Romeo]
13.
14. Hamlet:
15. You lying stupid fatherless big smelly half-witted coward!
16. You are as stupid as the difference between a handsome rich brave
17. hero and thyself! Speak your mind!
18.
19. You are as brave as the sum of your fat little stuffed misused dusty
20. old rotten codpiece and a beautiful fair warm peaceful sunny summer’s
21. day. You are as healthy as the difference between the sum of the
22. sweetest reddest rose and my father and yourself! Speak your mind!
23.
24. You are as cowardly as the sum of yourself and the difference
25. between a big mighty proud kingdom and a horse. Speak your mind.
26.
27. Speak your mind!
28.
29. [Exit Romeo]

6. Befunge
The goal for Chris Pressey, creator of the Befunge programming language, was simple: Create a language that was as difficult to compile as possible. Befunge accomplishes this by the two main features of the daunting language:

1. Self modifying – the p instruction can write new instructions into the playfield; and
2. Multi-dimensional – the same instruction can be executed in four different contexts (in a left-to-right series of instructions, or right-to-left, or upward or downward.)

Regardless, there are very smart people, (with way too much free time), who have created compilers for Befunge.

7. reMorse
reMorse is a language intended to look like morse code. Visions of submarines and telegrams come to mind with this simple yet incredibly challenging language. Here’s the reMorse version of “Hello World”:
view plaincopy to clipboardprint?

1. – - – ..- …-.—.;newline
2. – - – .-. – ..-.- …-. —.;!
3. – - – …- . . -.—.;d
4. —-. . . -.—.;l
5. —-. . -…—.;r
6. —-. -…—.;o
7. —-…-.- ..-. —.;W
8. //author didn’t feel like doing this part
9. -…………..;output all characters

- – - ..- …-.—.;newline
- – - .-. – ..-.- …-. —.;!
- – - …- . . -.—.;d
—-. . . -.—.;l
—-. . -…—.;r
—-. -…—.;o
—-…-.- ..-. —.;W
//author didn’t feel like doing this part
-…………..;output all characters

This language might be a tad on the difficult side for the rest of us (with the exception of amateur radio specialists). You know it’s a bear to program when the author of the language won’t finish all of the basic example, due to complexity.

8. FALSE
With an appropriate negative connotation, FALSE is a language meant to discourage even the cleverest programmers. Based on the Forth language, FALSE uses a punctuation based syntax (gross!) to help sour the programming experience.From the FALSE creator himself:

I designed this language with two particular objectives: confusing everyone with an obfuscated syntax, and designing as powerful a language as possible with a tiny implementation: in this case a compiler executable of just 1024 bytes (!), written in pure 68000 assembler.

Yet FALSE isn’t the most ridiculous of the esoteric languages, and could actually serve real world purposes, as the operations are reasonably sensible and the language isn’t extremely complex. Maybe somebody, someday, will make a useful real-world application out of the language…

False.

9. Whenever
Imagine a surly teenager as a programming language, and you’ve got yourself Whenever. Whenever is a simple language that does what it wants, when it wants.

It takes the program code and treats each line as an item in a to-do list. The interpreter chooses an item from the list at random to execute, and executes the statement. In some cases, the statement will contain a clause that specifies that it cannot be executed until certain conditions apply. This results in the statement being deferred and placed back on the to-do list.

Don’t think for a minute you can actually control a Whenever program. Imagine how hard this makes programming something like “99 Bottles of Beer”! The program would return something that read like it had already consumed all 99.
view plaincopy to clipboardprint?

1. defer (4 || N(1)
2. defer (4 || N(1)==N(2)) print(“Take one down and pass it around,”);
3. defer (4 || N(2)==N(3)) print(N(1)+” bottles of beer on the wall.”);
4. 1#98,2#98,3#98;

10. l33t
Ever wanted to speak like a “l33t H4xX0r5″? Now you can by learning the l33t programming language. Check out the l33t “Hello World” application:
view plaincopy to clipboardprint?

1. // Note that the views expressed in this source code do not necessarily coincide with those of the author :o )
2.
3. Gr34t l33tN3$$?
4. M3h…
5. iT 41n’t s0 7rIckY.
6.
7. l33t sP33k is U8er keWl 4nD eA5y wehn u 7hink 1t tHr0uGh.
8. 1f u w4nn4be UB3R-l33t u d3f1n1t3lY w4nt in 0n a b4d4sS h4xX0r1ng s1tE!!! ;p
9. w4r3Z c0ll3cT10n2 r 7eh l3Et3r!
10.
11. Qu4k3 cL4nS r 7eh bE5t tH1ng 1n teh 3nTIr3 w0rlD!!!
12. g4m3s wh3r3 u g3t to 5h00t ppl r 70tAl1_y w1cK1d!!
13. I’M teh fr4GM4stEr aN I’lL t0t41_1Ly wIpE teh phr34k1ng fL00r ***j3d1 5tYlE*** wItH y0uR h1dE!!!! L0L0L0L!
14. t3lEphR4gG1nG l4m3rs wit mY m8tes r34lLy k1kK$ A$$
15.
16. l33t hAxX0r$ CrE4t3 u8er- k3wL 5tUff lIkE n34t pR0gR4mm1nG lAnguidGe$…
17. s0m3tIm3$ teh l4nGu4gES l00k jUst l1k3 rE41_ 0neS 7o mAkE ppl Th1nk th3y’r3 ju$t n0rMal lEE7 5pEEk but th3y’re 5ecRetLy c0dE!!!!
18. n080DY unDer5tAnD$ l33t SpEaK 4p4rT fr0m j3d1!!!!!
19. 50mE kId 0n A me$$4gEb04rD m1ghT 8E a r0xX0r1nG hAxX0r wH0 w4nT2 t0 bR34k 5tuFf, 0r mAyb3 ju5t sh0w 7eh wAy5 l33t ppl cAn 8E m0re lIkE y0d4!!! hE i5 teh u8ER!!!!
20. 1t m1ght 8E 5omE v1rus 0r a Pl4ySt4tI0n ch34t c0dE.
21. 1t 3v3n MiTe jUs7 s4y “H3LL0 W0RLD!!!” u ju5t cAn’T gu3s5.
22. tH3r3′s n3v3r anY p0iNt l00KiNg sC3pT1c4l c0s th4t, be1_1Ev3 iT 0r n0t, 1s whAt th1s 1s!!!!!
23.
24. 5uxX0r5!!!L0L0L0L0L!!!!!!!

In real life, l33t is “teh sUxX0r” due to the fact that you can’t use it for anything useful. Ah well, back to hacking with all the other script kiddies and trolls!

What Makes a Good Programming Language?

Posted by admin | Systems Applications | Tuesday 22 December 2009 12:35 am

There are plenty of programming languages around. David Chisnall points out the various factors that determine what makes a “good” language. But note his caveat: These principles don’t always apply in any given set of circumstances!
What Is a Programming Language?

Programming languages, like spoken languages, are ways of communicating ideas. When two people who know the same language talk, they’re able to understand each other because they both know the rules that formalize how to translate sounds into meaning and vice versa.

Computers don’t understand human languages. Worse, the languages they do understand—their instruction sets—don’t mesh very well with how most humans speak. Imagine for a moment a French person talking to a Chinese person. Neither of them understands the other’s native language, but if they speak a common second language, such as English, they can still talk to each other. This is more or less the situation when it comes to programming languages.

The English skills of the speakers in that last example also have direct parallels in terms of programming languages. When you have one person speaking and another person listening, comprehension depends on two things:

* The speaker’s ability to translate ideas into the language
* The listener’s ability to translate the spoken words into ideas

The speaker’s ability is equivalent to the programmer’s skill, and the listener’s ability is equivalent to the compiler’s efficiency.

A programming language is a compromise. Translating a language such as English directly into a machine language is very difficult for a machine. Similarly, “speaking” a machine language well is very difficult for a human. A programming language is one that a human can speak reasonably well, and that a computer can translate into a language that it understands.
Language, Framework, and Runtime

Most languages are very small; for example, C contains only about 20 keywords. They control the flow of a program, but do little else. Writing a useful program using just the C language is almost impossible. Fortunately, the designers recognized this problem. The C language specification also defines some functions that must be available for C programs to call. The majority of these functions, known together as the C Standard Library, are themselves written in C, although a few primitive ones may need to be written in some language that’s yet more primitive.

Most languages have some kind of equivalent to the C Standard Library. Java, for example, has an enormous catalogue of classes in the java.* namespace that must be present for an implementation of the language to be called “Java.” Twenty years ago, Common Lisp had a similarly large collection of functions. In some cases, the language is most commonly used with a collection of libraries, usually referred to as a framework, that are specified separately from the language itself.

Sometimes the line between language and framework is blurry. It’s clear that C++ and the Microsoft Foundation Classes are separate entities, for example, but for Objective-C the distinction is less clear. The Objective-C specification defines very little by way of a standard library. (Although, because Objective-C is a proper superset of C, the C Standard Library is always there.) Objective-C is almost always used in conjunction with the OpenStep API; these days, the common implementations are Apple’s Cocoa and GNUstep.

When you start adding libraries to a language, you lose some of the clarity of what makes the language unique. Writing an OpenGL program in Java has a lot more in common with writing an OpenGL program in C than it does with writing a Swing application in Java.

Another source of confusion is the runtime system. Languages such as Smalltalk and Lisp were traditionally run in a virtual machine (although most current Lisp implementations are compiled into native machine code). This requirement can lead people to perceive a given language as slow. Interpreted code is almost always slower than compiled code. This doesn’t have anything to do with the language, but it is important. Code run in a Lisp interpreter will be much slower than compiled Lisp code.

When judging a language, it’s important to differentiate between characteristics of a language and characteristics of an implementation of the language. Early implementations of Java were very slow; the just-in-time compiler was little better than an interpreter. This led to people calling Java an “interpreted language.” The GNU project’s Java compiler destroyed this myth, although other design decisions in the Java language still prevent it from being run as fast as some other languages.

There are plenty of programming languages around. David Chisnall points out the various factors that determine what makes a “good” language. But note his caveat: These principles don’t always apply in any given set of circumstances!
Speed

How do you measure the speed of a language? The obvious way is to write some algorithms in it, run them, and see how long they take to execute. For the most part, this is a good, pragmatic solution. There are a few potential pitfalls, however:

*

Selecting the correct compiler. If you’re evaluating Lisp, for example, it wouldn’t be fair to benchmark an interpreted version of Lisp against compiled C++ or just-in-time compiled Java. But it would be fair to compare these languages with something like Perl, Ruby, or Python, in which the default (supported) implementation runs interpreted bytecode.
*

The fastest compiler isn’t always the correct one for your needs. For some time, the Microsoft Java runtime was the fastest implementation available. If you were looking for a language for cross-platform development, however, it would have been a mistake to select Java just because the Microsoft runtime was fast.

Be aware of the platform you’re targeting when you decide on a compiler. If you’re writing cross-platform code, you may want to standardize the compiler (or runtime) across all of your supported platforms to ensure that you have a minimum of issues from varying levels of language support across implementations. In this case, you might choose something like GCC, which is likely to produce code that’s slower than a compiler written for a specific architecture. Be sure to take this factor into account when performing a speed evaluation. Just because IBM’s XLC or Intel’s ICC produces faster code from C than whatever other language you’re evaluating, that doesn’t mean that you can always benefit from this speed

At the opposite extreme, you might need to support only one platform. In this case, you’re free to choose the best implementation available for that platform. Make sure that you do this for all of the languages you evaluate, however. It’s easy to read benchmarks showing that the Steel Bank Common Lisp compiler produces code that runs faster than C++ code, and miss the fact that it performs somewhat worse on register-starved architectures such as x86. If you’re targeting x86, this is an important factor.
*

Don’t place too much faith in micro-benchmarks. It’s quite easy to design an algorithm that plays to the strengths of a particular implementation—or to its weaknesses. Something that requires a lot of array accesses, for example, is likely to cripple Java’s performance. Something that requires a high degree of concurrency is likely to show off Erlang’s strengths. When you look at micro-benchmarks, try to imagine where you would use algorithms like the ones described in your own application. If you can’t, then disregard them.
*

Remember that speed isn’t always important. The CPU usage graph on my machine could almost be described as having two states: one showing 20% usage, and the other showing 100% usage. If you’re writing the kind of application that will contribute to the 20%, then you would be hard-pressed to select a language that the end user would notice was slow. If you’re writing an application that uses as much processing power as you can throw at it, or an embedded application in which processing power is still expensive, speed is a very important consideration.

There are plenty of programming languages around. David Chisnall points out the various factors that determine what makes a “good” language. But note his caveat: These principles don’t always apply in any given set of circumstances!
Expressiveness

The Church-Turing thesis is one of the foundation stones of computer science. It tells us that any programming language that can simulate a Turing Machine can be used to implement any algorithm. But this doesn’t tell us much about a language beyond a simple yes or no answer to the question “Is this language Turing-complete?” In almost all cases, the answer is yes; few useful languages are not Turing-complete. One example is Adobe’s Portable Document Format (PDF), which began life as a non-Turing-complete subset of PostScript. This was created so that the time required to render (and hence print) a document was bounded by its size. PostScript contains loop constructs that PDF lacks, and so it’s possible for a PostScript program never to terminate.

Anyone who has criticized C will be familiar with the defense “but you can implement that in C!” This is true, of course. Any Turing-complete language can be implemented in any other. Prolog, for example, can be implemented in about 20 lines of Lisp. If you write a program requiring 1,000 lines of Prolog and include with it a 20-line Prolog interpreter written in Lisp, is it fair to call it a Lisp program?

The same principle applies in many other languages. The Objective-C runtime is usually implemented in C, so obviously you can do anything in C that you can do in Objective-C. The question is whether this practice makes sense. Is it more sensible to write your own dynamic object system, or to use one that other people are working on and constantly optimizing?

Of course, we’re assuming that the features you would need to implement are actually useful. If a language lacks a feature that isn’t useful anyway, that’s not a limit to its expressiveness.

A good question to ask is how many language features you have to throw away to gain a useful feature. In Smalltalk, you send messages to objects. This is the equivalent of calling methods in a language such as C++ or Java. If the object doesn’t have an explicit handler for that message type, then the runtime system delivers this message and its arguments to the object’s doesNotUnderstand: method. This setup allows for a lot of flexibility in programming.

Consider Java’s RMI mechanism. Each class to be exposed through RMI must be run through a preprocessor that generates a proxy class, which passes the name and arguments of each method through to the RMI mechanism. In Smalltalk (or Objective-C, for that matter), you don’t need to do all this. You can just create a single proxy class that implements the doesNotUnderstand: method and passes the message to the remote class. This one class can be used as a proxy for any other class.

If you wanted to implement something comparable in C++, however, you would need to throw away the C++ method-call mechanism and replace it with your own custom message-passing system. Each C++ class would implement a single handleMessage() method, which would then call the “real” methods. By the time you’ve done this, you’ve thrown away a lot of the convenience of using C++ in the first place.

here are plenty of programming languages around. David Chisnall points out the various factors that determine what makes a “good” language. But note his caveat: These principles don’t always apply in any given set of circumstances!
Readability

Sometimes you can write code that gets used for a bit and then thrown away. Most of the time, you aren’t so lucky. Eventually you have to go back and read it, or someone does. If you know you’re leaving the company soon, and you hate your coworkers, you might consider a language like Intercal or C++, with baroque syntax and even more peculiar semantics. On the other hand, if there’s a chance that you might be stuck maintaining the code, or you want to be able to show it to other people without hanging your head in shame, the readability of the language is important.

A lot of factors go into determining whether a language is readable. The most obvious is familiarity. The human mind is very good at adaptation, and often it’s astonishing what the mind will perceive as “normal.” Familiarity only comes from constant exposure, though, which means that languages with relatively simple syntax become familiar more quickly. Lisp is at one extreme, with only one syntactic construct. It’s very easy to become familiar with Lisp, although grasping the large Common Lisp standard library is another matter. C++ is the popular language at the other extreme. Most C++ coders I have encountered use only a relatively small subset of the C++ language. Worse, everyone uses a slightly different subset, so C++ code written by other people may be quite difficult for you to read, even though you’re familiar with the language.

Another aspect of readability is the syntax itself. This is where Smalltalk-like languages tend to win. Since Objective-C allows the use of syntax that works for both C and Smalltalk, it’s a good language for an example. Apple provides a set of objects that are “toll-free bridged” between C and Objective-C. This means that a set of C functions are passed the Objective-C object as an opaque data type, so you can directly manipulate the Objective-C objects without having to translate them into some other form. This approach makes them ideal for a syntax comparison:

[array insertObject:anObject atIndex:12];
CFArrayInsertValueAtIndex(array, 12, anObject);

Both of these lines accomplish the same thing: inserting anObject into array at index 12. To understand this result from the first line above, you need to understand that the Objective-C message-passing syntax specified an object and then a list of parameter name:parameter pairs. To understand this result from the second example, you need to know how C function-calling works, that it’s conventional for the first argument in functions of this type to be the data structure being manipulated, and that the author of the function decided that the arguments for the function should be passed the opposite way to how they occur in the function name.

In this particular example, it’s quite easy to spot that 12 is the index, if you know that arrays are indexed by numbers. Now imagine that both arguments were variable names.

Of course, the biggest impact on readability comes not from the language, but from the developer. A poor developer can write illegible code in any language. A good developer? I’ve even seen well-written, readable Visual Basic code. (Once.)

here are plenty of programming languages around. David Chisnall points out the various factors that determine what makes a “good” language. But note his caveat: These principles don’t always apply in any given set of circumstances!
Summary

A lot of factors go into determining what makes a good language, and they don’t always apply in any given set of circumstances. A good language for a particular task may be a particularly bad choice in another situation. A good programmer will always pick the right tool for the job.

Google’s Go: A New Programming Language That’s Python Meets C++

Posted by admin | Uncategorized | Tuesday 22 December 2009 12:33 am

Big news for developers out there: Google has just announced the release of a new, open sourced programming language called Go. The company says that Go is experimental, and that it combines the performance and security benefits associated with using a compiled language like C++ with the speed of a dynamic language like Python. Go’s official mascot is Gordon the gopher, seen here.

Here’s how Google describes Go in its blog post:

Go attempts to combine the development speed of working in a dynamic language like Python with the performance and safety of a compiled language like C or C++. In our experiments with Go to date, typical builds feel instantaneous; even large binaries compile in just a few seconds. And the compiled code runs close to the speed of C. Go is designed to let you move fast.

We’re hoping Go turns out to be a great language for systems programming with support for multi-processing and a fresh and lightweight take on object-oriented design, with some cool features like true closures and reflection.

The Nice programming language

Posted by admin | Uncategorized | Tuesday 22 December 2009 12:31 am

Presentation

Nice is a new programming language. It extends the ideas behind object-orientation in order to better support modular programming and static type safety. It also incorporates features from functional programming, and puts into practice state-of-the-art results from academic research. This results in more expressivity, modularity and safety.

Safety

Nice detects more errors during compilation than existing object-oriented languages (null pointer accesses, casts exceptions). This means that programs written in Nice never throw the infamous NullPointerException nor ClassCastException. This aspect is developed in more details in this article.
Modularity

In object-oriented languages, it is possible to add a new class to an existing class hierarchy. In Nice, it is also possible to add methods to existing classes without modifying their source file. This is a special case of multi-methods.
Expressivity

Many repetitive programming tasks can be avoided by using Nice’s advanced features. Ever got bored of writing tons of loops, casts, overloaded methods with default values, anonymous classes, … ?

Advanced features

In addition to traditional object-oriented features, Nice offers:

Parametric types

This is especially useful for containers (lists, hash-tables) and allows for shorter and safer code. Values of primitive type (int, float, …) can be used in polymorphic code, in which case the wrapping and unwrapping is done automatically by the compiler.
Anonymous functions

Functions can be created and manipulated as first-class expressions, just like in Lisp and ML. This is much lighter than Java’s anonymous classes in many situations, for instance with listeners in a GUI.
Multi-methods

They allow methods to be defined outside classes. This means that new methods can be defined on classes that belong to a different package (even in java.*). This allows for a more modular style: you don’t need to pack classes with all possibly useful methods, but you can split them into several packages dealing with different aspects. Development can then happen independently if each package.

Multi-methods also extend usual methods with the possibility to dispatch on every argument, instead of only the receiver class. This article shows why using multi-methods is preferable to applying the Visitor pattern.
Tuples

This allows in particular methods to return several values.
Optional parameters to methods

Optional parameters have a default value that is used when the parameter is not present in the call. This is much simpler than in Java, where one has to write several versions of the method for each combination of parameters. The names of the arguments can also be specified at the call site, improving readability and making argument order irrelevant.
Contracts and assertions

Contracts can be attached to methods, to better describe their specification and detect illegal uses automatically at runtime, in debug mode. Contracts and assertions can be disabled, in which case they cause no slow down of the running program. Furthermore, they can be used on any version of the JVM, even prior to 1.4.

Integration with Java

The current implementation is tightly integrated with the Java environment, which offers several advantages. The huge amount of Java libraries can be used directly in Nice programs. Libraries can also be written in Nice and called from a Java program. The Nice compiler produces java bytecode, which means Nice programs can be executed on virtually any platform, with any Java Virtual Machine. Or they can be compiled to native programs with a native Java compiler. The compiler is itself written in Java and in Nice. The compiler needs a JVM version 1.2 or higher to run.
Availability

Nice is freely available under the GPL. The runtime classes are licensed under the “GPL + linking exception” license, which means that libraries and programs written in Nice can be licensed under any terms.

About Ruby

Posted by admin | Uncategorized | Tuesday 22 December 2009 12:30 am

Wondering why Ruby is so popular? Its fans call it a beautiful, artful language. And yet, they say it’s handy and practical. What gives?
The Ideals of Ruby’s Creator

Ruby is a language of careful balance. Its creator, Yukihiro “matz” Matsumoto, blended parts of his favorite languages (Perl, Smalltalk, Eiffel, Ada, and Lisp) to form a new language that balanced functional programming with imperative programming.

He has often said that he is “trying to make Ruby natural, not simple,” in a way that mirrors life.

Building on this, he adds:

Ruby is simple in appearance, but is very complex inside, just like our human body1.

About Ruby’s Growth

Since its public release in 1995, Ruby has drawn devoted coders worldwide. In 2006, Ruby achieved mass acceptance. With active user groups formed in the world’s major cities and Ruby-related conferences filled to capacity.

Ruby-Talk, the primary mailing list for discussion of the Ruby language has climbed to an average of 200 messages per day.

The TIOBE index, which measures the growth of programming languages, ranks Ruby as #9 among programming languages worldwide. Much of the growth is attributed to the popularity of software written in Ruby, particularly the Ruby on Rails web framework2.

Ruby is also totally free. Not only free of charge, but also free to use, copy, modify, and distribute.
Seeing Everything as an Object

Initially, Matz looked at other languages to find an ideal syntax. Recalling his search, he said, “I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python3.”

In Ruby, everything is an object. Every bit of information and code can be given their own properties and actions. Object-oriented programming calls properties by the name instance variables and actions are known as methods. Ruby’s pure object-oriented approach is most commonly demonstrated by a bit of code which applies an action to a number.

5.times { print “We *love* Ruby — it’s outrageous!” }

In many languages, numbers and other primitive types are not objects. Ruby follows the influence of the Smalltalk language by giving methods and instance variables to all of its types. This eases one’s use of Ruby, since rules applying to objects apply to all of Ruby.
Ruby’s Flexibility

Ruby is seen as a flexible language, since it allows its users to freely alter its parts. Essential parts of Ruby can be removed or redefined, at will. Existing parts can be added upon. Ruby tries not to restrict the coder.

For example, addition is performed with the plus (+) operator. But, if you’d rather use the readable word plus, you could add such a method to Ruby’s builtin Numeric class.

class Numeric
def plus(x)
self.+(x)
end
end

y = 5.plus 6
# y is now equal to 11

Ruby’s operators are syntactic sugar for methods. You can redefine them as well.
Blocks, a Truly Expressive Feature

Ruby’s block are also seen as a source of great flexibility. A programmer can attach a closure to any method, describing how that method should act. The closure is called a block and has become one of the most popular features for newcomers to Ruby from other imperative languages like PHP or Visual Basic.

Blocks are inspired by functional languages. Matz said, “in Ruby closures, I wanted to respect the Lisp culture4.”

search_engines =
%w[Google Yahoo MSN].map do |engine|
“http://www.” + engine.downcase + “.com”
end

In the above code, the block is described inside the do … end construct. The map method applies the block to the provided list of words. Many other methods in Ruby leave a hole open for a coder to write their own block to fill in the details of what that method should do.
Ruby and the Mixin

Unlike many object-oriented languages, Ruby features single inheritance only, on purpose. But Ruby knows the concept of modules (called Categories in Objective-C). Modules are collections of methods.

Classes can mixin a module and receive all its methods for free. For example, any class which implements the each method can mixin the Enumerable module, which adds a pile of methods that use each for looping.

class MyArray
include Enumerable
end

Generally, Rubyists see this as a much clearer way than multiple inheritance, which is complex and can be too restrictive.
Ruby’s Visual Appearance

While Ruby often uses very limited punctuation and usually prefers English keywords, some punctuation is used to decorate Ruby. Ruby needs no variable declarations. It uses simple naming conventions to denote the scope of variables.

* var could be a local variable.
* @var is an instance variable.
* $var is a global variable.

These sigils enhance readability by allowing the programmer to easily identify the roles of each variable. It also becomes unnecessary to use a tiresome self. prepended to every instance member.
Beyond the Basics

Ruby has a wealth of other features, among which are the following:

* Ruby has exception handling features, like Java or Python, to make it easy to handle errors.

* Ruby features a true mark-and-sweep garbage collector for all Ruby objects. No need to maintain reference counts in extension libraries. As Matz says, “This is better for your health.”

* Writing C extensions in Ruby is easier than in Perl or Python, with a very elegant API for calling Ruby from C. This includes calls for embedding Ruby in software, for use as a scripting language. A SWIG interface is also available.

* Ruby can load extension libraries dynamically if an OS allows.

* Ruby features OS independent threading. Thus, for all platforms on which Ruby runs, you also have multithreading, regardless of if the OS supports it or not, even on MS-DOS!

* Ruby is highly portable: it is developed mostly on GNU/Linux, but works on many types of UNIX, Mac OS X, Windows 95/98/Me/NT/2000/XP, DOS, BeOS, OS/2, etc.

10 Programming Languages You Should Learn

Posted by admin | Uncategorized | Tuesday 22 December 2009 12:27 am
Among thousands, 10 programming languages stand out for their job marketability and wide use. If you’re looking to boost your career or learn something new, start here.

Knowing a handful of programming languages is seen by many as a harbor in a job market storm, solid skills that will be marketable as long as the languages are.

Yet, there is beauty in numbers. While there may be developers who have had riches heaped on them by knowing the right programming language at the right time in the right place, most longtime coders will tell you that periodically learning a new language is an essential part of being a good and successful Web developer.

“One of my mentors once told me that a programming language is just a programming language. It doesnt matter if youre a good programmer, its the syntax that matters,” Tim Huckaby, CEO of San Diego-based software engineering company CEO Interknowlogy.com, told eWEEK..

However, Huckaby said that while his company is “swimming” in work, hes having a nearly impossible time finding recruits, even on the entry level, that know specific programming languages.

“Were hiring like crazy, but were not having an easy time. Were just looking for attitude and aptitude, kids right out of school that know .Net, or even Java, because with that we can train them on .Net,” said Huckaby.

“Dont get fixated on one or two languages. When I started in 1969, FORTRAN, COBOL and S/360 Assembler were the big tickets. Today, Java, C and Visual Basic are. In 10 years time, some new set of languages will be the in thing. …At last count, I knew/have learned over 24 different languages in over 30 years,” Wayne Duqaine, director of at Grandview Systems, of Sebastopol, Calif., told eWEEK.

By picking the brains of Web developers and IT recruiters, eWEEK selected 10 programming languages that are a bonus for developers to add to their resumes. Even better, theyre great jumping-off points, with loads of job opportunities for younger recruits.

1. PHP

  • What it is: An open-source, interpretive, server-side, cross-platform, HTML scripting language, especially well-suited for Web development as it can be embedded into HTML pages.
  • Why you should learn it: Its particularly widely used. “High-speed scripting with caching, augmented with compiled code plug-ins (such as can be done with Perl and PHP) is where the future is. Building Web apps from scratch using C or COBOL is going the way of the dinosaur,” said Duquaine.
  • Job availabilities: 1,152*
  • 2. C#

  • What it is: A general-purpose, compiled, object-oriented programming language developed by Microsoft as part of its .NET initiative, it evolved from C and C++
  • Why you should learn it: Its an essential part of the .Net framework. “Learning C#, which is just Java with a different name plate, is critical if you heavily use Microsoft,” said Duquaine.
  • Job availabilities: 5,111
  • 3. AJAX (Asynchronous JavaScript and XML)

  • What it is: Though technically not a programming language, AJAX uses XHTML or HTML, JavaScript and XML to create interactive Web applications.
  • Why you should learn it: Ever since Google Maps put AJAX, well, on the map, the requests for AJAX-knowledgeable pros went through the roof. “The demand for AJAX knowledge is huge because its so damned hard to learn,” said Huckaby. Of note, Microsoft announced recently plans to release a tool named Atlas that will make AJAX easier to implement. “If Microsofts Atlas tool is successful, it would bring the extreme complexity and annoyance of AJAX to the average worker,” said Huckaby.
  • Job availabilities : 1,106
  • 4. JavaScript

  • What it is: Not to be confused with Java, JavaScript is a an object-oriented, scripting programming language that runs in the Web browser on the client side. Its smaller than Java, with a simplified set of commands, easier to code and doesnt have to be compiled.
  • Why you should learn it: Embedded into HTML, its used in millions of Web pages to validate forms, create cookies, detect browsers and improve the design. With its simplicity to learn as well as wide use, its considered a great bang for your educational buck.
  • Job availabilities: 4,406
  • 5. Perl

  • What it is: Perl is an open-source, cross-platform, server-side interpretive programming language used extensively to process text through CGI programs.
  • Why you should learn it: Perls power in processing of piles of text has made it very popular and widely used to write Web server programs for a range of tasks. “Learning some form of scripting language, such as Perl or PHP is critical if you are doing Web apps,” said Duquaine.
  • Job availabilities: 4,810
  • 6. C

  • What it is: A standardized, general-purpose programming language, its one of the most pervasive languages and the basis for several others (such as C++).
  • Why you should learn it: “Learning C is crucial. Once you learn C, making the jump to Java or C# is fairly easy, because a lot of the syntax is common. Also, a lot of C syntax is used in scripting languages,” said Duquaine.
  • Job availabilities: 6,164, including all derivatives
  • 7. Ruby and Ruby on Rails

  • What they are: Ruby is a dynamic, object-oriented, open-source programming language; Ruby on Rails is an open-source Web application framework written in Ruby that closely follows the MVC (Model-View-Controller) architecture.
  • Why you should learn it: With a focus on simplicity, productivity and letting the computers do the work, in a few years, its usage has spread quickly. As a bonus, many find it easy to learn.
  • Job availabilities : 210 and 54, respectively
  • 8. Java

  • What it is: An object-oriented programming language developed by James Gosling and colleagues at Sun Microsystems in the early 1990s.
  • Why you should learn it: Hailed by many developers as a “beautiful” language, it is central to the non-.Net programming experience. “Learning Java is critical if you are non-Microsoft,” said Duquaine.
  • Job availabilities: 14,408
  • 9. Python

  • What it is: An interpreted, dynamically object-oriented, open-source programming language that utilizes automatic memory management.
  • Why you should learn it: Designed to be a highly readable, minimalist language, many say it has a sense of humor (spam and eggs, rather than foo and bar), Python is used extensively by Google as well as in academia because of its syntactic simplicity.
  • Job availabilities: 811
  • 10. VB.Net (Visual Basic .Net)

  • What it is: An object-oriented language implemented on Microsofts .Net framework.
  • Why you should learn it: Most argue that VB.Net is currently more popular than ever and one of the only “must-learns.” “It is currently dominating in adoption and that is where all the work is,” said Huckaby.
  • Job availabilities: 2,090