You are currently browsing the Computer Technology category
Displaying 1 - 10 of 285 entries.

Monoprice 27″ IPS-G Pro LED Monitor WQHD 2560×1440

  • Posted on September 22, 2017 at 9:56 am

Monoprice is among the more interesting companies you probably haven’t heard of. Started out of an apartment around a decade ago, the company initially sold everything at a single price, hence the name. That business model may have worked when the product line was mostly cables and connectors, but the company now offers a diverse array that includes monitors (more in a moment), home theatre screens, graphics tablets, headphones, apocket-size pico projector, an action cam, even electric guitars – and, yes, cables, connectors and accessories as well. It’s a lineup with no seeming rhyme or reason, other than quality products at bargain prices.

And that actually is the rhyme and reason behind Monoprice products. According to CEO Ajay Kumar, the company looks for categories where vastly overpriced products predominate. That gives Monoprice room to create and sell products at dramatically lower price points, while still maintaining strong profit margins.
“We are in the right place at the right time with our business model,” says Kumar, who joined the company in July 2011. “We offer the same cable or accessory as national retail brands, but for much less cost. However, we are not cutting corners as we employ high-quality manufacturing partners who work with our specs. Our markup is much lower and we pass those savings to our customers. Monoprice brings them a value proposition they can’t find anywhere else.”
And that leads us to the Monoprice 27″ IPS-G Pro LED Monitor WQHD 2560×1440 Product ID 10489, which is what you came here for. I’ve been rocking this 16:9 (widescreen) monitor for over a month now and it’s stunning. Let’s take a look at the stats and find out why.
Start with the size, 27″. You don’t have to join Grindr to know that size matters. A larger screen means that you can work easily with more windows at once. It makes copying files and editing text and spreadsheets easier and obviously makes working with pictures and video more convenient, if that’s your thing. And if you’re a gamer, a large screen is essential. Ditto if you are, for instance, a daytrader or a designer.
Hand in glove with size is resolution. “WQHD” may sound like a Minneapolis TV station, but it means 2560 x 1440 pixels. Some 27″ screens max out at regular Full HD, which is 1920 x 1080. The higher resolution of the Monoprice unit means that more detail is visible, if your PC’s graphics card supports it. If not, you’ll be limited to 1920 x 1080 (or less, if your PC is really old). A large screen with high resolution allows you to display more information. It makes it easier to do more with your PC.
Since we’re talking graphics cards, another nice feature of the Monoprice 10489 is that it supports four different types of interface: HDMI 1.4, DVI, VGA and DisplayPort 1.2. That means that the monitor is bound to work with your existing graphics card. The package includes VGA and DVI-D cables, but these are standard length (around 6′). Because of the size of the monitor, it’s much easier to use longer cables – you can plug in the cable before maneuvering the monitor into place on your desk. Monoprice has you covered with available 15′ HDMI, DVI-D, VGA and DisplayPort 1.2 cables. Choose the one you need.
The monitor uses LEDs for the backlighting, rather than cold cathode fluorescent tubes. The benefit: more even illumination. And it uses In Plane Switching (IPS) display technology, which means you get a wide viewing angle with no color shift even when the screen is viewed at an extreme angle. Viewing angle is stated as 178 degree in both the horizontal and vertical planes.
Covering that screen is a glossy glass laminate with an antiglare coating. The antiglare coating is not a matte finish; the screen is glossy, but the antiglare coating reduces the intensity of any glare from reflected light. As with any monitor, you’ll want to position it so that ambient light is not reflected directly back at you. I’ve found the screen easy to use.
The monitor comes with a removable stand and has a 100×100 VESA mounting size for use with desk or wall mounts. The stand (which is completely removable) has rotate and tilt adjustments. It doesn’t have height adjustment, a feature found on a small number of other monitors.
The bezel is black plastic and is relatively thick. The OSD controls (brightness, etc.) are easy to reach. The connectors are in the usual awkward place for monitors, along the bottom bezel.
Several other stats are key. One is dead pixels. The monitor has over 10 million subpixels (2560 x 1440 pixels x 3 colors per pixel). If any one of those subpixels is stuck in the on or off position, you get a dead pixel – a spot that is always dark, or always white, red, reddish, green, greenish, etc. Unfortunately, dead pixels are a potential fact of life on all monitors – but Monoprice tells me they offer a zero dead pixel guarantee for a year. It’s an unusually strong guarantee, since other manufacturers often will only guarantee that the dead pixel count won’t exceed 5 or 10. The unit I received had no dead pixels.
Also important are brightness and contrast. Monoprice advertises a brightness rating of 440 cd/m², which it says is more than 15% brighter than most comparable displays, and a maximum dynamic contrast ratio of 80,000:1.
The display is indeed bright, but this is the one area where I noted a difficulty with this product – the screen is a bit too bright, even with the brightness adjustment turned down to the lowest setting. As a result, black areas on screen are rendered slightly grayish. For most people and most applications, this won’t be a problem – and it’s a phenomenon that’s scarcely unique to the Monoprice unit – but graphic designers will want to carefully compare this screen with others to see what meets their needs.
The panel features 109 pixels per inch, which translates to a 0.2331mm pixel size. The unit also includes builtin stereo speakers, which can be fed via a stereo audio cable, as well as audio from the HDMI connection. As with most builtin monitor speakers, the sound was tinny and unimpressive, so I don’t recommend using them. Buy a pair of standalone computer speakers instead.
Another stat is response time, which the company says is 6 milliseconds (gray-to-gray response time). That’s a measurement of how long it takes the monitor to change the image when the PC tells it to, and is an issue for almost no one except gamers.
Bottom line: if you’re looking for a high-quality 27″ WQHD IPS LED monitor at a great price, pick up the Monoprice 10489.

iOS Beta 7 Is Software The Most High adoption rate

  • Posted on September 15, 2017 at 10:46 pm

Onswipe, mobile publishing company presenting interesting data related to IOS 7. As news is that we have quoted from TechCrunch, it turns out, iOS 7 beta is a beta version of iOS is the most popular so far.

This was revealed after they find out that 0.46% explorers on their sites using the iOS beta 7. This figure is much higher than the figures obtained from the iOS 6 years ago which was only 0:25%.

The takeaways from Onswipe, According to CEO Jason Baptiste, are that developers are around twice as excited about iOS 7 as they were about iOS 6, and that they’re spending more time getting ready for the big changes coming in the new version of Apple’s mobile OS in order to have everything nice and tidy for the consumer launch this coming fall.
Also note also iPhone users surf in Onswipe with iOS 7 is as much as 0.77%, while iPad users 0:28%. When compared to when iOS 6 beta last year just as much as iPhone users 0:19%, with iPad users are at 0:38%.

Previously, Apple released iOS beta 7 for developers widely registered on June 10, the last. And the release of iOS 7 beta 2 yesterday, Apple finally include support for the iPad. iOS beta 7 3 rumored release date July 8, 2013.

Talk Nokia Lumia Excellence 1020

  • Posted on September 13, 2017 at 12:04 pm

HELSINKI – 41 megapixel camera is a major advantage presented by Lumia 1020. But Nokia claims that there are many other advantages to selling this smartphone.

Head of Marketing and Sales of Nokia in North America Matt Rothschild, said the camera is not the only advantage Lumia 1020. Hardware elements, including the AMOLED screen to accessories Camera Grip and shutter button, says Rothschild, a smartphone is another advantage.

“On the whole, this is what we refer to as the volume of product.’s (Lumia 1020) is very beautiful to grip, has a good balance, and well designed.’s What we call a consideration” Rothschild said, as quoted from Venture Beat, Monday (15/07/2013).

As for the camera, said Rothschild, Lumia 1020 has a very broad target audience, ranging from the professional to make photography only as a hobby.

“But the most important thing for us is that when we talk to customers, they tell us that they want to have a good picture. Everyone knows that smartphones now include photographic device that can be carried anywhere, so this is the core thing that all people are looking for,” he concluded.

Revealed, Microsoft SkyDrive Allow Skype and Tapped

  • Posted on September 13, 2017 at 10:31 am

A document reveals how Microsoft is working with U.S. intelligence agencies to read messages from users, including helping the U.S. National Security Agency (NSA) secret unlock code Microsoft, Australia Guardian reported on Friday (07/12/2013).

Confidential documents obtained by the Guardian of Edward Snowden, U.S. intelligence whistleblowers, said the level of cooperation between Silicon Valley and American intelligence agencies in the last three years.

The document, among others, suggests, Microsoft helped the NSA to read the conversation at the new portal Outlook.com by giving the company secret code. NSA has access to Outlook.com including Hotmail before the messages are written in the form of a code (encrypted).

Microsoft is working with the FBI this year that the NSA get easier access to the data warehouse via Prism SkyDrive which has 250 million users in the world.

Microsoft is also working with the FBI to the intelligence agencies “understand” the issues that potential Outlook.com that allows users to use the e-mail alias for them.

In July last year, nine months after Microsoft bought Skype, the NSA is proud to mention that the NSA has been able to increase the amount of video that they can access through Skype as much as three times through the Prism program. The materials obtained from Prism program routinely accessed by the FBI and CIA. One of the documents referred NSA has the name “team sport”.

Snowden documents also reveal the tension between Silicon Valley and the Obama administration. Leading technology companies lobbying the government to be allowed to express the depth of their cooperation with the NSA to address customer concerns in terms of privacy.

Corporate leaders are not trying to claim that they have collaborated and worked with intelligence agencies like NSA documents mentioned in the argument that the process is carried out according to the lawsuit.

In a statement, Microsoft said, “If we increase the capacity (upgrade)-prudok and updating our products, we are not exempt from having to comply with applicable laws, both now and into the future.”

Microsoft reiterated his argument that they provide the customer data “only in response to government requests, and we only serve the demand for specific address or identity”.

Last June, the Guardian reported that the NSA claims to have “direct access” program through the Prism system leading internet companies including Microsoft, Skype, Apple, Google, Facebook, and Yahoo.

Leap Motion Controller, Great Hardware in Search of Great Software

  • Posted on September 12, 2017 at 4:49 pm

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).

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

  • Posted on September 12, 2017 at 12:21 pm

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.

Adobe’s Kuler beta site resurrects photo-color picker

  • Posted on September 11, 2017 at 10:46 am

Adobe Systems has launched a beta version to try out changes to its color-picker Kuler service, including the restoration of an earlier feature to extract dominant colors from photos.

Kuler lets people assemble quintets of colors into a color scheme that’s saved into their own archive; people can browse others’ schemes as well. The colors can be imported into Adobe’s Illustrator software, too.

The photo tool is available by loading the new Kuler beta site. Adobe said Monday it’s seeking feedback on the changes, which it may or may not keep. Adobe also provided an option to use a less obtrusive color wheel and to shrink borders around colors so designers can better judge how they look together.

Kuler is useful, though hardly a heavyweight app like Photoshop or After Effects. But it’s interesting to watch since it’s got new-era online, collaborative, and social aspects that seem to be a priority for Adobe as it tries to convince skeptics that its $50-per-month Creative Cloud subscription is more than just a new way to pay for the old Creative Suitesoftware.

When Adobe cut over to its Creative Cloud subscription program, it introduced an iOS app that also can pick a color scheme from a photo.

Adobe once had a Kuler app for Android, but scrapped it and is channeling its resources toward the Kuler Web interface at present.

In response to a request for a Kuler Android app, an Adobe staff member had this to say:

While the iOS app and the discontinued Android app do have similar capabilities, they are actually quite a bit different. We have found that people use tablets and mobile phones very differently. So, we created the iPhone app with a different focus in mind — which translated to different features, UI, and interactions.

We have also found the tasks most people wanted to accomplish with Kuler, on a tablet device, are very similar to the tasks people undertake with the Kuler website. So, we’ve invested a lot of time and effort into updating the site to embrace the latest Web standards (also announced at MAX). And, it should work really well on Android and iOS tablets. We look forward to getting these updates in the hands of users to hear what they think.

We understand there are many Android phone users who may find an app like the Kuler iPhone app useful, and we’ll monitor demand for that over time.

In my tests on a Nexus 7 tablet, I was able to use the normal Kuler site, but the photo upload and color-wheel shrinking features had some problems. I could use photos I took on the spot and from the photo gallery, but imports from Google+ galleries, Dropbox, and Google Drive failed. Worse, the color wheel for picking colors by hand didn’t work with my touch screen.

Folder Access Windows 8 on Linux

  • Posted on September 9, 2017 at 2:04 pm

Two editions ago we have discussed how to access Ubuntu from Windows 8. The technique does not necessarily mean that you can access the folder dibagipakaikan Windows 8 on Linux. Well, that ye may be able to access the folders of Windows 8, you should try this tutorial.

Step 1:
Configuration Workgroup Computers in the same

How:

T04-435-Windows8-gb11

 

1. Make the same Workgroup. Go to the Start screen, type “System”, click Settings, and then click the System icon on the left side. Click the “Change Settings” on computers using the Windows 8 operating system.

 

T04-435-Windows8-gb12

 

 

2. In the System Properties window go to the Computer Name tab and see the workgroup name there. Comparing with the existing workgroup name information in Linux. If the same, you can jump straight to step 4. If different, follow the first 3 steps.

 

 

T04-435-Windows8-gb12

 

3. Click the “Change” is in the Computer Name tab. After that, in the Computer Name Changes window, click the Workgroup menu in the box if the Member in the column below, the contents of the same name with a Linux workgroup. Press “OK” to save changes. When prompted, restart the PC in order to connect with the new workgroup.

 

 

Step 2:
Configuring Windows PC to be shared
T04-435-Windows8-gb20Bagipakaikan files as usual. Start Windows Explorer, and browse the folder name you want dibagipakaikan. Right-click the folder, select “Share with> Homegroup (view)” to provide read-only access or “Share with> Homegroup (view and edit)” to provide read and write access.

 

Step 3:

Access Folders from Linux
In this example we will use Ubuntu as an example. To access the folder via the Ubuntu dibagipakaikan, there are two ways that can be used. You can access the network via a network connection directly to the browser or Windows PC. This she steps details.

Option A: Access via the Network Browser

T04-435-Windows8-gb31

 

 

1. Click the Places menu> Network on your desktop.

 

 

 

T04-435-Windows8-gb32

 

 

2. When Network File Browser window appears, double-click the Windows Network icon on the list.

 

 

 

T04-435-Windows8-gb33

 

3. List of networks will appear next computer operating system Windows detected by Linux. Double-click the line with the name of the workgroup that you created in step 1.

 

4. Finally, double-click the name of your computer operating system Windows 8. Earlier dibagipakaikan folder will appear and can be accessed as usual.

 

Option B: Direct Connection to Windows

T04-435-Windows8-gb41

 

 

1. From the desktop, click the “Places> Connect to Server”.

 

 

 

T04-435-Windows8-gb42

 

 

2. Will munncul Connect to server window on the screen. You are asked to fill in a few questions about the membagipakaikan file server.

 

 

T04-435-Windows8-gb43

 

 

3. To get the right information, turn to your Windows PC. After that, right-click the folder that dibagipakaikan, click “Properties” and click the “Sharing” tab. Record the name of the folder sharing and its Network Path.

 

 

T04-435-Windows8-gb44

 

4. Now, turning back to Linux. Enter the following information in the Connect to Server window:
• Service type: Windows share;
• Server: WINDOWS-PC (filled with computer name);
• Share: / Users / name / Desktop (the path of the folder in bagipakaikan. Signs backslash (\) is replaced with a slash (/));
• Folder: shared (folder name dibagipakaikan).

 

5. Give a check mark in front of the option “Add Bookmark” and give the Bookmark name to any name that allows you to remember the name of the folder and file locations dibagipakaikan.

T04-435-Windows8-gb45

 

6. Click “Connect”. Window that contains folders dibagipakaikan in Windows 8 will appear automatically. At other times, you’ll be able to access the same folder quickly by simply clicking on the Places menu bookmarking it.

Notebook Lenovo ThinkPad T430u

  • Posted on September 6, 2017 at 8:46 am

Like the models in the fashion world, most outstanding ultrabook now prioritizes slimness of the body and a pretty view. However, these physical characteristics will result in a collision or vulnerable laptop face hostile weather conditions. That try to overcome this shortcoming by presenting a Lenovo T430 repeated his version into the ThinkPad series T430u.

Well, now ultrabook models (ThinkPad T430u) comes with the typical specifications of mobile devices are lightweight and power-saving. Examine the “u” as a marker ultrabook segment here. Series that we try (type 3351-7DA) contains an Intel Core i5-3317U 1.7 GHz, 4GB of main memory, and a 500GB hard disk. Also added a 4GB SSD for ultrabook-style get fast booting.

As general character ultrabook, the Lenovo ThinkPad T430u only include a little plug. This device only provides two USB 3.0 ports, LAN, HDMI, and DisplayPort. This device also has a wireless card slot that can be used to access the internet via a 3G connection. The slot itself is at the back of the laptop is sailing 14 ˝. The bottom of the laptop is also surprisingly easy to open with a special slot (no screwdriver) making it easier for you to upgrade components.

T430u also comes standard Thinkpad features such as finger print reader and an Anti-Theft technology from Intel. However, the laptop weighs 1.9 kg making it a lure is physical endurance-tested to military standards. This test requires the Lenovo ThinkPad T430u resistant to shock, dust, extreme temperatures, up to a humid environment. This is why this Ultrabook casing made slightly thicker (2.2 cm) with glass fiber plastic material to reinforce the cover.

To beautify the inside, Lenovo makes keyboad in design they call the Island-style that stood out. To give the impression of a minimalist, physical buttons for volume settings, wireless, and such removed. Instead, the available combination on the keyboard. Continue to be included on this keyboard also typical ThinkPad trackpoint. With lithiumpolymer 4220mAh battery, the laptop can be used for seven hours continuously.

Given its performance, the Lenovo ThinkPad T430u ultrabook par with most other equivalent. However, it seems to make a strong design-based Windows 8 Pro laptop is becoming prominent. This product is perfect for fans looking for a ThinkPad ultrabook or resilient.

Google Maps for iPad Launched

  • Posted on September 5, 2017 at 10:12 am

Jakarta – After a week after Google Maps launched for Android users, the information technology company is now re-presenting feature map for iPad users. Google Maps 2.0 can be enjoyed globally since Tuesday, July 16, 2013.
Features that are designed for use with the device’s larger screen choose the look with clearer images and soft colors.
Just like the Android version, iOS-based applications include traffic information in real time. Google Maps 2.0 comes with Foursquare and navigation that includes information about a variety of places, including restaurants and shopping centers.
This application actually has not been downloaded from the App Store could in their home country, the United States. Yet it can be downloaded for users in Asia.
Google Maps before, they can be enjoyed by users of smart phones iPhone. Launch the application updates to follow up on complaints that come from iPhone users, especially iPhone 5 to Apple Maps. Users complained about the lack of accuracy especially on Apple Maps. Apple Management then apologized in writing to the users of the iPhone and iPad.
Service on the map offers features traffic information, navigation, transit directions, satellite, road, indoor photos, restaurant reviews, and the integration of the Google profile. Unlike other Google apps made​​, this map is a special feature produced for the default operating system iOS. The application advantages are speed and small file size so it does not take much memory.