Category Archives: Computer Technology

Lenovo ThinkPad T440s, Ultrabook 14 Inci Full HD Artikel Baru CPU Intel Haswell & baterei 3-Cell Ganda

The presence of an Intel Core 4th generation Intel Haswell known as it turns out has brought blessing for Lenovo to immediately roll out the latest models of ultrabook and ThinkPad T440S Lenovo ThinkPad claimed to be the first to adopt the power of the processor.

Unlike most existing ThinkPad notebooks, Lenovo ThinkPad T440S This is more aimed at business users. Especially with premium features that it has, making super thin and light laptop is equipped with resilient chasing bandage made ​​of carbon fiber and magnesium, water resistant keyboard, touchpad with support for 5-point click and gesture, and a pointer nub in the middle of the keyboard , as well as dual battery setup that allows you menggonta-replace (remove plug) one batereinya without first turning off the existing system.

Lenovo ThinkPad T440s is itself supplied by feature 14-inch LCD screen with a resolution of 1600 × 900 option pixels or 1920 × 1080 pixels (HD + / FHD). As for users who want greater convenience in operation there, Lenovo also provides a choice of touch screen and support for NFC wireless technology.

Not only that, the article is a laptop with a 0.83-inch thick and weighs 1.5 kg has also been equipped by Mini DisplayPort and VGA, 3 USB 3.0 ports, 4-in-1 SD card reader, combo jack, and a smart card reader , HD anti-noise microphone dual stereo speakers with support Dolby ® HomeTheater ® v4 and two standard 3-cell battery that could have staying power usage up to 6 hours.

While about availability and price, unfortunately not yet known specific info related to it so far.

Lawyer Plugin for WordPress Promises Legal Resources and Nationwide Attorney Network

After two years of development, Lawyer Plugin (www.lawyerplugin.com) launched their first public version of what promises to be an essential plugin for any lawyer running a WordPress website.

Lawyer Plugin is the first plugin of its kind: it gives law firms access to hundreds of local resources which are automatically added, updated, and synced with Lawyer Plugin’s central servers every 24 hours.

The registration takes care of all settings automatically. For example, a bankruptcy lawyer in Tampa, Florida, creates his profile with his law firm’s name, address, city, state, and practice area(s). The plugin automatically pulls bankruptcy- and Florida-related resources onto the resource page which is created by the plugin. With that, the firm becomes part of the peer-to-peer legal directory which is then displayed on the websites of every plugin user.

Block Competition

When creating the plugin, the peer-to-peer directory presented a major challenge. A law firm does not want to display competing law firms on their website. To solve this problem, Lawyer Plugin has been designed to filter competitors and only displays non-competing listings on each user’s website.

Here is how the filter works:

Smith & Smith bankruptcy lawyers in Tampa, Florida, install Lawyer Plugin.

Lisa Johnson & Associates, elder law attorneys in Asheville, North Carolina, also installs Lawyer Plugin.

Bradley Baker & James bankruptcy lawyers in Tampa Florida installs Lawyer Plugin.

Foz & Oz Attorneys at Law, bankruptcy lawyers in Los Angeles, California, installs Lawyer Plugin, too.

On the Smith & Smith resources page, Lawyer Plugin will display the listing for Lisa Johnson & Associates, because that firm does not compete in Smith & Smith’s local market. It will also display the listing for bankruptcy attorneys Foz & Oz. Even though they are bankruptcy lawyers, Foz & Oz are in Los Angeles, and therefore not competing with the Tampa, Florida practice.

However, Bradley Baker & James will not be included on Smith & Smith’s website, and Smith & Smith will not be included on Bradley Baker & James website. Lisa Johnson & Associates will display listings for all three of the above firms, because none of them compete with her practice.

A Fun Brand for a Serious Industry

Lawyer Plugin breaks out of the stuffy legal mold. On Lawyerplugin.com, users will not find any bookshelves, gavels, or court house columns. Instead, they are offered an outlet for venting with a “Hate Mail” form and noting in their legal disclaimer that the plugin has not displayed any “violent behavior,” but cautions that the “adolescent years are right around the corner.”

Last year, Lawyer Plugin posted teasers on its Facebook and Twitter profiles as beta testing began. The question was asked: “How awesome will Lawyer Plugin be?” The answers —

Coffee will drink Lawyer Plugin to wake up.

You will never need a flu shot. The flu will need a Lawyer Plugin shot.

The earth will no longer rotate around the sun. The sun will be too busy rotating around Lawyer Plugin.

And it was even predicted that Christmas will begin celebrating Lawyer Plugin.

The Lawyer Plugin’s financial backers plan to keep the plugin free. Lawyer Plugin will continue to receive funding indefinitely as add-ons are developed, and a paid, professional version of Lawyer Plugin is also in the works.

Lawyer Plugin is free and out in the court of public opinion. The developers are thirsty for user feedback and additional ideas for features.

Toshiba Ultrabook Presents Stylish Dual Function

JAKARTA – Toshiba introduced the latest generation ultrabook, named “Portege Z10t”. This super-thin notebook is presented in order to meet the needs of professionals who require a technology to carry anywhere but still stylish.

Channel Manager of the Computer Systems Division of Toshiba Singapore Pte. Ltd., Albert Susilo, said that now the tablet has become a popular gadget. Many of the professionals who always move with a laptop and a tablet.

“This is why we re-present the latest generation of ultrabook Portege Z10t, which has two dual function,” said Albert the introduction Portege Z10t in Jakarta, Thursday (4/7).

This Ultrabook has advantages over its predecessor, which is designed with a water-resistant keyboard. “Water resistant up to 55 ml, both mineral water, coffee, tea to sodas,” said Senior Manager Marketing Service Toshiba Singapore, Tay Choon Song.

Portege Z10t is a 11.6-inch touch screen notebook with full HD IPS, which has a dual function. Weighing just 850 grams and a thickness of 24 millimeters, Portege Z10t notebook can function as well as tablets.

With 4GB of RAM, Portege Z10t available in two sophisticated processors, the Intel i5 and i7. Unfortunately, Toshiba Portege Z10t only just released in a choice of colors, namely gray metallic.

In that event, also introduced also a special gaming laptop, the Qosmio X70. Latop which was created specifically for the game lovers is equipped with Nvidia GeForce GTX770M graphics technology, the memory capacity of up to 1TB. “This is an extreme laptop for enthusiast gamers,” added Tay Choon Song.

Zulu Creative Launches Redesigned Website For MAX’s Wine Dive

Zulu Creative is proud to announce the launch of a new website for MAX’s Wine Dive, the award-winning, rockin’ restaurant concept from Houston-based Lasco Enterprises that combines gourmet comfort food with retail wine sales and features unlikely pairings such as fried chicken and champagne. The new website is mobile-friendly for diners on-the-go and contains unique content for five MAX’s locations in Austin, Dallas, Fort Worth, Houston and San Antonio, plus corporate-specific content. The MAX’s website is the second of three that Zulu Creative is designing for Lasco. A new website for Boiler House, Lasco’s Texas grill and wine garden concept located at the historic Pearl Brewery in San Antonio, was completed in fall 2012. A complete redesign of The Tasting Room site is forthcoming.

(Photo: http://photos.prnewswire.com/prnh/20130723/MN51688)

Taking its design cue from current branding, the new MAX’s site features a black and white color palette with red accents and bold typographical elements. Zulu Creative recommended key website enhancements to better convey MAX’s funky, eclectic brand vibe online. The website reflects each location’s unique ambience and personality through witty slogans on each page, graphical jukebox-inspired elements that evoke the restaurant’s dive-bar feel, and location-specific featured images.

Site visitors can easily make online reservations and access key information such as each location’s address, hours, contact information and menus. In addition, visitors can view each location’s calendar of events, read chef and wine manager bios, see private event/catering options, purchase gift cards online, sign up for MAX’s newsletter and easily connect with MAX’s through their social media channels. Press+Awards pages tout each location’s accolades, while a corporate Employment page lists all job openings by location and serves as a useful recruiting tool.

Designed and built on a content management system (CMS) platform with multisite functionality, the website is scalable, making it easy to manage multiple websites through a single interface and add new sites as Lasco opens new MAX’s locations.

“We are extremely excited about the new website for MAX’s Wine Dive created by the talented team at Zulu Creative,” said Jonathan Horowitz, Chief Brand Officer of Lasco Enterprises. “Throughout the entire creative process, the Zulu team exercised intense attention to detail and introduced a new site that is easy for our guests to navigate, as well as met our goal to produce a product which mimics the energy, look and feel of the MAX’s Wine Dive concept.”

“Designing sites for three award-winning Lasco brands is an exciting opportunity and huge honor,” says Tina Zulu, Founder and Creative Chieftess of Zulu Creative. “Our experience creating websites for other successful restaurants and bars made the Boiler House, MAX’s Wine Dive and The Tasting Room projects a perfect fit for us, and our teams work extremely well together. We couldn’t be more thrilled and congratulate Lasco on their continued success and growth. Cheers!”

About Zulu Creative
Fun! And smart! Zulu Creative is a boutique agency in Midtown Houston, Texas, specializing in marketing and brand development for lifestyle businesses that serve consumer niche markets. The Zulu crew is a dynamic team of intelligent professionals who are energetic, innovative, passionate and reliable. Clients who choose Zulu Creative get a big bang for their buck, benefit from a diverse team of experience and talent, and enjoy a smashing, cutting-edge image in the Houston community, nationally and globally. Whether a brand needs a kick-start, upgrade or extreme makeover, Zulu Creative is known for creating memorable experiences and making an impact. It’s all about positioning brands at the top of the target audience’s mind. Zulu Creative accomplishes it through innovative, integrated marketing. For more information, visit www.zulucreative.com

About Lasco Enterprises
Established by Jerry and Laura Lasco in Houston in 2003, Lasco Enterprises, LLC is the parent company for MAX’s Wine Dive (Houston, Austin, San Antonio, Dallas and Ft. Worth), The Tasting Room Wine Cafés, Lasco Events & Catering, Boiler House Texas Grill & Wine Garden (San Antonio), and The Black Door online wine community, and now has more than 500 employees in five cities. In 2010, Inc. 5000 named Lasco Enterprises one of the fastest growing private companies in the U.S. In 2011 and 2012, Lasco was named as one of the “Best Companies to Work for in Texas” by the Best Companies Group. The Houston Business Journal named Lasco Enterprises to its Fast 100 list of fastest-growing private companies in Houston in 2009, 2010, 2011 and in 2012. In 2009 and in 2012, the publication awarded Lasco the Houston Business Journal’s “Enterprise Champion” award for the company’s commitment to its employees, the communities in which it operates, and for its contributions to its industry. For more information, visitwww.lascoenterprises.com

It’s a Mad, Mad, Mad, Mad World: Scoping in CoffeeScript and JavaScript

CoffeeScript, as many people know, is a transpile-to-JavaScript language.1 For the most part, it does not introduce major changes in semantics. For example, this:

-> 'Hello, world'

Transpiles directly to:

function () { return 'Hello, world'; }

This is convenient syntactic sugar, and by removing what some folks call the “syntactic vinegar” of extraneous symbols, it encourages the use of constructs that would otherwise make the code noisy and obscure the important meaning. The vast majority of features introduced by CoffeeScript are of this nature: They introduce local changes that transpile directly to JavaScript.2

CoffeeScript also introduces features that don’t exist in JavaScript, such as destructuring assignment and comprehensions. In each case, the features compile directly to JavaScript without introducing changes elsewhere in the program. And since they don’t look like existing JavaScript features, little confusion is created.

equals doesn’t equal equals

One CoffeeScript feature does introduce confusion, and the more you know JavaScript the more confusion it introduces. This is the behaviour of the assignment operator, the lowly (and prevalent!) equals sign:

foo = 'bar'

Although it looks almost identical to assignment in JavaScript:

foo = 'bar';

It has different semantics. That’s confusing. Oh wait, it’s worse than that: Sometimes it has different semantics. Sometimes it doesn’t.

So what’s the deal with that?

Well, let’s review the wonderful world of JavaScript. We’ll pretend we’re in a browser application, and we write:

foo = 'bar';

What does this mean? Well, it depends: If this is in the top level of a file, and not inside of a function, then foo is a global variable. In JavaScript, global means global across all files, so you are now writing code that is coupled with every other file in your application or any vendored code you are loading.

But what if it’s inside a function?

function fiddleSticks (bar) {
  foo = bar;
  // ...
}

For another example, many people enclose file code in an Immediately Invoked Function Expression (“IIFE”) like this:

;(function () {
  foo = 'bar'
  // more code...
})();

What do foo = 'bar'; or foo = bar; mean in these cases? Well, it depends as we say. It depends on whether foo is declared somewhere else in the same scope. For example:

function fiddleSticks (bar) {
  var foo;
  foo = bar;
  // ...
}

Or:

function fiddleSticks (bar) {
  foo = bar;
  // ...
  var foo = batzIndaBelfrie;
  // ...
} 

Or even:

function fiddleSticks (bar) {
  foo = bar;
  // ...
  function foo () {
    // ...
  }
  // ...
}

Because of something called hoisting,3 these all mean the same this: foo is local to function fiddleSticks, and therefore it is NOT global and ISN’T magically coupled to every other file loaded whether written by yourself or someone else.

nested scope

JavaScript permits scope nesting. If you write this:

function foo () {
  var bar = 1;
  var bar = 2;
  return bar;
}

Then bar will be 2. Declaring bar twice makes no difference, since both declarations are in the same scope. However, if you nest functions, you can nest scopes:

function foo () {
  var bar = 1;
  function foofoo () {
    var bar = 2;
  }
  return bar;
}

Now function foo will return 1 because the second declaration of bar is inside a nested function, and therefore inside a nested scope, and therefore it’s a completely different variable that happens to share the same name. This is called shadowing: The variablebar inside foofoo shadows the variable bar inside foo.

javascript failure modes

Now over time people have discovered that global variables are generally a very bad idea, and accidental global variables doubly so. Here’s an example of why:

function row (numberOfCells) {
  var str = '';
  for (i = 0; i < numberOfCells; ++i) {
    str = str + '<td></td>';
  }
  return '<tr>' + str + '</tr>';
}

function table (numberOfRows, numberOfColumns) {
  var str = '';
  for (i = 0; i < numberOfRows; ++i) {
    str = str + row(numberOfColumns);
  }
  return '<table>' + str + '</table>';
}

Let’s try it:

table(3, 3)
  //=> "<table><tr><td></td><td></td><td></td></tr></table>"

We only get one row, because the variable i in the function row is global, and so is the variable i in the function table, so they’re the exact same global variable. Therefore, after counting out three columns, i is 3 and the for loop in table finishes. Oops!

And this is especially bad because the two functions could be anywhere in the code. If you accidentally use a global variable and call a function elsewhere that accidentally uses the same global variable, pfft, you have a bug. This is nasty because there’s this weird action-at-a-distance where a bug in one file reaches out and breaks some code in another file.

Now, this isn’t a bug in JavaScript the language, just a feature that permits the creation of very nasty bugs. So I call it a failure mode, not a language bug.

coffeescript to the rescue

CoffeeScript addresses this failure mode in two ways. First, all variables are local to functions. If you wish to do something in the global environment, you must do it explicitly. So in JavaScript:

UserModel = Backbone.Model.extend({ ... });
var user = new UserModel(...);

While in CoffeeScript:

window.UserModel = window.Backbone.Model.extend({ ... })
user = new window.UserModel(...)

Likewise, CoffeeScript bakes the IIFE enclosing every file in by default. So instead of:

;(function () {
  // ...
})();

You can just write your code.4

The net result is that it is almost impossible to replicate the JavaScript failure mode of creating or clobbering a global variable by accident. That is a benefit.

what would coffeescript do?

This sounds great, but CoffeeScript can be surprising to JavaScript programmers. Let’s revisit our table function. First, we’ll fix it:

function row (numberOfCells) {
  var i,
      str = '';
  for (i = 0; i < numberOfCells; ++i) {
    str = str + '<td></td>';
  }
  return '<tr>' + str + '</tr>';
}

function table (numberOfRows, numberOfColumns) {
  var i,
      str = '';
  for (i = 0; i < numberOfRows; ++i) {
    str = str + row(numberOfColumns);
  }
  return '<table>' + str + '</table>';
}

table(3, 3)
  //=> "<table><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>"

Good! Now suppose we notice that no function calls row other than table. Although there is a slightly more “performant” way to do this, we decide that the clearest and simplest way to indicate this relationship is to nest row inside table Pascal-style:

function table (numberOfRows, numberOfColumns) {
  var i,
      str = '';
  for (i = 0; i < numberOfRows; ++i) {
    str = str + row(numberOfColumns);
  }
  return '<table>' + str + '</table>';

  function row (numberOfCells) {
    var i,
        str = '';
    for (i = 0; i < numberOfCells; ++i) {
      str = str + '<td></td>';
    }
    return '<tr>' + str + '</tr>';
  }
}

It still works like a charm, because the i in row shadows the i in table, so there’s no conflict. Okay. Now how does it work in CoffeeScript?

Here’s one possible translation to CoffeeScript:

table = (numberOfRows, numberOfColumns) ->
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "<table><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>"

It works just fine. Here’s another:

table = (numberOfRows, numberOfColumns) ->
  str = ""
  i = 0
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "<table><tr><td></td><td></td><td></td></tr></table>"

Broken! And a third:

str = ""
i = 0
table = (numberOfRows, numberOfColumns) ->
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "<table><tr><td></td><td></td><td></td></tr></table>"

Also broken! Although the three examples look similar, the first gives us what we expect but the second and third do not. What gives?

Well, CoffeeScript doesn’t allow us to “declare” that variables are local with var. They’re always local. But local to what? In CoffeeScript, they’re local to the function that either declares the variable as a parameter or that contains the first assignment to the variable.5 So in our first example, reading from the top, the first use of str and i is inside the row function, so CoffeeScript makes them local to row.

A little later on, the code makes an assignment to i and str within the table function. This scope happens to enclose row’s scope, but it is different so it can’t share the strand i variables. CoffeeScript thus makes the i and str in table variables local totable. As a result, the i and str in row end up shadowing the i and str in table.

The second example is different. The first i encountered by CoffeeScript is in table, so CoffeeScript makes it local to table as we’d expect. The second i is local to row. But since row in enclosed by table, it’s possible to make that i refer to the i already defined, and thus CoffeeScript does not shadow the variable. The i inside row is the same variable as the i inside table.

In the third example, i (and str) are declared outside of both table and row, and thus again they all end up being the same variable with no shadowing.

Now, CoffeeScript could scan an entire function before deciding what variables belong where, but it doesn’t. That simplifies things, because you don’t have to worry about a variable being declared later that affects your code. Everything you need to understand is in the same file and above your code.

In many cases, it also allows you to manipulate whether a variable is shadowed or not by carefully controlling the order of assignments. That’s good, right?

all those against the bill, say “nay nay!”

Detractors of this behaviour say this is not good. When JavaScript is written using var, the meaning of a function is not changed by what is written elsewhere in the file before the code in question. Although you can use this feature to control shadowing by deliberately ordering your code to get the desired result, a simple refactoring can break what you’ve already written.

For example, if you write:

table = (numberOfRows, numberOfColumns) ->
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "<table><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td></tr></table>"

All will be well, until you are debugging late one night, and you add:

console.log('Hello!') for i in [1..5]

table = (numberOfRows, numberOfColumns) ->
  row = (numberOfCells) ->
    str = ""
    i = 0
    while i < numberOfCells
      str = str + "<td></td>"
      ++i
    "<tr>" + str + "</tr>"
  str = ""
  i = 0
  while i < numberOfRows
    str = str + row(numberOfColumns)
    ++i
  return "<table>" + str + "</table>"

table(3,3)
  #=> "table><tr><td></td><td></td><td></td></tr></table>"

This breaks your code because the i you used at the top “captures” the other variables so they are now all the same thing. To someone used to JavaScript, this is a Very Bad Thing™. When you write this in JavaScript:

function row (numberOfCells) {
  var i,
      str = '';
  for (i = 0; i < numberOfCells; ++i) {
    str = str + '<td></td>';
  }
  return '<tr>' + str + '</tr>';
}

It will always mean the same thing no matter where it is in a file, and no matter what comes before it or after it. There is no spooky “action-at-a-distance” where code somewhere else changes what this code means. Whereas in CoffeeScript, you don’t know whether the iin row is local to row or not without scanning the code that comes before it in the same or enclosing scopes.

coffeescript’s failure mode

In this case, CoffeeScript has a failure mode: The meaning of a function seems to be changed by altering its position within a file or (in what amounts to the same thing) by altering code that appears before it in a file in the same or enclosing scopes. In contrast, JavaScript’s var declaration never exhibits this failure mode. JavaScript has a different action-at-a-distance failure mode, where neglecting var causes action at a much further distance: The meaning of code can be affected by code written in an entirely different file.

Mind you, the result of calling our row function is not affected by declaring an i in an enclosing scope. Our function always did what it was expected to do and always will. Although you and I know why the change breaks the table function is that row now uses an enclosed variable, imagine that we were writing unit tests. All of our tests for row would continue to pass, it’s the tests for table that break. So in an evidence-based programming sense, when we maintain the habit of always initializing variables we expect to use locally, changing code outside of those functions only changes the evidence that the enclosing code produces.

So one way to look at this is that row is fine, but moving i around changes the meaning of the code where you move i. And why wouldn’t you expect making changes to tableto change its meaning?

so which way to the asylum?

If you ask around, you can find people who dislike JavaScript’s behaviour, and others who dislike CoffeeScript’s behaviour. Accidentally getting global variables when you neglectvar is brutal, and action-at-a-distance affecting the meaning of a function (even if it is always within the same file) flies against everything we have learned about the importance of writing small chunks of code that completely encapsulate their behaviour.

Of course, programmers tend to internalize the languages they learn to use. If you write a lot of JavaScript, you habitually use var and may have tools that slap your wrist when you don’t. You’re bewildered by all this talk of action-at-a-distance. It will seems to you to be one of those rookie mistake problems that quickly goes away and is not a practical concern.

Likewise, if you write twenty thousand lines of CoffeeScript, you may never be bitten by its first-use-is-a-declaration behaviour. You may be in the habit of using variable names likeiRow and iColumn out of habit. You may find that your files never get so large and your functions so deeply nested that a “capture” problem takes longer than three seconds to diagnose and fix.

It’s a bit of a cop-out, but I suggest that this issue resembles the debate over strong, manifest typing vs. dynamic typing. In theory, one is vastly preferable to the other. But in practice, large stable codebases are written with both kinds of languages, and programmers seem to adjust to overcome the failure modes of their tools unconsciously while harvesting the benefits that each language provides.


  1. Yes, “transpile” is a real word, or at least, a real piece of jargon. It’s a contraction of “transcompiler,” which is a compiler that translates one language to another language at a similar level of abstraction. There’s room for debate over what constitutes a “similar level of abstraction.” https://en.wikipedia.org/wiki/Source-to-source_compiler

  2. There are other possibilities: You could write a Tail-Call Optimized language that transpiles to JavaScript, however its changes wouldn’t always be local: Some function calls would be rewritten substantially to use trampolining. Or adding continuations to a language might cause everything to be rewritten in continuation-passing style.

  3. Scanning all of the code first is called “hoisting,” in part because some declarations nested in blocks are “hoisted” up to the level of the function, and all declarations are “hoisted” to the top of the function. This is a source of confusion for some programmers, but it isn’t germane to this essay.

  4. If you don’t want the file enclosed in an IIFE, you can compile your CoffeeScript with the--bare command-line switch.

Monitor Asus MX279H

Tempting appearance u6-436-AsusAsus MX279H is one variant of the monitor into the first ranks of Designo MX Series.Hal that steal the show are performances that are the focus of this series.

Rely on the screen with a thin bezel, this LCD monitor performed beautifully accented with metal bar which also serves as the setting panel on the bottom right side. Circular buffer is designed as though the actual form of metal plastic.

The buttons are there on the Asus MX279H, although there are physical, but it just needs to be touched. True, Asus chose to use the touch buttons on the LCD monitor with a diagonal screen size of 27 ˝ this. The arrangement itself is quite comprehensive, ranging from the standard setting brightness, contrast, until saturation. There is also the selection of presets like Scenery, Theater, Game, Night View, and in which each of these presets you can still set it again.

In terms of connectivity, this Asus monitor provides two HDMI ports, a single D-Sub 15pin port, and two audio ports (Headphone Out and Line In). Asus nullify the decision and choose the DVI connector HDMI connector types may recall this now more popular and is found in many devices. Interesting features contained in this MX279H Asus Asus SonicMaster is in charge of presenting the best sound for the class of integrated speakers on the monitor.

At PCplus testing for the audio quality, speaker Bang and Olufsen ICEpower sound produces above average speaker monitor in general. The audio system can not replace a desktop audio system, especially if you expect thumping bass. Power output or volume is enough to fill the room. So for everyday use such as watching streaming video or simply listen to soft music, the sound produced by Asus PCplus MX279H sufficient.

Asus uses AH-IPS panel type on MX279H to provide a good quality display. Panel is fairly dark frame design make it blend with the screen so that the state of death, this LCD monitor looks completely frameless. Facilitate the availability of several presets that you do not want to mess around with these settings and it. In general appearance was good, with the brightness and contrast level is fairly good. However, PCplus found that the saturation level of the monitor is a bit high, so as to obtain the best view, PCplus suggest to keep it set.

Seven signs of dysfunctional engineering teams

I’ve been listening to the audiobook of Heart of Darkness this week, read by Kenneth Branagh. It’s fantastic. It also reminds me of some jobs I’ve had in the past.

There’s a great passage in which Marlow requires rivets to repair a ship, but finds that none are available. This, in spite of the fact that the camp he left further upriver is drowning in them. That felt familiar. There’s also a famous passage involving a French warship that’s blindly firing its cannons into the jungles of Africa in hopes of hitting a native camp situated within. I’ve had that job as well. Hopefully I can help you avoid getting yourself into those situations.

There are several really good lists of common traits seen in well-functioning engineering organizations. Most recently, there’s Pamela Fox’s list of What to look for in a software engineering culture. More famous, but somewhat dated at this point, is Joel Spolsky’s Joel Test. I want to talk about signs of teams that you should avoid.

This list is partially inspired by Ralph Peters’ Spotting the Losers: Seven Signs of Non-Competitive States. Of course, such a list is useless if you can’t apply it at the crucial point, when you’re interviewing. I’ve tried to include questions to ask and clues to look for that reveal dysfunction that is deeply baked into an engineering culture.

Preference for process over tools. As engineering teams grow, there are many approaches to coordinating people’s work. Most of them are some combination of process and tools. Git is a tool that enables multiple people to work on the same code base efficiently (most of the time). A team may also design a process around Git — avoiding the use of remote branches, only pushing code that’s ready to deploy to the master branch, or requiring people to use local branches for all of their development. Healthy teams generally try to address their scaling problems with tools, not additional process. Processes are hard to turn into habits, hard to teach to new team members, and often evolve too slowly to keep pace with changing circumstances. Ask your interviewers what their release cycle is like. Ask them how many standing meetings they attend. Look at the company’s job listings, are they hiring a scrum master?

Excessive deference to the leader or worse, founder. Does the group rely on one person to make all of the decisions? Are people afraid to change code the founder wrote? Has the company seen a lot of turnover among the engineering leader’s direct reports? Ask your interviewers how often the company’s coding conventions change. Ask them how much code in the code base has never been rewritten. Ask them what the process is for proposing a change to the technology stack. I have a friend who worked at a growing company where nobody was allowed to introduce coding conventions or libraries that the founding VP of Engineering didn’t understand, even though he hardly wrote any code any more.

Unwillingness to confront technical debt. Do you want to walk into a situation where the team struggles to make progress because they’re coding around all of the hacks they haven’t had time to address? Worse, does the team see you as the person who’s going to clean up all of the messes they’ve been leaving behind? You need to find out whether the team cares about building a sustainable code base. Ask the team how they manage their backlog of bugs. Ask them to tell you about something they’d love to automate if they had time. Is it something that any sensible person would have automated years ago? That’s a bad sign.

Not invented this week syndrome. We talk a lot about “not invented here” syndrome and how it affects the competitiveness of companies. I also worry about companies that lurch from one new technology to the next. Teams should make deliberate decisions about their stack, with an eye on the long term. More importantly, any such decisions should be made in a collaborative fashion, with both developer productivity and operability in mind. Finding out about this is easy. Everybody loves to talk about the latest thing they’re working with.

Disinterest in sustaining a Just Culture. What’s Just Culture? This post by my colleague John Allspaw on blameless post mortems describes it pretty well. Maybe you want to work at a company where people get fired on the spot for screwing up, or yelled at when things go wrong, but I don’t. How do you find out whether a company is like that? Ask about recent outages and gauge whether the person you ask is willing to talk about them openly. Do the people you talk to seem ashamed of their mistakes?

Monoculture. Diversity counts. Gender diversity is really important, but it’s not the only kind of diversity that matters. There’s ethnic diversity, there’s age diversity, and there’s simply the matter of people acting differently, or dressing differently. How homogenous is the group you’ve met? Do they all remind you of you? That’s almost certainly a serious danger sign. You may think it sounds like fun to work with a group of people who you’d happily have as roommates, but monocultures do a great job of masking other types of dysfunction.

Lack of a service-oriented mindset. The biggest professional mistakes I ever made were the result of failing to see that my job was ultimately to serve other people. I was obsessed with building what I thought was great software, and failed to see that what I should have been doing was paying attention to what other people needed from me in order to succeed in their jobs. You can almost never fail when you look for opportunities to be of service and avail yourself of them. Be on the lookout for companies where people get ahead by looking out for themselves. Don’t take those jobs.

There are a lot of ways that a team’s culture can be screwed up, but those are my top seven.

SuVolta’s transistor technology speed-power benefits are validated in ARM processor

The ARM Cortex-M series processor was manufactured with SuVolta’s Deeply Depleted Channel (DDC) technology on a 65 nm bulk planar CMOS DDC process. With SuVolta’s transistor technology, designers are able to reduce power or improve performance, depending upon design requirements.

“ARM’s heritage is based on low power, so technologies that can further improve power consumption, such as DDC technology from SuVolta, will always be welcomed by ARM and our Partners,” said Noel Hurley, vice president, Strategy and Marketing, Processor Division, ARM. “SuVolta has shown that the DDC technology, when incorporated into an ARM processor, can provide additional power reductions or a significant performance boost. As the Internet of Things continues to expand, innovative ultra-low power technology for Sensors and other devices will be vital to ensure that ARM remains at the forefront of this opportunity.”

When compared to an identical ARM Cortex-M0 processor manufactured in the conventional 65 nm process, with a 1.2 V supply voltage, the DDC transistor-based ARM implementation operating at 0.9 V demonstrates a 50 percent lower total power consumption at matched 350 MHz operating speed. There is also a 35 percent increased operating speed (performance) at matched power. In addition there is a 55 percent increased operating speed when operated at matched supply voltage.

“We’ve now validated the benefits of the DDC technology in a complex SoC, by combining the ARM Cortex-M0 CPUs with SRAM instances and various analog components,” explained David Kidd, senior director, digital design at SuVolta. “The results speak for themselves – power-performance optimized CPU cores, with results that hold across process corners and temperature, plus, SRAMs with 150 mV lower minimum operating voltage, 50 percent less leakage power at matched SRAM read current, and more than 5x less leakage power in retention mode.”

“Reducing power consumption and enhancing performance are key to providing next-generation capabilities for a variety of advanced digital products,” said Bruce McWilliams, president and CEO at SuVolta. “By validating the speed-power advantages of the DDC technology in a SoC that includes ARM processors, we’ve reached another significant milestone in demonstrating the value of our technology in a system.”

Panasonic Lumix DMC-XS3, Latest Digital Camera with 14.1MP MOS sensor has a high sensitivity

Panasonic not only introduced the new Lumix cameras that rely on high zoom capability. The Japanese company also helped bring a compact camera Lumix DMC-XS3 that rely 14.1 MP MOS sensor with high sensitivity.

This digital camera is designed with a slim shape and body size of 14 millimeters. Although the size is quite small, this camera is claimed to deliver high quality images thanks to sensors that can reduce noise. In addition, this camera also features a 5x optical zoom and 10x zoom intelegent.

Panasonic Lumix DMC-XS3 also has the ability to record full HD video in MP4 format. In it there is also a feature called Intelligent Auto (iA) which enables features like Intelligent ISO Control, Intelligent Scene Selector, Face Detection and Intelligent Exposure is done automatically.

For shooting in low-light atmosphere, there is a Handheld Night Shot mode. This mode can produce high quality images with a single shot.

Leap Motion Controller, Great Hardware in Search of Great Software

By now, we all know what the future will be like; movies and TV shows have described it in detail. We know about the flying cars (thank you, “Blade Runner”), holograms (thank you, “Star Trek”) and robot butlers (thank you, “Jetsons”).

The Leap Motion Controller is a solution in search of a problem: its hardware is simple, but it needs a killer app.

So when will we really get those technologies? Probably on the 11th of “Don’t hold your breath.”

There is, however, one exception. As of this week, you can buy your own little piece of “Minority Report” and “Iron Man”: controlling your computer by making hand motions in the air.

The Internet has been buzzing about the much-delayed Leap Motion Controller ($80) since its first public demonstrations over a year ago. Imagine controlling on-screen objects just by reaching into empty space, just like Tom Cruise! Imagine gesture recognition just like Microsoft’s Kinect game controller, but on a much smaller, more precise scale! Imagine the future, plugged into a USB jack on the Mac or Windows PC you own today!

The Leap Motion sensor is beautiful, tiny and self-contained. If Wrigley’s ever comes out with a Juicy Fruit Designer Pack, it might look like this: a sleek, glass-and-aluminum slab (1.2 by 3 by 0.5 inches), with nonskid rubber on the bottom. A single USB cable (both a long one and a short one come in the box) stretches away to your computer; a light comes on when it’s working.

(Please note that Leap Motion has nothing to do with Leap Pad, the children’s toy. That gadget is educational in a completely different way.)

If you have a desktop computer, you put the sensor between your screen and keyboard. If it’s a laptop, you park it on the desk just in front of the keyboard. Soon, Leap says, you’ll be able to buy a PC from H.P. or Asus that has the sensor built right in.You download the Leap software, and presto: a somewhat buggy tutorial instructs you to insert your hands into the space — an invisible two-foot cube — that’s monitored by the Leap’s cameras and infrared sensors.

This device is like the Kinect in that it recognizes body parts in space. But not only is the Leap far smaller and less expensive, it’s also far more precise. According to the company, it can detect the precise positions of all 10 of your fingers simultaneously, with a spatial accuracy to a 100th of a millimeter — 200 times as accurate as the Kinect.

And remember, the Leap adds gesture recognition not to your TV, but to your computer. A machine that can run millions of different programs for all different purposes. Games, sure, but also office work. Creative work. Communication. Entertainment. Surely this little wonder is a very big deal.

Unfortunately, it’s not. The Leap’s hardware may be simple, attractive and coherent — but its software is scattershot, inconsistent and frustrating.

The first crushing disappointment is that no software recognizes your hand motions unless it’s been specially written, or adapted, for use by the Leap.

There are 75 such apps already on the Leap’s app store, Airspace; some are free, some cost a few dollars. Not all work on both Mac and Windows.

Most are games. In the best of them, you control the action in 3-D space, just as with the Kinect but without having to stand up. For example, Boom Ball ($5) is the classic Breakout game, where you try to knock out bricks by bouncing a ball against them — but your paddle is attached to your finger in vertical space.

In Disney’s clever Sugar Rush ($2), a spin off from the “Wreck-It Ralph” movie, you bake yourself a racing car shaped like a wedge of cake, and then steer it by holding both sides of an invisible steering wheel. When you play Dropchord ($3), you hold two index fingers out in space; you’re defining a line between them that you use to slice dots and avoid X’s. Cut the Rope is here, too (free).

There are some interesting music-making programs, which makes sense, since hand motions are generally associated with playing instruments. Air Harp ($1) is just what it sounds like. Chordion Conductor is a sweet-sounding arpeggiator (generates music from chords you select).

A few simple educational apps are available, like Molecules (rotate molecules on the screen; free), Cyber Science 3D (pull apart a skull; free) and Frog Dissection (you guessed it; $4).