Tobiasz Cudnik's shared items in Google Reader

Fun with Apps Script at the Google Apps Developer Hackathon in NYC

2012-01-04T19:05:00Z

Editor’s Note:This is a guest post from John Watkinson. John is a developer and the co-founder of Docracy, a start-up company that hosts crowd-sourced legal documents and provides free e-signing services. He recently attended, and won first place, at the Google Apps Hackathon in NYC. Here's John's story about the event.

Our company is focused on documents in the cloud, so we attended the Google Apps Developer Hackathon on December 1st in New York City to learn more about the various Google Apps APIs, and how we can best integrate with them. During the initial presentations from Ryan Boyd and Saurabh Gupta of the Google Apps team, we were delighted to learn about Apps Script. It provides a powerful JavaScript interface into Google Apps, including Docs, Calendar, Gmail, Maps and many others.

Hack #1: “The Wolf”

After the tech presentations, we formed teams and started hacking with the technology. I joined a team with Matt Hall (also from Docracy), Nick Siderakis, Jeff Hsin and Scott Thompson. We struck upon the idea of creating a function that would make calls to Wolfram Alpha via their developer API. It took all five of us hacking away for a few hours to parse the Alpha results properly, but eventually we had an Apps Script custom function for Spreadsheet called “wolf”. It had a kind of magic feeling about it, as you could pass simple English-language queries into the function and get back exact numeric results in your Google Spreadsheet. Some example working queries:

=wolf("distance from the earth to the moon in km") Answer: 403,778km
=wolf("population of canada in 1960") Answer: 17.9 million
=wolf("average january temperature in buenos aires") Answer: 64F
=wolf("9th digit of pi") Answer: 5
=wolf("count of olympic medals won by japan in 2008") Answer: 25

Any function in Apps Script can be used as a spreadsheet function directly, so our main wolf function is the entry point to our script. We use Apps Script’s UrlFetch service to make our API call to Wolfram Alpha (note, the full URL is truncated for brevity):

var response = UrlFetchApp.fetch("http://api.wolframalpha.com/..." +
  encodeURIComponent(input));

The response from Alpha is an XML file that includes a lot of metadata we don’t need. So, we used a recursive function and the XML manipulation tools in Apps Script to track down the element of interest to us (below is a simplified version):

function findText(e) {
  if (e.getName().getLocalName() == 'plaintext') {
    return e.getText();
  } else {
    var children = e.getElements();
    for (var i = 0; i < children.length; i++) {
      var result = findText(children[i]);
      if (result) return result;
    }
    return null;
  }
}

A little bit more work is required to parse the result, as sometimes Alpha will report numbers in words (i.e. “40.7 million”), but otherwise that’s it!

For a small script, it definitely feels pretty powerful! Our little invention earned us a first place finish at the hackathon, and the prizes were little indoor RC-controlled helicopters. I managed to irreparably damage mine in a gruesome crash into my refrigerator already, but I hear that many of the others are still serviceable and flying missions daily.

Hack #2: Sheet Sweeper

Once we were comfortable with the Apps Script Services (and aware of its capabilities with spreadsheets in particular), a side project emerged that used some of the other integration features available. Apps Script functions can listen for events that are triggered by the editing of a spreadsheet cell (if the user grants the appropriate permissions). Using these onEdit Event Handlers, we wrote an implementation of the classic game Mine Sweeper that is playable right in the spreadsheet!

Watch on YouTube

You can play the game by making a copy of this spreadsheet and then clicking the menu item SheetSweeper > New Game. When you play the game, the script responds to onEdit events that are dispatched from the spreadsheet.

function onOpen() {
  var ss = SpreadsheetApp.getActiveSpreadsheet();
  var menuEntries = [{name: "New Game", functionName: "startGame"}];
  ss.addMenu("SheetSweeper", menuEntries);
}

Then when the user edits a cell, the script responds and implements the mine sweeper logic:

function onEdit(event) {
  var ss = event.source.getActiveSheet();
  var cell = ss.getActiveCell();
  if (cell.getValue() == 'x') {
    // Flagging a mine
    flagCell(cell);
  } else {
    // Clearing a cell
    clearCell(cell);
  }  
}

We had a great time at the hackathon, and are happy to have been introduced to Apps Script. We believe it has an exciting future ahead of it.

John Watkinson profile

John is a developer and the co-founder of Docracy, a start-up company that hosts crowd-sourced legal documents and provides free e-signing services. He previously co-founded the mobile development shop Larva Labs, which developed the popular Androidify app with the Google Creative Lab.

curl dancing; fun with node + nodejitsu + ANSI escape codes

2011-10-28T13:12:36Z

Marak Squires of Nodejitsu has a great Friday Fun project for today. He kindly told us a little about it:

Open up a terminal and run:

curl ohh.io/dancing

after that, you can try curl ohh.io to see a menu.

After that, check out http://ohh.io/ASNIdom. This is a (naive) DOM implementation in ANSI escape codes. It allows you to share HTML templates between the browser and…the terminal…

All MIT as usual:

https://github.com/marak/ANSIdom
https://github.com/marak/ohh

Awesome :)

JavaScript unit testing support

2011-10-17T12:12:27Z

If you’re a JavaScript developer, you probably know that the quality and correctness of your application are crucial. Well, consistency and regression testing just got a little less painful. Meet JsTestDriver plugin – an open-source project that was originally started at Google and is now contributed to by the JetBrains team.

WebStorm 3.0 bundles it.

Users of other JetBrains IDE – PhpStorm, IntelliJ IDEA, PyCharm, RubyMine, and AppCode – can install it from the plugin repository following these instructions.

It allows you to enjoy all the benefits of JsTestDriver right from the comfort of your IDE. This includes the following features:

starting and stopping the server;
running and rerunning tests;
filtering and viewing test results, navigation from results to source code;
jumping from JavaScript exception stacktrace to source code;
support for JsTestDriver configuration file: syntax and error highlighting, basic completion, navigation to referenced files;
capturing messages sent to console.log();
support for Jasmine, QUnit and JsTestDriver built-in assertion frameworks:
- quick-fixes for enabling global symbol reference resolving for each assertion framework (if you have QUnit or Jasmine tests in a project, you will be prompted to install the corresponding adapter);
- contextual code generation actions (Alt+Insert) for creating new tests, setup and teardown methods for each assertion framework;
- declarative HTML injection support for JsTestDriver built-in assertion framework.

The best way to understand how this works is to see it in action.

Getting started

If you aren’t aware of JsTestDriver concepts, consider visiting http://code.google.com/p/js-test-driver/wiki/GettingStarted. There is also an excellent tutorial introduction to JavaScript unit testing by Christian Johansen.

Setup project

We have created a sample project for you. Please download greeter-sample.zip, extract it and open the project in your IDE.

If you open GreeterTest.js for the first time, you will see error highlighting on the TestCase method call expression. Position the caret on the error-highlighted code, press Alt+Enter/Option+Enter and choose “Add JsTestDriver assertion framework support” from the list of available intention actions.

A global JavaScript library named “JsTestDriver Assertion Framework” will be created and associated with a project. To view it, open the Settings dialog (File | Settings or IntelliJ IDEA | Preferences) and select JavaScript Libraries.

Before you can run any of your tests you need to start the test server and capture at least one slave browser. The server does not have to reside on the machine where the test runner is, and the browsers themselves can be on different machines as well.

Starting JsTestDriver server locally

To launch the JsTestDriver server, look for the tool window at the bottom of the screen.

Click the green arrow to the right of the address bar to start the server. The status bar turns yellow to let you know the server is running, but has no slave browsers.

Then, copy the capture URL and paste it in a browser. The status bar turns green, and the corresponding browser icon lights up. Now you’re ready to run tests.

Running tests

To run tests, right-click greeter.jstd and choose Run “greeter.jstd”. Tests will be run against the local JsTestDriver server.

In our case we have one failed test ‘GreeterTest.test greet null’. You can easily navigate from the stack trace to the source code that causes problems. You can also navigate from the test results tree to the test case/test function declaration using the F4 key.

Generate code

In order to remove duplicated code that sets the greeter local variable, you can refactor the Greeter object creation to a special method called setUp, which is called before each test function is executed. Just invoke the Generate action by pressing Alt+Insert inside of a TestCase method call expression, and then choose “JsTestDriver Setup”.

Use the Shift+F10 keyboard shortcut to re-run the tests after changing code.

Test with pleasure!

Download WebStorm for your platform from project EAP page.

Note: Users of PhpStorm, as well as other JetBrains IDE – IntelliJ IDEA, PyCharm, RubyMine, and AppCode – should install it from the plugin repository following these instructions.

Android 4.0 Platform and Updated SDK Tools

2011-10-19T03:00:00Z

Today we are announcing Android 4.0, Ice Cream Sandwich — a new version of the platform that brings a refined, unified user experience for phones, tablets, and more.

Android 4.0 builds on the things people love most about Android — efficient multitasking, rich notifications, customizable home screens, resizable widgets, and deep interactivity — and adds powerful new ways of communicating and sharing. It includes many great features for users, including social and sharing integration, network data usage control, innovative connectivity and camera options, and an updated set of standard apps.

For developers, Android 4.0 introduces many new capabilities and APIs. Here are some highlights:

Unified UI toolkit: A single set of UI components, styles, and capabilities for phones, tablets, and other devices.

Rich communication and sharing: New social and calendar APIs, Android Beam for NFC-based instant sharing, Wi-Fi Direct support, Bluetooth Health Device Profile support.

Deep interactivity and customization: Improved notifications, lockscreen with camera and music controls, and improved app management in the launcher.

New graphics, camera, and media capabilities: Image and video effects, precise camera metering and face detection, new media codecs and containers.

Interface and input: Hardware-accelerated 2D drawing, new grid-based layout, improved soft keyboard, spell-checker API, stylus input support, and better mouse support.

Improved accessibility: New accessibility APIs and text-to-speech APIs for writing new engines.

Enhancements for enterprise: Keychain and VPN APIs for managing credentials and connections, a new administrator policy for disabling the camera.

For a complete overview of what’s new for users and developers, please read the Android 4.0 Platform Highlights.

Alongside the new Android platform, we are releasing new versions of the SDK Tools (r14) and ADT Plugin (14.0) for Eclipse. Among the highlights are:

Improved build performance in Ant and Eclipse
Improved layout and XML editors

To get started developing on Android 4.0, visit the Android Developers site for information about the Android 4.0 platform, the SDK Tools, and the ADT Plugin.

If you have already developed and published apps, we encourage you to download the Android 4.0 platform now, to begin testing your app before devices arrive in stores.

Check out the video below for a closer look at Android 4.0 in action.

Introducing Aurora 9

2011-09-30T22:22:45Z

We have just released Aurora 9 (download and test Aurora 9), which is planned to be the upcoming Firefox 9. In it, we have a number of new things that we hope will get you excited!

JavaScript Type Inference

We’ve improved JavaScript performance once again with type inference. We’ve made significant improvements on both the V8 and Kraken benchmarks, and you should see real-world improvements to JavaScript performance as well.

JavaScript Interface for Do Not Track

Firefox 4 introduced Do Not Track, and now there is a way to detect a users’prefence through JavaScript as well:

mouseenter and mouseleave events

For some time now, web developers have been struggling with handling mouseover and mouseout events on elements, since when child elements have gained focus, the event has bubbled up and triggered mouseout on the parent element – something you would in most cases not like to happen.

Therefore, we are now happy to introduce support for mouseenter and mouseleave events:

Camera UI for Mobile

You can now use an input element to trigger a native app to take pictures. Please try the Camera UI for Mobile demo.

Support for chunked XMLHttpRequest

When doing XMLHttpRequest requests with large data sets, you can now get partial data as it arrives instead of waiting for it all to show up. You can use this to build more responsive and more efficient web sites.

Other changes

We’ve also got support for a bunch of other changes as well. These will be added to the Firefox 9 for Developers page over the next few weeks.

Intel’s Parallel Extensions for JavaScript

2011-10-08T17:38:07Z

Intel’s Parallel Extensions for JavaScript, code named River Trail, hooks into on-chip vector extensions to improve performance of Web applications. Details of Intel’s attempt to get on the JavaScript juggernaut emerged last month at its developer event.

The prototype JavaScript extension offered by Intel is intended to allow JavaScript apps to take advantage of modern parallel chip capabilities. Sequential gives way to parallel, at least in theory.

In-browser games and image editing are pitched as examples of application elements that would take advantage of new eight-core processors, blogs Intel’s Stephan Herhut.The software is said to ”play nicely” with the WebGL JavaScript API to OpenGL for 3D visualization in the browser. Intel has a beta Firefox extension for interested developers. Says Herhut:

You can download a prebuilt version for Windows and 64 Bit MacOS [from github] or build it yourself. For the latter, we have written a README that explains the process. Once you have the extension installed, take a look at our demos to see what is possible.

Why should the browser be a second fiddle to the operating system? As browsers, JavaScript, and HTML5 gain more influence, top-tier chip makers will start to adapt their libraries to Web application demands. More, including material on API design or the beginnings of API documentation, is on a RiverTrail wiki.

JavaScript++: classes, block scoping, pluggable type systems, and more

2011-10-10T07:01:03Z

All eyes are on the upcoming “Dart” announcement from Denmark. That being said, there are many others playing on top of the playground that is the JavaScript VM (browser + server now!).

One ambitious project is JavaScript++ from Roger Poon and team.

The JavaScript++ project adds a slew of functionality that all gets compiled down to ES3. It includes support for:

classes (as in ‘class’ and ‘extend’)
block scoping (let!)
pluggable type systems (gilad!)
full PCRE-compatible regular expression patterns (everything from look behinds to possessive quantifiers)
array programming: scoped extensions, comprehensions, and more
and a ton of “small” things such as multi-line strings

Check out the tutorial for the real deets.

Firebug 1.8 New Features

2011-07-29T11:49:59Z

Firebug 1.8 compatible with Firefox 5.0 has been released and I would like to get this opportunity and introduce some new features in this version.

Firebug 1.8 has been also uploaded to AMO, but it can take some time to appear.

First of all, check out the following compatibility table:

Firefox 3.6 with Firebug 1.7.3
Firefox 4.0 with Firebug 1.7.3
Firefox 5.0 with Firebug 1.8 (and also Firebug 1.7.3)
Firefox 6.0 with Firebug 1.9a0 (and Firebug 1.8 as soon as 6.0 is out)
Firefox 7.0 with Firebug 1.9a0
Firefox 8.0 with Firebug 1.9a0

console.timeStamp()

There is a new API that can be used to create time-stamps during Javascript execution and compare them together with HTTP traffic timing on the timeline in the Net panel: console.timeStamp();

See detailed description of this feature with examples how to use it.

IP Address displayed in the Net Panel

The Net panel displays remote & local IP address + port number for each request. There are two additional columns, see the screen-shot:

HTML Preview Reloaded

This feature is back and better than before. Now you can adjust height of the preview by drag-and-drop to see more or less content as necessary.

Improved Script Location List

Script location list available in the Script panel adjusts its size automatically according to the screen size and uses scroll-bar as needed. This makes easier for the user to pick up the right script.

Command Line Content Persistence

Command line content is now persistent across reloads. This feature allows to quickly execute the same expression on different pages. This is one of many little details that make Firebug the indispensable tool.

New DOM Panel Options

The DOM panel has two new options:

Show Own Properties Only check if you don’t want see the prototype chain for objects
Show Enumerable Properties Only check if you want to see only enumerable properties

CSS Panel Color Tooltips

A tooltip with color preview is displayed for colors specified in various formats. Supported formats are: hex, rgb, rgba, hsl and hsla.

Shortcuts for Changing CSS values

Firebug is great when tweaking CSS of the current page to perfection. Now, there are also new keyboard shortcuts for changing CSS values (numbers).

Ctrl+Up/Down increases/decreases by 0.1
Shift+Up/Down increases/decreases by 10

Better Support for External Editors

As you might know Firebug allows to configure and open an external editor (or IDE). There has been two arguments you could pass to such editor:

%url URL of the file (if %url is not present, %file will be added by default)
%file Path to the local file (or to the temporary copy)

Firebug 1.8 introduces a new %line argument that allows to open the external editor scrolled at the right position (according to the current scroll position in the the Script panel).

%line Line number

Box Sizing Exposed

CSS3 introduced a new property called box-sizing, which allows the user changing the box model for an element and thereby influence element layout. Value of this property is now exposed in the Layout side panel.

Stay Tuned!

Honza

Rendering 3D with CSS and JavaScript with dom3d (guest post)

2011-08-08T07:38:22Z

Today we have a guest post by James Long (@jlongster).

James is the tech lead for mozilla.com on the Web Development team. James is passionate about interactive graphics on the open web.

Today he explains how you can create 3D objects using CSS without having 3D transforms support. Take it away, James.

Recently I was tinkering with CSS3 and I discovered that it enabled me to do primitive 3D rendering, which I found fascinating! This led to the creation of dom3d, a JavaScript library that uses CSS to render basic 3D objects.

Now the question is: why? Aren’t canvas, WebGL, and even SVG better technologies to work with for this? Possibly. However, CSS is becoming a powerful language for describing complex effects and shapes, and we should experiment.

Keep that in mind, because CSS definitely isn’t intended to do this, but it’s worth trying to see where we should take CSS in the future.

Advantages

Although this is more of an experiment, it has a few real world benefits:

All rendering libraries available for the web (canvas, WebGL, SVG) require a canvas, which is a constrained box on the page with a specific width and height. It is not possible to render anything outside this box. The canvas also captures all DOM events (like clicks), even completely transparent sections. Theoretically, this could make it difficult to do effects that overlay large parts of the page or are somehow deeply integrated to the content.

Using CSS, we aren’t constrained to a box, and the effect can overlay large portions of the page without covering any the the links or other content requiring interaction.

Other advantages include no need to initialize canvas 2D or WebGL, and a simplistic API making it easy to pick up even if you don’t know much about 3D. It might be easier for kids to start playing around with this before they jump into WebGL or something else. Also, because it’s just a dump of DOM elements you can embed it anywhere (without animation).

So keep in mind that this is a hack, but with the above advantages. This might be good for certain effects: 3D cursor, nav transitions, and others.

How it works

Three-D objects are just a bunch of triangles put together, so let’s start with one simple triangle. If we get that working, it’s a simple step forward to render multiple triangles to form a 3D object.

Rendering a 3d triangle on a 2D screen involves something called “projection”. This is the act of taking a 3D point and projecting it onto a 2D screen. Plug in a 3D triangle to a simple math equation, and you get a 2D triangle representing how the 3D one would look on the screen.

The math is remarkably simple but may seem weird if you aren’t familiar with linear algebra. You can take a look at the renderer code.

Now comes the fun part: can you render any 2D triangle simply with CSS3 transforms? Turns out you can! It just takes some fiddling to figure out which transforms to generate. CSS3 transforms are composed of translate, scale, rotate, and skew values, and we need a few equations to compute these values for a specific 2D triangle.

First, let’s take a simple DOM element and turn it into a triangle. We can do this with the linear-gradient background image (another way is border triangles).

Now let’s draw the following blue triangle with the points [20, 20], [50, 120], and [120, 30]. A vital step is to set a few initial reference points which set everything in the same space. Our equations will assume these coordinate spaces. This is how the points A, B, C and the side AB are related.

If we take a closer look at this, we can derive the transform values. First, get an idea of which angles and values we need and then use geometry to form the equations (in pseudo-code). The red box represents the DOM element, the form AB represents the side formed by points A and B, and rotation occurs clockwise.

rotation = atan2(AB.x, AB.y)
AC' = rotate(AC, -rotation)
width = AC'.x
height = length(AB)
skew = atan2(AC'.y, AC'.x)
translate = A

Awesome! Let’s try it out. Here is a live DOM element being transformed by applying each of our equations:

The resulting triangle matches our target triangle! Here is the final CSS:

width: 93px;
height: 104px;
background: -moz-linear-gradient(-0.727211rad, #0000FF 50%, transparent 0pt);
-moz-transform: translate(20px, 20px) rotate(-0.291457rad) skewY(0.391125rad);
-moz-transform-origin: top left;

Note: The tranform-origin: top left line is important. Normally transforms happen relative to the center of the element, but our equations assume the top left.

Note: dom3d also generates code with the -webkit and -o prefixes for WebKit and Opera support.

You can view the implementation of these equations. It turns out that these equations work for any triangle, as long as the points given are in counter-clockwise order, which is standard in the graphics world.

Taking it all the way

Since we can project a 3D triangle into 2D space and render it with CSS, all we have to do now is apply that to several 3D triangles to form a 3D object!

We need some 3D data at this point. I used Blender to export a teapot into the simple OBJ file format and wrote a script to dump the data as JavaScript. Rendering all those triangles with this technique produces the following:

Teapot! However, we can do much better. A big part of the 3D effect is shading. If we calculate normals, a vector representing where the triangle is facing, and specify a light direction, we can take the dot product of the normal and light for each triangle to get flat shading. View the code for flat shading.

There are many tweaks that take this even further. For example, the above objects have z-indexing enabled. Without this, a triangle that is supposed to be behind another may actually appear on top because it was rendered later. The dom3d uses a heap to render the triangles from back to front.

Real-time animation can be achieved with a setTimeout or requestAnimationFrame function that continually renders the object. The dom3d supports the scale, translate, yaw, and pitch transformations, but there’s nothing stopping you from modifying the object data however you like between renderings. See some examples over at the dom3d website.

Here is the code which renders the teapot animation with dom3d:

It’s more appropriate for webpages to update an animation in response to user interaction instead of constantly rendering and hogging the CPU. See the pole example on the dom3d site for an example.

Improvements and last thoughts

The most interesting possibility with this is to include actual page elements as part of 3D objects. A navigation item could pop out and swirl around in 3d space, and the nav item is seamlessly transformed along with it.

That’s where this hack starts to show its faults, though. Unfortunately this is a little too hacky to provide an appropriate web experience. Because it tricks DIVs into fake triangles, it removes the possibility of integrating any page elements with it. With the coming of 3D CSS transforms though, we can start building true 3D objects made up of any kind of page elements. The only restriction with 3D transforms is that the 3D objects need to built with rectangles instead of triangles.

Other people have already experimented with 3D transforms, like building a pure CSS 3D city. There’s another cool library, Sprite3D, which provides a JavaScript API for building basic 3d objects from page elements.

The most glaring problem with dom3d is the seams in the object, which appear in all browsers. Apparently there are a few bugs in rendering engines when stressing their CSS3 transforms and using linear-gradients!

The dom3d library provides an API to work with all of this, but is hasn’t been documented very well yet. Feel free to browse the README and code on github. These APIs could be improved as well. It also provides an SVG rendering backend, seen here, but I don’t this is the right direction to take. We should focus on building basic 3D objects with page elements.

This was a fun experiment and I’m excited by how fast and capable browsers are becoming. The web is an exciting platform and getting richer and more powerful every year!

browserify - write client-side javascript server-side

2011-07-25T23:23:46Z

browserify - write client-side javascript server-side:

Unifying your front-end and back-end codebases can be a harrowing experience. Regardless of your web technology stack of choice, you’ve probably created some server-side component which generated some front-end JavaScript for you at some point. I’ve created and used many tools that do such code generation, and I’ve hated all of them. This is why I’m soo excited to see node-browserify by prolific Node.js module author, James Halliday.

browserify is a node.js library which helps you share your back-end code to the front-end by enabling such features as:

a client-side require() method
being able to load npm packages
a middleware system for code generation:
- minify
- uglify
- ES5 compatibility
- fileify ( wrap static files or directories in JavaScript methods )
a CLI tool for creating stand-alone bundles
full integration with node’s httpServer and Express
browser-versions of certain core node modules such as path, events, and vm

Browserify does a great job of simplifying the process of sharing code between the browser and server by building on top of existing infrastructure and providing some great new features that play very nice with node.js

I needed to build a library that would operate dual-sided ( front-end and back-end ), and I choose to build it server-side first and then use the browserify CLI tool to port it to the client ( and work as a standalone with no server dependencies ). The entire process worked out much better then expected and I’d recommend trying it out for your next JavaScript project.

If you’d like to see an example of node-browserify in production, you can check out Browserling, Mr. Halliday’s very own company which allows you to test websites cross-browser, in your own browser! I can only imagine what crazy libraries SubStack will think up next.

hook.io 0.6.0 released

2011-08-02T13:37:16Z

hook.io 0.6.0 released:

hook.io is a node.js library which creates a distributed EventEmitter that works cross-process / cross-platform / cross-browser. Essentially, it’s a real-time event bus that works anywhere JavaScript is supported.

Since we first blogged about hook.io in April of 2010, the project has been completely rewritten in the 0.5.x and 0.6.x versions to take full advantage of EventEmitter2, dnode, and Forever.

The new version has a very simple broadcasting API:

 hook.emit('hello', 'world');

 hook.on('*::hello', function(data){
    console.log(this.event); // 'the-source-hook::hello'
    console.log(data);  // 'world   
 });

There are also a few pre-built Hooks

cron: Execute Hook Events as Tasks
irc: Full IRC bindings
helloworld
logger: Multi-transport Logger ( Console, File, Redis, Mongo, Loggly )
mailer: Sends emails
pinger: Pings URLS on intervals ( useful for monitoring )
request: Simple wrapper for http://github.com/mikeal/request
repl: Rainbow Powered REPL
twilio: Make calls and send SMS through [Twilio][10]
twitter: Wrapper to Twitter API
webhook: Emits received HTTP requests as Events ( with optional JSON-RPC 1.0 Support )

Gmail and Document Services now available in Apps Script

2011-06-15T21:13:00Z

If you’ve used Google Apps Script before, you’ll know that we have deep integration with many Google Apps & APIs. You can access your Calendar and Contacts, create Google Sites, send email, and lots more. But two integrations were noticeably missing: the Google Docs word processor, and Gmail. A few weeks ago, at Google IO, we announced new Apps Script APIs for these two great products.

`GmailApp` - read, label and send emails

The new GmailApp should be instantly familiar if you’re used to using Gmail. You have access to labels, threads, and messages, and you can do all the things you expect: change labels, add and remove stars, mark things as important or trash or spam. You can also use the GmailApp.search() method to do any search you can do in Gmail itself. This is the first full fidelity API to Gmail, and we’re excited to see what you all will do with it.

To make sure your Gmail account remains private and secure, we are extra cautious about any script that uses GmailApp. Any time you change the code for a script that accesses Gmail, we will require you to reauthorize the script to run. Keep that in mind when editing a script that runs on a trigger - if you don’t reauthorize it, it will fail the next time the trigger tries to run it.

`DocumentApp` - create and edit Docs

The new DocumentApp lets you create new documents or open existing ones by id. The id of a document is always in the URL you see when visiting it, and document ids are consistent between DocumentApp and the existing DocsList service, so you can use DocsList.find() to search for a document, and then get its id from File.getId().

Once you have a document, you can access all of its individual elements. You can do search and replace (great for mail merge!), change styles or text, add or remove tables and lists, and much more. And when you are done, you can call Document.saveAndClose(), which makes sure all of your changes to the document get saved. If you don’t call it, we’ll do it for you at the end of the script, but it can be useful to call it yourself if you’d like to do something with the document after making your edits.

GmailApp and DocumentApp are available to all Apps Script users right now. Now the only question is, what are you going to build with them?

Posted by Corey Goldfeder, Google Apps Script Team

Want to weigh in on this topic? Discuss on Buzz

window.nextTick

2011-06-16T11:59:00Z

Node.js has a special API called process.nextTick which schedules a function to be executed immediately the next time the event loop is idle.

Web applications often try achieve a similar result using setTimeout. The problem is that setTimeout with a zero time parameter does not schedule for immediately but rather for some time a little later. This *can* lead to real performance problems.

I benchmarked a couple ways to do postMessage between workers, iframes and on the current window itself. Turns out doing postMessage on your current window might be a really good alternative to implement process.nextTick in browsers.

Please tell me what I did wrong in my benchmark.

Why Microsoft has made developers horrified about coding for Windows 8

2011-06-13T04:35:39Z

Microsoft's Windows 8 demonstration at the D9 conference looked pretty, but carried a chilling message for developers: if they wanted to write for the new operating system, they'd have to use HTML5 and JavaScript. This might seem a crazy move from a company that prides itself on backwards compatibility, but the warning signs have been there for quite some time now.

Getting Organized with the Tasks API

2011-05-11T17:05:00Z

Google Tasks helps many of us to remember all those things that keep us busy. Towards the end of last year we asked our users what they wanted to see improved with Google Tasks and an overwhelming request was for the ability to access tasks from anywhere — be it on the move, on the desktop, or through their favorite Web apps.

Today, we’re checking off a big to-do from our list and are inviting you to try out the new Google Tasks API. Using the Google Tasks API, developers can — for the very first time — create rich applications which integrate directly with Google Tasks.

The Google Tasks API provides developers with a powerful set of API endpoints for retrieving and modifying Google Tasks content and metadata. It offers a simple, RESTful interface and supports all basic operations required to query, manage and sync a user’s tasks and task lists. The API uses JSON for data representation and works with multiple authentication mechanisms including OAuth 2.0.

Plain HTTP using JSON

Using Google API Client Library for Java

POST /tasks/v1/lists/<list-ID>/tasks
Content-Type: application/json
...
{ title: "Publish blog post" }

Task task = new Task();
task.setTitle(
    "Publish blog post");
client.tasks.insert(
    "list-ID", 
    task).execute();

Client libraries are provided for several major programming environments and should help you get up and running quickly.

The API is available in Labs and can be activated for your project through the API Console. Get started today by trying the Tasks API yourself using the API Explorer and taking a look at the documentation.

If you want to see the API in action check out the Google Tasks Chrome Extension. If you are at Google I/O we invite you to come along and hear the Google Tasks team talk about the new API today.

We thank the early adopters that have worked with us and built their own Google Tasks integrations over the last weeks. We’d like to highlight a few of them:

Producteev is a task management platform that lets teams and individuals access their to-dos from a lot of different locations (web, mobile, email, calendars...). You will now have all your Producteev's tasks available in Google Tasks and vice versa!
Mavenlink's project collaboration suite allows you to communicate, share files, track time, invoice, and make or receive payments in one place. With its Google Tasks integration, your Mavenlink project tasks & Google Tasks always stay in sync.
Manymoon is the top installed social task and project management app in the Google Apps Marketplace and makes it simple to get work done online with co-workers, partners, and customers. Manymoon's users can now create and view tasks with Gmail and Google Calendar through Google Tasks.
Zoho offers a suite of online business, collaboration and productivity applications for small businesses. So far they have integrated Zoho CRM & Zoho Projects with the Tasks API.

Get Started with the Google Tasks API today!

Want to weigh in on this topic? Discuss on Buzz

	Posted by Fabian Schlup & Nicolas Garnier Google Tasks API Team

Google gives away 5,000 Samsung Galaxy Tab 10.1 tablets to devs at I/O

2011-05-10T16:53:00Z

Hey, who said we'd only get software news at Google I/O? The Android maker just reminded us that Samsung's Galaxy Tab 10.1 tablet (the thin version) will be launching in a month's time, and to whet appetites, a white-backed version of the device was shown off on stage. It's described as a limited edition, potentially because it looks to be running stock Android without the TouchWiz UI layer on top, and will be given away to the gathered crowd of 5,000 conference attendees. They'll get it with Honeycomb 3.0 on board, but an update to 3.1 will be forthcoming over the next couple of weeks as well.

Gallery: Samsung Galaxy Tab 10.1 Limited Edition

Google gives away 5,000 Samsung Galaxy Tab 10.1 tablets to devs at I/O originally appeared on Engadget on Tue, 10 May 2011 12:53:00 EDT. Please see our terms for use of feeds.

Permalink | | Email this | Comments

PhpStorm & WebStorm 2.1 EAP build 106.444

2011-04-11T13:24:05Z

PhpStorm & WebStorm 2.1 EAP is started. Build 106.444 is available immediately with pack of new features, important bugfixes, performance and usability improvements. Most notable:

Memory usage was improved leading to overall performance improvement, especially for batch code inspection
Tons of fixes and improvements from IntelliJ IDEA platform 10.5 (branch 106) are included starting from this build, including:
- Chrome JavaScript debugging support
- Check TODO on commit, patch into Shelf & GNOME Keyring support
- Full details on platform changes in changelogs for builds 106.330 & 106.396
PHP support enhancements
- Extract function/method refactoring implemented for PHP
- Create parameter quick fix for PHP “Undefined local variable” inspection
- Code inspections
  - Detect self assignments
  - Illegal type of array key
  - Return type inconsistency inspection for mixed “void” & “value” return statements
- PHP Doc inspections for missing and mismatched doc comments with generate or update doc quick fixes, accessible from batch inspection results
- Type inference engine and library subs improved

JavaScript debugger break on exception
CSS completion for previously used colors
Exclude single file from project by mapping it to plain text. More details in dedicated post
HAML support bundled
.htaccess support added, including completion, quick doc, regex fragments and path mapping support. More details to follow in dedicated post
HTML tag tree highlighting added

More details available on build changelog

Stay tuned for more info on new features and do not hesitate with your feedback – the 2.1 schedule is pretty tight!

Download PhpStorm & WebStorm 2.1 EAP build 106.444 for your platform from project EAP page.
Note that release builds will NOT prompt for update and patch is not available for this build.

Develop with pleasure!
-JetBrains Web IDE Team

Faster than a speeding rabbit: speed, sync, and settings

2011-02-17T23:00:00Z

In the spirit of the lunar new year, we’re excited to kick off the Year of the Rabbit with a slew of enhancements in the Chrome beta channel. Today’s new beta includes a dramatic improvement in JavaScript speed, new password sync features, and entirely revamped browser settings.

In our new beta release, JavaScript is as quick as a bunny. With a new speed boost that we previewed in December, Chrome’s JavaScript engine V8 runs compute-intensive JavaScript applications even more quickly than before. In fact, this beta release sports a whopping 66% improvement on the V8 benchmark suite over our current stable release.

This release also includes a preliminary implementation of GPU-accelerated video. Users with capable graphics hardware should see a significant decrease in CPU usage. In full screen mode, CPU usage may decrease by as much as 80%! This means better battery life so you can keep going and going like that pink bunny in the commercials.

For those of you who enjoy the convenience of saving passwords in Chrome, you can synchronize your saved passwords across multiple computers, along with your bookmarks, preferences, themes, and extensions. For added security, you can choose to encrypt your synced passwords with your own secret sync passphrase. To enable sync, visit the “Personal Stuff” section of Chrome’s settings dialog.

Speaking of settings, you’ll notice we have reworked the look and feel of the settings dialogs. Instead of opening in a separate window, they now open in a tab. More importantly, we’ve added two new settings features that make it easy to customize Chrome to your liking. Firstly, if you can’t remember where a particular pesky configuration setting is, simply type its name into the search box to see the settings that match as you type. Secondly, you can also now jump directly to most settings pages using their own dedicated URLs, without needing to navigate through a sequence of windows. Here’s a short video of the new settings interface in action:

As always, we’re eager to get your feedback, and look forward to bringing this basket of beta-fortified carrots to the stable channel over the coming weeks! (For those of you keen for some fun and games in this Year of the Rabbit, we’ll leave you with the mind-bending #ThinkFastGame speed challenge to try out alongside our new beta.)

Posted by Jeff Chang, Product Manager and Min Li Chan, Product Marketing Manager

IcedRobot – An OpenJDK-based Fork of Android

2011-02-14T10:39:00Z

A team of developers has announced the intent to fork Android in order to create a new OS based on OpenJDK, escaping Oracle’s patent lawsuits, to make it run on other platforms and operating systems, and to bring it to the desktop. By Abel Avram

Clamcase iPad keyboard case review

2011-02-14T18:25:00Z

We know you've been on pins and needles since we cleared up some of the confusion regarding the Clamcase, but a review unit finally landed on our doorstep to put through the paces. If you need a refresher, this was one of the earliest iPad keyboard cases to be introduced, but has only started shipping recently after some manufacturing woes. We've had sometime to put this baby through the paces so read past the break for the lowdown.

Gallery: Clamcase iPad keyboard case review

Continue reading Clamcase iPad keyboard case review

Clamcase iPad keyboard case review originally appeared on Engadget on Mon, 14 Feb 2011 14:25:00 EDT. Please see our terms for use of feeds.