Burque Design Group: Your Daily digest for Tech Geek`s Tools, Tips, Tricks and Tutorials

Tech Geek`s Tools, Tips, Tricks and Tutorials

Pipes Output

Firefox 20 Arrives With Per-Window Private Browsing, New Download Manager

Apr 2nd 2013, 22:55

An anonymous reader writes "Mozilla on Tuesday officially launched Firefox 20 for Windows, Mac, Linux, and Android. The improvements include per-window private browsing, a new download manager in the Firefox toolbar, and the ability to close hanging plugins without the browser hanging. The new desktop version was available as of yesterday on the organization's FTP servers, but that was just the initial release of the installers. Firefox 20 has now officially been made available over on Firefox.com and all users of old Firefox versions should be able to upgrade to it automatically. As always, the Android version is trickling out slowly on the official Google Play Store. The changelogs are here: desktop and Android."

Read more of this story at Slashdot.

Covet Desk di Shin Azumi

Apr 2nd 2013, 22:18

Si chiama Covet Desk. Disegnata dal giapponese Shin Azumi è un’elegante scrivania in legno di rovere e noce con un’ampia superficie in vetro. Perfetta per lo studio di casa si adatta gli amanti dello stile minimal. Se siete interessati ad acquistarne una potete chiedere direttamente sul sito di Case Forniture che distribuisce il prodotto. In alternativa potete rivolgervi a un buon falegname per ottenere qualcosa di simile a un costo più abbordabile.

Covet Desk, dettaglio portaoggetti

Why You Should Worry About the Future of Chromebooks

Apr 2nd 2013, 22:12

dcblogs writes "PC manufacturers may try to corral Chromebook, much like Netbooks, by setting frustratingly low hardware expectations. The systems being released from HP, Acer, Lenovo and Samsung are being built around retro Celeron processors and mostly 2 GB of RAM. By doing so, they are targeting schools and semi-impulse buyers and may be discouraging corporate buyers from considering the system. Google's Pixel is the counter-force, but at a price of $1,299 for the Wi-Fi system, reviewers, while gushing about hardware, believe it's too much, too soon. The Chromebook is a threat to everything, especially PC makers, as its apps improve. Compare Tweetdeck's HTML5 version with its native app. Can you tell the difference? It might be a year or two before Adobe delivers Web-only versions of its products, but if it doesn't it will be surrendering larger portions of its mindshare to users of Pixlr, Pixel Mixer, PicMonkey and many other interesting and increasingly capable tools."

Read more of this story at Slashdot.

IE11 To Support WebGL

Apr 2nd 2013, 21:28

mikejuk writes "The biggest problem with IE10 as far as modern web apps go is its lack of WebGL support. Now we have strong evidence that IE11 will support WebGL. A leaked build of Windows 'Blue,' aka Windows 8.1, also contained an early version of IE11. Web developer François Remy decided to see what it was hiding and found that there were WebGL APIs, but they were non-functional. Rafael Rivera, who writes the Within Windows blog, dug a little deeper and discovered the registry keys that have to be changed to enable WebGL support. Apparently the API works so well that you can take existing WebGL programs (with OpenGL shaders) and just run them. As the implementation also supports DirectX HLSL shaders, it seems reasonable to guess that the implementation maps OpenGL to DirectX, thus avoiding Microsoft having to endorse OpenGL use."

Read more of this story at Slashdot.

Wiping a Smartphone Still Leaves Data Behind

Apr 2nd 2013, 20:38

KindMind writes "To probably no one's surprise, wiping a smartphone by standard methods doesn't get all the data erased. From an article at Wired: 'Problem is, even if you do everything right, there can still be lots of personal data left behind. Simply restoring a phone to its factory settings won't completely clear it of data. Even if you use the built-in tools to wipe it, when you go to sell your phone on Craigslist you may be selling all sorts of things along with it that are far more valuable — your name, birth date, Social Security number and home address, for example. ... [On a wiped iPhone 3G, mobile forensics specialist Lee Reiber] found a large amount of deleted personal data that he recovered because it had not been overwritten. He was able to find hundreds of phone numbers from a contacts database. Worse, he found a list of nearly every Wi-Fi and cellular access point the phone had ever come across — 68,390 Wi-Fi points and 61,202 cell sites. (This was the same location data tracking that landed Apple in a privacy flap a few years ago, and caused it to change its collection methods.) Even if the phone had never connected to any of the Wi-Fi access points, iOS was still logging them, and Reiber was able to grab them and piece together a trail of where the phone had been turned on.'"

Read more of this story at Slashdot.

3D DRAM Spec Published

Apr 2nd 2013, 19:56

Lucas123 writes "The three largest memory makers announced the final specifications for three-dimensional DRAM, which is aimed at increasing performance for networking and high performance computing markets. Micron, Samsung and Hynix are leading the technology development efforts backed by the Hybrid Memory Cube Consortium (HMC). The Hybrid Memory Cube will stack multiple volatile memory dies on top of a DRAM controller. The result is a DRAM chip that has an aggregate bandwidth of 160GB/s, 15 times more throughput as standard DRAMs, while also reducing power by 70%. 'Basically, the beauty of it is that it gets rid of all the issues that were keeping DDR3 and DDR4 from going as fast as they could,' said Jim Handy, director of research firm Objective Analysis. The first versions of the Hybrid Memory Cube, due out in the second half of 2013, will deliver 2GB and 4GB of memory."

Read more of this story at Slashdot.

Facebook Phone e dejà vu: quando MySpace presentò il "MySpace Phone"

Apr 2nd 2013, 19:24

Quello nella foto è Tom Anderson. A molti questo nome dirà poco e niente. Nel 2003 fondò con Chris DeWolfe MySpace. All’epoca bastava iscriversi a MySpace per ritrovartelo in automatico tra gli amici. Il suo nome in questi giorni è tornato alla ribalta per un fatto curioso legato, guarda i casi del destino, a Facebook.

L’attesa è per giovedì 4 aprile. I riflettori puntati tutti su Mark Zuckerberg. Secondo le indiscrezioni circolate in rete nei giorni scorsi dovrebbe presentare il tanto chiacchierato Facebook Phone. In pochi ricorderanno però che sette anni fa, MySpace ebbe la stessa idea. Il 26 febbraio 2006 lanciò MySpace Mobile, un telefono realizzato in collaborazione con Samsung e l’operatore mobile Helio che “esaltava” l’esperienza sociale di MySpace.

MySpace Mobile

A quell’epoca gli smartphone erano nient’altro che prototipi segreti rinchiusi dentro i laboratori di ricerca di un paio di società della Silicon Valley. L’iPhone sarebbe arrivato solo più di un anno dopo a inaugurare la rivoluzione degli smartphone e le funzioni sociali messe oggi a disposizione da Facebook erano ancora in una fase primitiva.

Con il lancio di MySpace Mobile, News Corp. che aveva acquistato MySpace nel 2005 per 580 milioni di dollari sperava di «mantenere gli utenti saldamente legati al social network evitandogli il destino di Friendster». Già nel 2006 le cose non andavano granché bene. I tentativi di tamponare l’emorragia, fino a quel momento si erano rivelati tutti infruttuosi. Il MySpace Phone fu un flop clamoroso. E dopo anni di conti in sofferenza e di un rosso cronico in bilancio, Rupert Murdoch decise di sbarazzarsi di MySpace svendendolo per appena 35 milioni di dollari a Specific Media nel 2011. Il MySpace Phone finì nell’oblio delle iniziative andate a male. Chissà se a Facebook andrà meglio.

Magician & Investigator James Randi Talks Directly to You (Video)

Apr 2nd 2013, 19:15

Last week James Randi answered your questions. But that was text, and he's a performer ("The Amazing Randi"), so you need to hear the man talk to get his full flavor. He's a good talker, too. So Rob Rozeboom (samzenpus) got on Skype with The Amazing Randi to talk about his exploits, including his debunking of a whole bunch of (alleged) frauds, ranging from Uri Geller to Sylvia Browne. The resulting interview was so long and so strong that we cut it in half. Today you see Part One. Tomorrow you'll see Part Two. (The video's here now; sorry about the delay.)

Read more of this story at Slashdot.

NASA Gets $75 Million For Europa Mission

Apr 2nd 2013, 18:23

astroengine writes "It may not be a lander or an orbiter, but its something. Europa, one of Jupiter's largest moons, has been the focus of much scrutiny over its potential life-bearing qualities. It has an icy crust over a liquid water ocean and now salts have been detected on its surface, suggesting a cycling of nutrients from the surface to the interior. This only amplifies the hypothesis that Europa not only could support basic life, it could support complex life. But how can we find out? The proposed Europa Clipper received interest at NASA HQ last year as it would optimize the science while keeping the mission budget under $2 billion. It would be a spacecraft that will be in orbit around Jupiter, but make multiple flybys of Europa to assess the moon for its habitable qualities. Now, in a bill signed by President Obama and approved by lawmakers, $75 million has been allocated (for the remainder of this fiscal year) for a 'Jupiter Europa mission.' Could it represent the seed money for the Europa Clipper? We'll have to wait and see."

Read more of this story at Slashdot.

Nuclear Power Prevents More Deaths Than It Causes

Apr 2nd 2013, 17:32

MTorrice writes "NASA researchers have compared nuclear power to fossil fuel energy sources in terms of greenhouse gas emissions and air pollution-related deaths. Using nuclear power in place of coal and gas power has prevented some 1.8 million deaths globally over the past four decades and could save millions of more lives in coming decades, concludes their study. The pair also found that nuclear energy prevents emissions of huge quantities of greenhouse gases. These estimates help make the case that policymakers should continue to rely on and expand nuclear power in place of fossil fuels to mitigate climate change, the authors say."

Read more of this story at Slashdot.

FTC Awards $50k In Prizes To Cut Off Exasperating Robocalls

Apr 2nd 2013, 16:50

coondoggie writes "The Federal Trade Commission today said it picked two winners out of nearly 800 entries for its $50,000 Robocall Challenge which dared technologists to come up with an innovative way of blocking the mostly illegal but abundant calls. According to the FTC, Serdar Danis and Aaron Foss will each receive $25,000 for their proposals, which both use software to intercept and filter out illegal prerecorded calls using technology to 'blacklist' robocaller phone numbers and 'whitelist' numbers associated with acceptable incoming calls." Can't wait until Symantec, Kaspersky, etc. sell competing anti-spammer packages for phones.

Read more of this story at Slashdot.

Google Glass and Surveillance Culture

Apr 2nd 2013, 16:09

Nerval's Lobster writes "Tech journalist Milo Yiannopoulos asks the question lurking in everyone's mind about Google Glass. 'It's an audacious product for a company no one trusts to behave responsibly with our data: a pair of glasses that can monitor and record the world around you,' he writes. 'But if Glass becomes as ubiquitous as the iPhone, are we truly to believe that Google will not attempt to abuse that remarkable power?' With each new eyebrow-raising court judgment and federal fine levied against Google, he adds, 'it becomes ever more clear that this is a company hell-bent on innovating first and asking questions later, if ever. And its vision, shared with other California technology companies, is of corporate America redefining societal privacy norms in the service of advertising companies and their clients.' He feels that Google will eventually end up in some sort of court battle over Google Glass and privacy. Do you agree? Does Google Glass deserve extra scrutiny before it hits the market?"

Read more of this story at Slashdot.

Brown vs. Startup Over a Sandwich

Apr 2nd 2013, 15:30

An anonymous reader writes "Crunchbutton, founded by Yale grads, is trying to replicate the success of its one-button food delivery service in and around Brown University. The controversy began when the startup delivered a popular Brown sandwich called the 'Spicy With' to students. Brown's lawyers sent Crunchbutton a cease and desist letter, demanding that the company remove any associations with the university or its name. The startup says it has complied with the demands, yet Brown has not backed off, and it expects to be served with a lawsuit. This tale illustrates the perils of encouraging entrepreneurship while protecting the interests of a big educational institution."

Read more of this story at Slashdot.

Valve Starts Publishing Packages For Its Own Linux Distribution

Apr 2nd 2013, 14:49

An anonymous reader writes "In preparation for the "Steam Box" game console that will make necessary their own Linux-based software platform, Valve developers have started publishing Debian packages for their platform which looks like their first-generation operating system will be derived from Ubuntu 12.04.2 LTS. So far the packages being published include a new "Plymouth" boot splash screen as the operating system loads, a Steam desktop wallpaper, auto-updating system scripts, and experimental NVIDIA Linux graphics drivers."

Read more of this story at Slashdot.

Alan Kay Says iPad Betrays Xerox PARC Vision

Apr 2nd 2013, 14:07

harrymcc writes "Over at TIME.com, we've published David Greelish's interview with Alan Kay, the famously quotable visionary whose Dynabook proposal has provided much of the inspiration for advances in mobile computing for over 40 years now. Kay talks about his work, laments that the computer has failed to live up to its potential as an educational tool, and says that the iPad betrays the vision that he and others created at Xerox PARC and elsewhere in the 1970s."

Read more of this story at Slashdot.

Build a Secret Compartment, Go To Jail

Apr 2nd 2013, 13:25

KindMind writes "Alfred Anaya was a custom stereo installer who branched out to making secret compartments for valuables, who the DEA sent to prison as a co-conspirator when a drug dealer used his creation to smuggle drugs. But Wired points out the bigger question: 'The challenge for anyone who creates technology is to guess when they should turn their back on paying customers. Take a manufacturer of robot kits for hobbyists. If someone uses those robots to patrol a smuggling route or help protect a meth lab, how will prosecutors determine whether the company acted criminally?'"

Read more of this story at Slashdot.

IEEE Launches 400G Ethernet Standards Process

Apr 2nd 2013, 12:44

alphadogg writes "The IEEE this week launched a study group to explore development of a 400Gbps Ethernet standard to support booming demand for network bandwidth. Networks will need to support 58% compound annual growth rates in bandwidth on average, the IEEE claims, driven by simultaneous increases in users, access methodologies, access rates and services such as video on demand and social media. Networks would need to support capacity requirements of 1 terabit per second in 2015 and 10 terabit per second by 2020 if current trends continue, the organization says."

Read more of this story at Slashdot.

Judge Rules That Resale of MP3s Violates Copyright Law

Apr 2nd 2013, 12:03

Redigi runs a service that lets you resell your digitally purchased music. Naturally, they were sued by major labels soon after going live, with heavyweights like Google weighing in with support and an initial victory against pre-trial injunctions. But the first actual court ruling is against them. Pikoro writes "A judge has sided with Capitol Records in the lawsuit between the record company and ReDigi — ruling that MP3s can only be resold if granted permission by copyright owners. From the article: 'The Order is surprising in light of last month's United States Supreme Court decision in Kirtsaeng v. Wiley & Sons, which reaffirmed the importance and applicability of the First Sale Doctrine in the United States of America.'" Redigi vows to appeal, and claims that the current version of their service is not affected by the lawsuit.

Read more of this story at Slashdot.

A Thorough Introduction To Backbone.Marionette (Part 2)

Apr 2nd 2013, 11:00

In the first part of this series, we discussed Backbone.Marionette's Application. This time around, we'll discuss the module system that is included in Backbone.Marionette. Modules are accessible through the Application, but modules are a very large topic and deserve an article dedicated to them.

What Are Modules?

Before we get into the details of how to use Marionette's module system, we should make sure we all have a decent definition of a module. A module is an independent unit of code that ideally does one thing. It can be used in conjunction with other modules to create an entire system. The more independent a unit of code is, the more easily it can be exchanged or internally modified without affecting other parts of the system.

For this article, that's about as much as we need to define modules, but if you want to learn more about writing modular code, plenty of resources are on the Internet, of which the "Maintainability Depends on Modularity" chapter of Single Page Apps in Depth is one of the better ones out there.

The JavaScript language doesn't currently have any built-in methods for defining modules (the next version should change that), but many libraries have arisen to provide support for defining and loading modules. Marionette's module system, sadly, doesn't provide support for loading modules from other files, but it does offer some functionality that other module systems do not have, such as the ability to start and stop a module. We'll cover more of that later. Right now, we will just start with defining a module.

Module Definition

Let's start with the most basic of module definitions. As mentioned, modules are accessible through the Application, so we need to instantiate one of those. Then we can use its module method to define a module.

  var App = new Backbone.Marionette.Application();    var myModule = App.module('myModule');

That's pretty simple, right? Well, it is, but that's the simplest module we can create. What exactly did we create, though? Essentially, we told the application that we want a barebones module, with no functionality added by us, and that it will be named myModule (according to the argument we passed into module). But what is a barebones module? It's an instantiation of a Marionette.Module object.

Module comes with a bit of functionality baked in, such as events (through EventAggregator, which we'll discuss thoroughly in a later article), starting with initializers (just like Application has), and stopping with finalizers (we'll go over that in the "Starting and Stopping Modules" section).

Standard Module Definition

Now let's look at how to define a module with some of our own functionality.

  App.module("myModule", function(myModule, App, Backbone, Marionette, $, _){      // Private Data And Functions      var privateData = "this is private data";        var privateFunction = function(){          console.log(privateData);      }        // Public Data And Functions      myModule.someData = "public data";        myModule.someFunction = function(){          privateFunction();          console.log(myModule.someData);      }  });

As you can see, there's a lot of stuff in there. Let's look at the top line and work our way down. Just like before, we call App.module and provide a name for the module. But now we're also passing a function in, too. The function is passed several arguments. I bet you can figure out what they are, based on the names I've given them, but I'll still explain them all:

myModule is the very module you're trying to create. Remember, it's already created for you, and it's a new instance of Module. You're probably going to want to extend this with some new properties or methods; otherwise, you might as well stick with the short syntax that doesn't require you to pass in a function.
App is the Application object that you called module on.
Backbone is, of course, the reference to the Backbone library.
Marionette is the reference to the Backbone.Marionette library. It is actually available through Backbone, but this allows you to alias it and make it a shorter name.
$ is your DOM library, which will be either jQuery or Zepto (or possibly something else in the future).
_ is a reference to Underscore or Lodash, whichever you're using.

After that, you can actually pass in and use custom arguments. We'll go over this in a bit.

Normally, I would say that most of these arguments are unnecessary; after all, why wouldn't you already have access to these references? However, I could see these being useful in a couple of situations:

A minifier can shorten the names of the arguments, saving some bytes.
If you're using RequireJS or some other module loader, you only need to pull in the Application object as a dependency. The rest will be available through the arguments given to you by Module.

Anyway, let's get back to explaining the rest of what's going on in the code above. Inside the function, you can utilize the closure to create private variables and functions, which is what we've done. You can also expose data and functions publicly by adding them as properties of myModule. This is how we create and extend our module. There is no need to return anything because the module will be accessible directly through App, as I'll explain in the "Accessing a Module" section below.

Note: Make sure that you only try to add properties to your module variable and do not set it equal to something (for example, myModule = {…}), because when you set your module variable to something, that changes what the variable's name is referencing, and none of the changes you specify will show up in your module later.

Earlier, I noted that you can send in custom arguments. In fact, you can send in as many custom arguments as you want. Take a look at the code below to see how it's done.

  App.module("myModule", function(myModule, App, Backbone, Marionette, $, _, customArg1, customArg2){      // Create Your Module  }, customArg1, customArg2);

As you can see, if you pass additional arguments to module, it will pass those in to the function that you are defining your module in. Once again, the biggest benefit I see from this is saving some bytes after minification; other than that, I don't see much value.

Another thing to note is that the this keyword is available within the function and actually refers to the module. This means you don't even need the first argument, but you would lose the advantage of minification if you didn't use the argument. Let's rewrite that first code using this so that you can see that it's exactly the same as myModule.

  App.module("myModule", function(){      // Private Data And Functions      var privateData = "this is private data";        var privateFunction = function(){          console.log(privateData);      }        // Public Data And Functions      this.someData = "public data";        this.someFunction = function(){          privateFunction();          console.log(this.someData);      }  });

As you can see, because I'm not using any of the arguments, I decided not to list any of them this time. It should also be obvious that you can skip the first argument and just use this.

Split Definitions

The final thing I'll mention about defining modules is that we can split up the definitions. I don't know exactly why you would want to do this, but someone might want to extend your modules later, so splitting up the definitions might help them avoid touching your original code. Here's an example of split definitions:

  // File 1  App.module("myModule", function(){      this.someData = "public data";  });    // File 2   App.module("myModule", function(){      // Private Data And Functions      var privateData = "this is private data";        var privateFunction = function(){          console.log(privateData);      }        this.someFunction = function(){          privateFunction();          console.log(this.someData);      }  });

This gives us the same result as the previous definition, but it's split up. This works because in File 2, the module that we defined in File 1 is being given to us (assuming that File 1 was run before File 2). Of course, if you're trying to access a private variable or function, it has to be defined in the module definition where it is used because it's only available within the closure where it is defined.

Accessing A Module

What good is creating modules if we can't access them? We need to be able to access them in order to use them. Well, in the very first code snippet of this article, you saw that when I called module, I assigned its return value to a variable. That's because we use the very same method to both define and retrieve modules.

  var myModule = App.module("myModule");

Normally, if you're just trying to retrieve the module, you'll pass in the first argument, and module will go out and grab that module for you. But if you pass in a function as the second argument, the module will be augmented with your new functionality, and it will still return your newly created or modified module. This means you can define your module and retrieve it all with a single method call.

This isn't the only way to retrieve modules, though. When a module is created, it is attached directly to the Application object that it was constructed with. This means you can also use the normal dot notation to access your module; but this time, it must be defined beforehand, otherwise you'll get undefined back.

  // Works but I don't recommend it  var myModule = App.myModule;

While this syntax is shorter, it doesn't convey the same meaning to other developers. I would recommend using module to access your modules so that it is obvious you are accessing a module and not some other property of App. The convenience and danger here is that it will create the module if it doesn't already exist. The danger comes if you misspell the name of the module; you won't have any way of knowing that you didn't get the correct module until you try to access a property on it that doesn't exist.

Submodules

Modules can also have submodules. Sadly, Module doesn't have its own module method, so you can't add submodules to it directly, but that won't stop us. Instead, to create submodules, you call module on App, just like you used to do; but for the name of the module, you need to put a dot (.) after the parent module's name and then put the name of the submodule.

  App.module('myModule.newModule', function(){      ...  });

By using the dot separator in the module's name, Marionette knows that it should be creating a module as a submodule of the module before the dot. The cool (and potentially dangerous) part is that if the parent module isn't created at the time that you call this, it will create it along with its submodule. This can be dangerous because of the same potential for misspelling that I mentioned earlier. You could end up creating a module that you didn't intend to create, and the submodule would be attached to it, instead of to the module you intended.

Accessing Submodules

As before, submodules can be accessed the very same way they are defined, or you can access them as properties of the module.

  // These all work. The first example is recommended  var newModule = App.module('myModule.newModule');  var newModule = App.module('myModule').newModule;  var newModule = App.myModule.newModule;    // These don't work. Modules don't have a 'module' function  var newModule = App.myModule.module('newModule');  var newModule = App.module('myModule').module('newModule');

Any of these methods of accessing the submodule will work equally well if both the module and submodule have already been created.

Starting And Stopping Modules

If you read the previous article in the series, about Application, you will know that you can start an Application with start. Well, starting modules is the same, and they can also be stopped with stop.

If you recall (assuming you've read the previous article), you can add initializers with addInitializer to an Application, and they will be run when it is started (or will run immediately if the Application has already started). A few other things happen when you start an Application. Here are all of the events, in order:

fires the initialize:before event,
starts all of the defined modules,
runs all of the initializers in the order they were added,
fires the initialize:after event,
fires the start event.

A Module behaves in a very similar way. The number of events and some of the names of the events are different, but overall it is the same process. When a module is started, it:

fires the before:start event,
starts all of its defined submodules,
runs all of its initializers in the order they were added,
fires the start event.

The stop method is also very similar. Instead of adding initializers, though, you need to add finalizers. You do this with addFinalizer and by passing in a function to run when stop is called. Unlike with initializers, no data or options are passed along to each of the functions. When stop is called, it:

fires the before:stop event,
stops its submodules,
runs its finalizers in the order they were added,
fires the stop event.

Initializers and finalizers aren't only meant for use by others. In fact, they are quite helpful when used inside the module definition. This way, you can define a module inside the definition without actually creating any objects to be used, but then write your initializers to start creating the objects and setting them up, such as in the example below.

  App.module("myModule", function(myModule){      myModule.startWithParent = false;        var UsefulClass = function() {...}; // Constructor definition      UsefulClass.prototype ... // Finish defining UsefulClass      ...        myModule.addInitializer(function() {          myModule.useful = new UsefulClass();          // More setup      });        myModule.addFinalizer(function() {          myModule.useful = null;          // More tear down      });  });

Automatic And Manual Starting

When a module is defined, by default it will automatically start at the same time that its parent starts (either the root Application object or a parent module). If a module is defined on a parent that has already started, it will start immediately.

You can set up a module to not start automatically by changing its definition in one of two ways. Inside the definition, you can set a module's startWithParent property to false, or you can pass an object (instead of a function) to module that has a startWithParent property set to false and a define property to replace the normal function.

  // Set 'startWithParent' inside function  App.module("myModule", function(){      // Assign 'startWithParent' to false      this.startWithParent = false;  });    // -- or --    // Pass in object   App.module("myModule", {      startWithParent: false,        define: function(){          // Define module here      }  });    App.start();    // myModule wasn't started, so we need to do it manually  App.module('myModule').start("Data that will be passed along");

Now the module won't autostart. You must call start manually to start it, as I did in the example above. The data that is passed to start could be anything of any type, and it will be passed along to the submodules when they're started, to the initializers, and to the before:start and start events.

As I said, data isn't passed along like this when you call stop. Also, stop must be called manually, and it will always call stop on submodules; there is no way around this. This makes sense because a submodule shouldn't be running when its parent isn't running, although there are cases when a submodule should be off when its parent is running.

Other Events And Built-In Functionality

I mentioned that Module comes with some baked-in functionality, such as the EventAggregator. As discussed, we can use the on method on a module to watch for events related to starting and stopping. That's not all. There are no other built-in events, but a module can define and trigger their own events. Take a look:

  App.module('myModule', function(myModule) {      myModule.doSomething = function() {          // Do some stuff          myModule.trigger('something happened', randomData);      }  });

Now, whenever we call doSomething on the module, it will trigger the something happened event, which you can subscribe to:

  App.module('myModule').on('something happened', function(data) {      // Whatever arguments were passed to `trigger` after the name of the event will show up as arguments to this function      // Do something with `data`  });

This is very similar to the way we do things with events on collections, models and views in normal Backbone code.

How We Might Actually Use A Module

The modules in Marionette can definitely be used to define modules very similarly to any other module definition library, but that's actually not how it was designed to be used. The built-in start and stop methods are an indication of this. The modules that Marionette includes are meant to represent somewhat large subsystems of an application. For example, let's look at Gmail.

Gmail is a single application that actually contains several smaller applications: email client, chat client, phone client and contact manager. Each of these is independent — it can exist on its own — but they are all within the same application and are able to interact with one another. When we first start up Gmail, the contact manager isn't up, and neither is the chat window. If we were to represent this with a Marionette application, each of those sub-applications would be a module. When a user clicks the button to open the contact manager, we would stop the email application (because it becomes hidden — although, for speed, we could keep it running and just make sure it doesn't show in the DOM) and start the contacts manager.

Another example would be an application built largely out of widgets. Each widget would be a module that you can start and stop in order to show or hide it. This would be like a customizable dashboard such as iGoogle or the dashboard in the back end of WordPress.

Of course, we're not limited to using Marionette's modules in this way, although it's difficult to use it in the traditional sense. This is because Marionette's modules are fully instantiated objects, while traditional modules are "classes" that are meant for instantiation later.

Conclusion

Phew! That's a lot of information. If you've made it this far, I commend you (although it was much easier for you to read this than for me to write it). Anyway, I hope you've learned a lot about the way that Marionette handles defining, accessing, starting and stopping modules and submodules. You may find it to be a very handy tool, or you might choose to completely ignore its existence. That's one of the great things about Backbone and Marionette: most of their features are largely independent, so you can pick and choose what you want to use.

Credits of image on front page: ruiwen

(al) (ea)

L'amaro sfogo di Napolitano, il femminismo spicciolo e l'irresponsabilità dei partiti

Apr 2nd 2013, 10:14

Il Presidente della Repubblica Napolitano: «sui saggi critiche ingiuste e insolenti»

L'amaro sfogo del Presidente della Repubblica Napolitano è il termometro più indicativo della deriva politica del nostro Paese. La scelta della commissione dei Saggi non è proprio andata giù a nessuno. «Sono stato lasciato solo dai partiti» ha dichiarato, «su di me sospetti e dietrologie incomprensibili». Isolato e ritenuto colpevole, da parte di certa stampa e dalla politica, dello stallo istituzionale in cui siamo impantanati ormai da più di un mese. Dopo le recenti e inconcludenti elezioni, nell'incapacità e nell'irresponsabilità dei partiti di trovare un accordo per poter governare un Paese ormai allo sbando, i partiti si sono prima lavati le mani rimettendo la scelta di come poter districare l'ingarbugliata matassa nelle mani del capo dello Stato. Poi lo hanno accusato per la scelta dell'istituzione della commissione dei saggi.

Molti hanno rimproverato a Napolitano il fatto di non essersi dimesso. Dico che sono parole senza senso. Sarebbe stato un atto irresponsabile, di una gravità inammissibile, che avrebbe lasciato un totale vuoto istituzionale in un Paese senza Governo e senza Capo dello Stato. Una follia. Sempre se non ci fosse stato qualcuno a cui quella situazione pericolante avesse fatto gioco.

La gazzarra delle solite femministe incallite che criticano la mancanza di donne nella commissione dei saggi ha il sapore stantio di quelle vane battaglie ideologiche perse in partenza. Che poi a guardar bene sono le stesse femministe che non si scandalizzano più di tanto se qualche intellettualoide afferma che il Parlamento è pieno di "troie". Perché associando l'epiteto alle tanto chiacchierate figure femminili che hanno frequentato i palazzi romani del potere nelle legislature passate, quel termine, per loro, trova una relativistica e accettabile giustificazione. Non siete assolutamente credibili signore care. Anzi, lo siete meno che niente.

E in tutto questo i maggiori partiti continuano a intorbidire le acque senza alcuna intenzione di voler risolvere la faccenda. Dal risultato di queste elezioni hanno tutti gustato il sapore della vittoria ma formalmente hanno perso tutti quanti. Fa più comodo dimenarsi in una cagnara rumorosa, nella speranza di tornare immediatamente alle urne, piuttosto che lavorare in maniera costruttiva per il Paese. Lavandosi di ogni responsabilità. Arroccandosi dietro posizioni d'intransigenza incommentabili. E ora, in malafede, vogliono provare a scaricare le loro colpe sul Capo dello Stato. Non regge. Perché siete voi gli unici responsabili dello sfacelo.

The Underhanded C Contest Is Back

Apr 2nd 2013, 09:04

Xcott Craver writes "After several years of inactivity, the Underhanded C contest has returned. The object is to write a short, readable, innocent-looking computer program that nevertheless performs some evil function for reasons that are not obvious under code review. The prize is a $200 gift certificate to ThinkGeek." The deadline is July 4th, so get to hacking.

Read more of this story at Slashdot.

Flat Surface Shader: An Awesome Lighting Simulator

Apr 2nd 2013, 07:52

Advertise here via BSA

Admit it, 3D is cool. But, you know what’s cooler? 2D. I love WebGL, but unfortunately it doesn’t work everywhere. Flat Surface Shader is a lighting simulation, which can be configured to use either the 2D context of a canvas element or an array of SVG polygons to draw the triangles. It also utilises native Float32Arrays to store numerical data for highly optimised calculations. You can export the image once you have done.

Requirements: -
Demo: http://wagerfield.github.com/flat-surface-shader/
License: License Free

Relative vs. Absolute Units

In terms of measurement, every length is expressed in relation to some basic unit. All measurement systems provide a standard set of units with which to compare and calibrate all other units and measurement devices.

Units (as far as CSS goes) can be absolute or relative, depending on whether their basic unit depends on the context within which it’s used. For computer displays, the basic unit is the pixel, to which all other units are recalculated when objects are finally rendered to the screen. Although the pixel is treated as a relative unit, it is nevertheless dependent on two parameters: the screen’s physical size and its resolution. I’ll cover how pixels relate to physical units later in the article.

Other units, such as percentages (denoted by the % symbol), are dependent on the context of their use. They can express a proportion of a container’s width or height or a proportion of the current font size or line height.

First, let’s cover absolute CSS units.

Absolute CSS Length Units

Absolute CSS units (see Table 1) express a length that is not dependent on the context of use—an inch is an inch, regardless of where it is measured. There is, however, a discrepancy that you should be aware of when you’re using nonpixel absolute units, and that is display pixel density.

Table 1 Available CSS Absolute Units

A display has an inherent property that is measured in pixels per length unit. The convention is to use the inch as the basic unit of length to measure the number of pixels that fit inside a display (expressed as dots per inch, or DPI). As you might guess, different displays have different pixel densities.

A typical HD TV display has a resolution of 1920 × 1080 pixels and (for the sake of this example) a physical size of 40 × 22.5 inches. Taking either dimension and dividing the pixels by the length, you get the display’s DPI:

1920 px / 40 in. = 48 DPI

A low DPI value such as this tells you that the pixels on this display are rather large, because a TV is meant to be viewed at a distance, which makes the pixels appear smaller than they would at arm’s length.

In contrast, mobile devices are meant to be viewed at less than arm’s length, but they still need to fit in the palm and pack enough resolution for characters to be legible—or else they risk having to expose the user to keyhole browsing because of the extremely low pixel resolution, which forces the user to scroll across the document instead of enabling him to see the whole block of text.

The current spur of growth in high-end, high-performance mobile devices has culminated in high density display in use on various Windows Phone, Android and iOS devices, of which the Retina display is one of the earliest examples of high-DPI displays. Its original resolution was 960 × 640 pixels, and it had a diagonal size of 3.5 inches, which makes its pixel density 326 DPI. Comparing this value to the one calculated for the TV, you can see that the mobile device has almost seven times as many pixels per inch as the TV.

If you know a display’s DPI, you can calculate the length in pixels by multiplying the length by its DPI. Say you have a cropped image that’s 2 × 1.5 inches and want to display it on the TV:

2 in. × 48 DPI = 96 px 1.5 in. × 48 DPI = 72 px

A 96 px × 72 px image on the TV would cover only a tiny portion of the display area, but it would be rendered true to its physical size. On the other hand, rendering the same image on the Retina display gives a very different result:

2 in. × 326 DPI = 652 px 1.5 in. × 326 DPI = 489 px

Judging by the pixel sizes, the object displayed on the Retina display would render at 6.8 times the size of the object on the TV. But, interestingly, the object would render at the same physical size on both displays.

Yet, when you specify absolute units in Web pages, you often (if not always) get different results. A centimeter-wide image is rendered at different sizes on different devices. It appears large on TVs and small on mobile devices. Two reasons account for this: one is historical, and the other is readability.

In terms of readability, it wouldn’t make sense to display documents at their true physical sizes on different size screens, since that would imply that you were reading them at the same distance. Also, the pixel density would make documents displayed on larger devices seem blurred while, conversely, rendering the same document on smaller devices takes too much space.

To overcome this, early operating system developers adopted a fixed DPI value that would map absolute units to pixels directly, ignoring the real DPI value of the device. Apple first adopted a DPI value of 72, while Microsoft opted for 96. Eventually, everyone adopted 96 as the norm, including for browsers.

This fixed value applies only to display screens (media types such as those designated by the keywords screen and scan), however. Printer devices do apply correct absolute units, so it’s safe to assume that a print layout will print exactly as it is laid out, regardless of the printer type and make.

Relative CSS Length Units

In contrast to absolute units, relative units in CSS (see Table 2) have no fixed values with which to be compared. Some are relative to the container they’re used in, others to the display properties (viewport width and height). The only relative unit that is consistently rendered at the same size across different browsers and displays is the pixel (a white lie, it turns out, when dealing with high-density displays, discussed later).

Table 2 CSS Relative Units and Their Relation to Reference Elements

Pixels (px)

The px unit is always relative to the physical pixel on the given display device. A 20 px × 20 px rectangle will always be rendered at the same pixel sizes, regardless of the display type.

Retina and high-end Android displays render all Web pages at some multiple of their pixel resolution. To take full advantage of the display resolution, you can use oversize images and scale them down to make them appear sharper on such devices.

The Apple Retina display, for example, exactly doubles the DPI value of the screen in previous-generation iPhones. The browser renders all pixel dimensions at double the size, displaying a 20 px ×

20 px rectangle at 40 px × 40 px to offset the higher pixel density (at 1:1 zoom, pinch-zooming a web page skews this ratio).

Other device manufacturers have followed suit with their own offering of high-density displays, especially on high-end Android devices, where pixel densities vary considerably, running the gamut from 100 to 350 DPI. As a consequence, browsers on these devices adopt these values to stick to one of the common viewport widths on an otherwise arbitrarily wide screen. You can detect the device pixel vs. CSS pixel ratio by reading the window.devicePixelRatio property in JavaScript or using the DPI media query, enabling you to set additional CSS properties to .

It follows that pixels on the Web almost never render at their device pixel’s size and should be treated as a relative unit. There is, however, an upper limit to how dense the pixels will be packed in future devices—the human eye is generally unable to resolve individual pixels above 300 DPI at arm’s length, which is the expected viewing distance for such devices anyway. Currently, future devices aren’t expected to increase resolution in this respect, since there would be no noticeable increase in display clarity.

Percentages (%)

Percentages are probably the most well known of the units used in Web design, leveraging the power of proportions to reflow documents according to the space available to render them. Percentages are used most extensively in fluid Web page layouts where one size (tries) to fit all by defining proportions relative to their container or inherited font size.

It is a simple unit to understand: when you are working with box-model dimensions, the unit is relative to its parent’s dimensions. By default, this size includes the content box and excludes padding and border sizes.

Figure 1 Font metrics mapped to CSS attributes

When you are using the unit with typography-related dimension attributes, a different handling logic is required for each of the attributes (see Figure 1 for attribute reference):

font-size: Relative to the inherited font-size
line-height: Relative to the current element’s font-size
letter-spacing: Has no effect

When you define line-height, be aware that it’s always relative to the current font size, not it’s container’s line-height:

p { font: normal 16px/200% serif }

The preceding example evaluates line-height to 32 px, regardless of its container’s line-height.

Ems (em)

Ems is a handy typographical unit that takes its measure from the current element’s font-size. Historically, this unit was used to express dimensions relative to the width of a font’s letter M (minus its kerning), but it has evolved to encompass non-Latin scripts and is now an arbitrarily defined unit, set by the designer and coded into the font itself.

Figure 2 Two Fonts Rendered at the Same Size and Aligned Along the Baseline (left: News Gothic, right: Garamond)

At a given absolute size, a font’s apparent height might differ between font faces (see line-height in Figure 1). This effect is purely visual though, because the vertical measure (baseline positioning) doesn’t change when font faces are changed. (See Figure 2.)

When ems are used on the root element to define font-size, size is relative to the initial value—in other words, the browser’s default as set in the preferences dialog in the user’s profile.

As with percentages, the context of use for ems depends on which CSS attribute you are using it in. For every attribute this unit always relates to the current element’s font-size. The exception is font-size itself, which always refers to its parent’s font size.

X-Height (ex)

A similar unit to ems, ex denotes the height of the X character for the current font. This value is also defined by the font itself, but it is currently estimated by browsers to be one half of an em.

The same rules apply to ex as for em, so check the previous list of exceptions.

Viewport Width (vw) and Viewport Height (vh)

If you’ve ever tried to use elements dimensioned relative to the viewport size, you’ve basically been limited to two options: attaching elements as direct children to the element and sizing using percentages or using percentages on all elements and then calculating the inverse to compensate for the reductions.

To enable the use of viewport-relative sizes, you can use vw and vh in any element, no matter how deep within the hierarchy. The unit will always represent a percentage of the current viewport. For example, to create a box that is 50 percent of both the viewport width and height, simply use:

#mydiv { width: 50vw; height: 50vh; }

In contrast to percentages, the sizing context for viewport never changes, which means it’s safe to use this unit anywhere without fear of its size changing because of inherited sizing.

Smaller Viewport Dimension (vmin)

This unit behaves exactly as vw and vh, but with a twist: it equals whichever is the smaller of vw or vh. To illustrate this principle, take a simple div and apply the vmin unit to its dimensions:

#mydiv { width: 100vmin; height: 100vmin; }

Declaring width and height this way yields a square that exactly fits the viewport and never has its contents clipped, effectively making this the largest square that fits inside the viewport.

Width of 0 (ch)

This is a typography-related relative unit that doesn’t measure the height but rather the width of the character 0 (the number zero). If the current font family doesn’t contain the symbol, it takes the average width of all characters. The specification is currently a bit fuzzy about how this value should be measured, so it recommends taking the default value of 0.5 em when the 0 symbol is not present in the font.

The ch unit is very useful for defining horizontal typographical grids because multiples of this unit roughly correspond to the width of a string of the same number of characters. Here’s an example column that contains roughly 40 characters per line:

#mycolumn { width: 40ch }

Root Element m-height (rem)

Sometimes it’s useful to refer to the original font size somewhere deep inside the hierarchy and express font sizes using the root element. To address this use case, you can use the rem unit, which always refers to the font size in <body>:

#mydiv { font-size: 2rem; }

The text within this element will always be set at twice the size of the text of the <body> element, regardless of where inside the DOM you put it.

On Compatibility

CSS3 is no different from other cutting-edge technologies. While browsers are slowly implementing features and aspects of CSS3, some of the units I’ve described have been on the backburner of the features implemented. Currently, the browser that supports the most of the length units described in this article is Chrome, which supports vw, vh and vmin in a March 2012 changeset. Internet Explorer support has also improved significantly, as IE9 and later provide support for vw, vh and rem, as shown here. Also, Gecko has supported the rem unit since version 1.9.2.

Until we see wider support in other browsers, I’m afraid you cannot use these units with fallbacks because the behavior of these units prohibits you from emulating them by using other units without using JavaScript. Even so, responsive design and progressive enhancement will allow you to rely on sensible defaults and alternatives in case these units are not available by simply providing an alternative size declared before any use of an unsupported unit, for example:

#mycolumn { width: 320px; width: 40ch; }

In this case, the browser that doesn’t understand these units will use the previously declared value instead. Since some of the preliminary implementations of these units behave differently among

browsers, you should test these features extensively to see where fallbacks and workarounds are necessary.

For more information regarding CSS3, have a look at the supplementary content attached to this document.

About the Author

Klemen Slavič is a front-end engineer at Celtra Inc., working on the company’s self-service ad Web application and mobile runtimes. He currently holds MCT and MCPD Web certifications and is also an ACE in Photoshop. He’s a strong proponent of open Web technologies.

He started programming in 1996, working his way up from writing fractal renderers in Logo and BASIC into the Windows environment with Visual Basic 6 and eventually moved to the Web. He fell in love with HTML, CSS and JavaScript, which is currently his primary career and hobby focus.

In his free time he likes to keep on top of various emerging Web technologies, closed and open-source alike, and enjoys working on media-rich projects and performances. To get a birds-eye view, head over to his about.me page.