Eclipse Announces PDT 2.0 Release

Tagged:  

The Eclipse Foundation has announced the 2.0 release of the Eclipse PHP Development Tools project (PDT). The project is sponsored by Zend and forms the basis of the commercial product Zend Studio.

Major features of this release include:

  • A Hierarchy view for navigating the PHP object hierarchy.
  • Easy searching for PHP types.
  • Override indicators for PHP methods that override other methods.
  • Performance improvements from using a new indexing and caching engine from the DLTK project.
  • Improved code completion.

The PDT project is one of Eclipse's most popular downloads, with more than 1 million downloads to date. The plug-ins are available from the download page or through the download site at:

http://download.eclipse.org/tools/pdt/updates

Apache Ivy 2.0 Released

Tagged:  

The Apache Ivy project, now a subproject of Ant but formerly a product of Jayasoft, has released version 2.0 of its dependency management solution for Ant build files. It is the first stable release of Ivy since becoming a full-fledged subproject of Ant.

The release features increased compatibility with Maven 2.0, improved cache management, a new "packager" resolver, and better handling of relative paths. Ivy has become an excellent tool for those unable (or unwilling) to move to Maven, but unable to live without dependency management (though there is also Maven's own Ant tasks).

Ivy 2.0 is available for download here. The IvyDE Eclipse plug-in (essentially an editor for ivy.xml files and a classpath container for your dependencies) is also available through the update site:

http://www.apache.org/dist/ant/ivyde/updatesite

jQuery 1.3.1 Released

jQuery 1.3.1 has been released with a number of bug fixes (23 to be exact).

50+ stunning jQuery applications

You can never get enough useful example of applications written in your favorite JavaScript library. One of my personal favorite JavaScript libraries is jQuery. Well, over at Developer Snippets they have put together a good list of 50+ jQuery applications.

Below is an excerpt from the post.

Color Picker - jQuery plugin – eyecon.ro
A simple component to select color in the same way you select color in Adobe Photoshop, features includes:
* Flat mode - as element in page
* Powerful controls for color selection
* Easy to customize the look by changing some images
* Fits into the viewport
Color Picker - jQuery plugin


Building a better web forms: Context highlighting using jQuery
– jankoatwarpspeed.com
In very complex web forms this enables users to focus only on a current action. By using attractive color schema and jQuery animations, this can be even more interesting.
 Context highlighting using jQuery

Creating accessible charts using canvas and jQuery
– filamentgroup.com
Data visualization in HTML has long been tricky to achieve. Past solutions have involved non-standard plugins, proprietary behavior, and static images. But this has changed with the recent growth in support for the new HTML Canvas element, which provides a native drawing API that can be addressed with simple JavaScript. This article is a proof of concept for visualizing HTML table data with the canvas element.
Accessible Charts

You can read the full post here.

DOM Prototypes in IE 8

Tagged:  

Travis Leithead, a Program Manager for Internet Explorer at Microsoft, writes in a recent blog entry about DOM prototypes in IE 8. In brief, IE 8 is the first version of the browser to expose the JavaScript constructors and prototypes for all DOM objects. This allows JavaScript developers--especially framework developers--to extend the functionality of DOM objects. It is not hard to envision extending IE 8, for example, to implement the (currently not implemented) getElementsByClassName method of HTML 5, which allows you to get all elements of a given CSS class. Travis gives an example of how to do so here:

function _MS_HTML5_getElementsByClassName(classList)
{
     var tokens = classList.split(" ");
     // Pre-fill the list with the results of the first token search
     var staticNodeList = this.querySelectorAll("." + tokens[0]);
     //Start the iterator at 1 since first match already colllected
     for (var i = 1; i < tokens.length; i++)
     {
        // Search for each token independently
        var tempList = this.querySelectorAll("." + tokens[i]);
        // Collects the "keepers" between loop iterations
        var resultList = new Array();
        for (var finalIter=0; finalIter < staticNodeList.length; 
          finalIter++)
        {
            var found = false;
            for (var tempIter=0; tempIter < tempList.length; tempIter++) 
            {
               if (staticNodeList[finalIter] == tempList[tempIter]) {
                  found = true;
                  break; // termination if found
               }
            }
         if (found) {
          // This element was in both lists, it should be perpetuated
          // into the next round of token checking...
          resultList.push(staticNodeList[finalIter]);
         }
       }
       // Copy the AND results for the next token
       staticNodeList = resultList;
     }
     return staticNodeList;
}
HTMLDocument.prototype.getElementsByClassName =
   _MS_HTML5_getElementsByClassName;
Element.prototype.getElementsByClassName =
   _MS_HTML5_getElementsByClassName;

Travis also details IE 8's support for JavaScript getters/setters (currently supported in Firefox, Safari, and Opera) in the article here. Getters and setters are a special feature for defining non-trivial object properties such as innerHTML while retaining the same familiar JavaScript syntax for referencing or assigning the property. The syntax for defining a property is specified by the defineProperty method of ECMAScript 3.1 (aka "JavaScript Harmony"):

Object.defineProperty(  [(DOM object) object],
                        [(string)     property name],
                        [(descriptor) property definition] );

All parameters are required.
Return value: the first parameter (object) passed to the function.

The syntax for retrieving a property definition is:

Object.getOwnPropertyDescriptor( [(DOM object) object],
                                 [(string)     property name] );

All parameters are required.
return value: A "property descriptor" object

Example usage of the special property syntax would be something like the following snippet of code:

// Let's define a property to define the co-ordinates of an
// img element in JSON
var coordDesc = new Object();
//define getter
coordDesc.getter = function() {
   var coords = new Object();
  coords.x = parseInt(this.currentStyle.left);
  coords.y = parseInt(this.currentStyle.top);
  coords.w = parseInt(this.currentStyle.width);
  coords.h = parseInt(this.currentStyle.height);
  return JSON.stringify(coords);
}
//define setter
coordDesc.setter = function(JSONString) {
  var coords = JSON.parse(JSONString);
  if (coords.x) this.style.left   = coords.x + "px";
  if (coords.y) this.style.top    = coords.y + "px";
  if (coords.w) this.style.width  = coords.w + "px";
  if (coords.h) this.style.height = coords.h + "px";
}
//define property
var img = Object.defineProperty(new Image(), "coordinates", coordDesc);
img.src = "images/my_image.png";
// Call the new property
img.coordinates = '{"w":200,"h":100}';
// Read the image's current position
alert(img.coordinates);   // => {"w":200,"h":100}

The Upshot

The combination of these two new features should make IE 8 far more amenable to extensibility than any previous version of Internet Explorer. This should help framework developers bridge the gap between browsers in a much less painful way, and make life easier for the average JavaScript developer.

The two MSDN articles describing DOM prototypes in IE 8 are here:
Document Object Model Prototypes, Part 1: Introduction
Document Object Model Prototypes, Part 2: Accessor (getter/setter) Support

jQuery 1.3 Released

Setting a land speed record for transition from Beta->RC->Release, the jQuery project has released version 1.3 of its popular JavaScript framework. All in all, it is a major release for the project and could have easily been dubbed "jQuery 2.0".

The important features of this release are:

  • A rewritten and very fast CSS selector engine: Sizzle. The Sizzle code base is stand-alone has been donated to the Dojo Foundation in an effort to encourage other JavaScript libraries to adopt it.
  • "Live Events" (also referred to as Event Delegation): a new API for binding events to current and future DOM elements. The live() function is used to bind an event to all matched elements, including future matched elements that are added to the DOM. The die() function removes the bound live event.
  • A rewrite of jQuery's event handling. The introduction of a jQuery.Event wrapper object brings jQuery's event model in line with W3C standards and makes events work smoothly across all browsers; the wrapper also allows arbitrary data to be associated with events. All triggered events now "bubble up" the DOM tree, but progress can be halted via a stopPropagation() function.
  • A rewrite of HTML injection (e.g., the append, prepend, before, and after methods) for much greater speed (heavy use of DOM Fragments).
  • A rewrite of the offset() method for better cross-browser compatibility as well as greater speed.
  • No more browser sniffing. As of 1.3, jQuery no longer uses any form of browser/userAgent sniffing internally. Instead, a technique called "feature detection" is used to simulate a browser feature (or bug) internally to see if it exists or behaves as expected. All of these checks are encapsulated in the jQuery.support object.

Anyone doing an upgrade to 1.3 from previous versions should note there are some backward compatibility issues which are noted here (under "Changes"). The full release notes are here.

In other news, there is a new API browser for jQuery (written by Remy Sharp), which is available online or as an AIR application. The project has also decided to join the Software Freedom Conservancy and will continue to be developed under its auspices. John Resig elaborates on the reasons for the move in his blog entry.

The new release can be downloaded from the main page.

Scala 2.7.3 Released

Tagged:  

The latest version of the Scala language has been released. Version 2.7.3 contains a number of bug fixes, especially in the actors library, and performance optimizations. A full list of issues resolved can be found here in the release notes.

The 2.7.3 distribution can be downloaded here. The corresponding Eclipse plug-in has also been updated and can be downloaded via its update site at:
http://www.scala-lang.org/scala-eclipse-plugin

jQuery 1.3 Reaches RC1

jQuery 1.3 has officially reached Release Candidate status. There are no release notes for this release, but for those who haven't been following the beta releases, you can read more about the changes in 1.3 here and here.

RC1 can be downloaded here.

Firebug 1.3 Released

Tagged:  

The Firebug 1.3 plug-in for Firefox 3.0.x has been released. The release features new tracing capability, used mostly for internal debugging but used to drive improvements in the Net panel as well. There are also numerous bug fixes. The full release notes are here.

The upcoming 1.4 release of Firebug will target Firefox 3.1.

Is SOA Dead?

Tagged:  

The Burton Group's Anne Thomas Manes wrote a provocative post yesterday declaring that SOA (as a term at least) is dead. It will, of course, be replaced by...(drum roll, please)...SERVICES! Hmm...isn't that what the "S" in SOA stands for? To quote Manes:

Once thought to be the savior of IT, SOA has instead turned into a great failed experiment—at least for most organizations. In the beginning, the forecast for SOA was to reduce costs and increase agility on a large scale, but except in rare situations, SOA has not delivered those promised benefits.

But, take solace, consultants everywhere! For all is not lost...

SOA is survived by its offspring: mashups, BPM, SaaS, Cloud Computing, and all other architectural approaches that depend on “services”.

Ah, I knew there had to be a silver lining to that cloud (*sniff*).

Cheekiness aside, the reality is that many organizations haven't really had a clue as to what SOA really is or how to do it. They, led by all too eager vendors and the general vagueness of the term itself, naively equated "SOA" with tacking on web services to their existing applications or building an ESB like a "field of dreams"--which many did, and dutifully waited for the magic transformation to come. It never did, mostly because many organizations were already too mired in years (indeed decades) of creating siloed applications. True service-orientation, however, required a re-thinking of traditional methods of doing IT, a shift that met silent but stiff resistance in many organizations. SOA demanded a revolution in thinking, something most organizations were simply not ready for.

So the term "SOA" must die, and give rise to equally vague (but much trendier) and equivalent terms. Silently and slowly, though, an evolution will happen: out of necessity, if nothing else. For services are an economy of form in an inter-connected world.

Syndicate content