StackOverflow updated the users profile pages, which now look awesome:

It’s way cleaner now. All in all, thumbs up from me, and as it seem, most of the community. You can read more about it on their blog.

I’m a big fan of Stack Overflow and I tend to contribute regularly (am currently in the top 0.X%). In this category (stackoverflow) of posts I will will be posting my top rated questions and answers. This, btw, is allowed as explained in the meta thread here.

My question was:

I am wondering if there is a way to write the SQL so that it would return me a result as usual but now, on the first row that would return also the attribute names.

To explain what I mean:

say you have a table “test” which has 2 attributes “id” and “name”:

id name
1  nik
2  tst

query:

SELECT*FROM test;

produces:

1 nik
2 tst

but what I want it to return is this:

id name
1 nik
2 tst

Is this possible?

edit: I am using PostreSQL

 The answer, by a_horse_with_no_name, was:

You cannot return the names and the actual column values in a single result unless you give up on the real datatypes (which is probably not what you want).

Your example mixes character data and numeric data in the id column and Postgres will (rightfully) refuse to return such a result set.

Edit:
I tested the “union” solution given e.g. by JNK and it fails (as expected) on Postgres, Oracle and SQL Server precisely because of the non-matching datatypes. MySQL follows it’s usual habits of not throwing errors and simply converts everything to characters.

While editing your post in WordPress in the Publish area on the right, next to Visibility click on edit and then check the “Stick this post to the front page” option.

That moment when you realize someone on your team surely logged all of the errors, and still something wasn’t right, and then you find out how exactly this logging works…

I’m a big fan of Stack Overflow and I tend to contribute regularly (am currently in the top 0.X%). In this category (stackoverflow) of posts I will will be posting my top rated questions and answers. This, btw, is allowed as explained in the meta thread here.

My question was:

I was wondering how can I match two digits but which are not the same. So, it would be fine to match 12, but not 11.

What I have till now is: I have to match strings like “P12”, and I’ve done it with this regex:

^P([1-6]{1})([1-6]{1})$

But now my problem is how to match only strings like P12 or P32 where the numbers do not repeat.

Any help or guidance to reading materials will be grateful.

edit:  this is what worked:

^P([1-6]{1})(?!\1)([1-6]{1})$

 The answer, by Ignacio Vazquez-Abrams, was:

Use this:

^P((1[2-6])|(2[13-6])|(3[124-6])|(4[1-356])|(5[1-46])|(6[1-5]))$

I finished the course at CodeSchool, and below are my notes from it.

Level 1

Ternary howto with SIAF

var allPacked = true;
var readyToGo = true;
var adventureTime;

adventureTime = allPacked && readyToGo ?

  function( ){
    return "Adventure time is now!" ;
  }()
  :
  function( ){
    return "Adventuring has been postponed!" ;
  }() ;

console.log(adventureTime);

Short-circuting, if the this.swords is not empty it takes it immediately, without looking at the thing after the ||

this.swords = this.swords || [];

Same goes for &&, as soon as it finds a first falsy value – it returns that. If all falsy, it returns the last one.

Level 2

If you need lengthy, repetitive access to a value nested deep within a JS Object, then cache the necessary value in a local variable.

var numCritters = location.critters.length;
for(var i = 0; i < numCritters; i++){
      list += location.critters[i];
}

//instead of
for(var i = 0; i < location.critters.length; i++){
      list += location.critters[i];
}

//and even better
for(var i = 0, numCritters = location.critters.length; i < numCritters; i++){
    list += location.critters[i];
}

Put script tag just before the ending body tag, or you can also leave them in the head section, but add async keyword. Use a list of variables after the keyword var all at once! Use function join() on the array instead of concatenation. with +=. console.time(“string”) is the opening statement to a timer method that will help us measure how long our code is taking to perform. console.timeEnd(“string”) ends it and prints how long it took. “string” has to be the same in both cases.

var now = new Date();

console.log(+now) == console.log(new Number(now));

 Level 3

 === compares type and content. instanceof – userful to determine, well, the instance of some object 🙂

function Bird(){}
function DatatypeBird(){}
function SyntaxBird(){}
DatatypeBird.prototype = Object.create(Bird.prototype);
SyntaxBird.prototype   = Object.create(Bird.prototype);

Runtime error catching:

try{
   if(someVar === undefined)
        throw new ReferenceError();
}
catch(err){
    if(err instanceof ReferenceError)
        console.log("Ref err:" + err);

    //TypeError
}
finally{
    //this will execute no matter what
}

Avoid eval, with.

Use num.toFixed(2), parseFloat(), parseInt(num, radix). Radix can be from 2 – 36. typeof along with isNan to determine if the number is trully a number.

Level 4

Namespace is an object that groups and protects related data and methods in JavaScript files.

Say you have a code like this:

var treasureChests = 3;
var openChest = function(){
    treasureChests--;
    alert("DA DADADA DAAAAAAA!");
};

you can use namespacing like this:

var DATA = {
	treasureChests : 3,
	openChest : function(){
	    this.treasureChests--;
	    alert("DA DADADA DAAAAAAA!");
	}
};

You then call the function like this: DATA.openChests().

Closures are a feature of JavaScript, used to cause some properties to be private, bound only to a surrounding function’s local scope, and some properties to be public, accessible by all holders of the namespace.

Private properties are created in the local scope of the function expression. Public properties are built within the object which is then returned to become the namespace. Access to private data is thus possible only because of closure within the larger module.

Say you have a code like this:

var CAVESOFCLARITY = {
  stalactites: 4235,
  stalagmites: 3924,
  bats: 345,
  SECRET: {
    treasureChests: 3,
    openChest: function(){
      this.treasureChests--;
      alert("DA DADADA DAAAAAAA!");
    }
  }
};

You would make it into a closure like this:

var CAVESOFCLARITY = function () {

  var treasureChests = 3;

  return {
    stalactites: 4235,
    stalagmites: 3924,
    bats: 345,
    openChest: function () {
        treasureChests--;
        alert("DA DADADA DAAAAAAA!");
    }
  };
}();

If a module references globally-scoped variables, it’s a best practice to bring them into the scope of anonymous closure through the use of a specific technique called global imports.

Say the code is like this and uses a global variable named globalAnswer:

var MySomething = function () {
  var a = 3;

  return {
    getA: function() {return a; },
    summon: function(){
      if(globalAnswer === "42"){
        alert("YEP!");
      }
      else{
          alert("NOPE");
      }
    }
  };
}();

You would rewrite this using global imports like this:

var MySomething = function (answer) {
  var a = 3;

  return {
    getA: function() {return a; },
    summon: function(){
      if(answer === "42"){
        alert("YEP!");
      }
      else{
          alert("NOPE");
      }
    }
  };
}(globalAnswer);

Your import ensures clarity of scope within a module. By using a parameter, you protect the global data that might have been overwritten. All imported data becomes locally scoped to the anonymous function, to be used in closure. Thus, when compared with searching the entire scope, import are both clearer and faster.

Augmentation is the term for adding or changing properties in a module after the module has already been built.

In simple augmentation, the module file and the augmentation file do not share their private state. Augmented module properties may only access the private data from their file’s closure. Private data from the original closure will not be lost, and will be accessible to all original properties that referenced it.

I’m a big fan of Stack Overflow and I tend to contribute regularly (am currently in the top 0.X%). In this category (stackoverflow) of posts I will will be posting my top rated questions and answers. This, btw, is allowed as explained in the meta thread here.

My question was:

I got a request from my client that they want to add stars (★) to their email subject (They send these mails through the application we made as a part of bigger CRM for them).

I tried to send a test mail, and the email title is displayed nicely in my Gmail account, and I must agree with my client that it is eye catching, but what came to my mind is that this may be a spam magnet, so I googled about it but I can’t find the actual “don’t do this”.

Generaly, my oppinion would be not to use it, but now I have to explain to the client why. My best explanation whould be there is a probability your emails will be treated as spam but I don’t have the background for this statement.

Do you have any suggestions about what should I do?

 The rather extensive answer, by Kibbee, was:

The only information I could find is on the SpamAssassin page of how to avoid false positives. The only relevant part I found was this part.

Do not use “cute” spellings, Don’t S.P.A.C.E out your words, don’t put str@nge |etters 0r characters into your emails.

SpamAssassin is a very widely used spam filtering tool. However, simply breaking one of the rules (strange characters) alone wouldn’t get an email marked as spam. But combined with some other problems could lead to your email being considered spam. That being said, if your email is a completely legitimate business email, it’s likely that few other rules are triggered, and using the special characters wouldn’t create a huge problem. That being said, you should probably try out a couple test emails on SpamAssassin and a couple other spam filtering tools in order to come to a better conclusion on the emails you plan to send out.

Additionally, there was also a good answer from Nathan White:

Simply explain to your client as you have explained to SO: you stated that the star made it eye catching: this doesn’t directly mean that it will be treated as spam, but you could explain how that concept COULD be considered spam.

If the star is part of their branding, however, this could be quite a nice way in which your client expresses themselves.

Spam emails are becoming more and more like what one would consider ‘normal’, so I think they have trial it internally, test the concept.

Talk it over with your client – there is going to be no basis in hard fact with things like this, purely social perception.

And also by lukeA:

More and more retailers are using unicode symbols in their subject lines since a few months. Of course it’s in order to gain more attention in cluttered inboxes. Until now, there has been absolutely no evidence that such symbols increase the likelihood of failing spam filter tests. However, keep in mind that rare symbols might not render (correctly) across all mail user agents. Especially keep an eye on Android and Blackberry smartphones, but also on Outlook. In addition, due to a Hotmail bug symbols will render much bigger in subect lines and in the email body within the web front end. In fact, they are beeing replaced by images. All in all, the star shouldn’t make any problems. At least, if it’s encoded correctly in the subject line. So, go for it.

Smarterer released its API for free. Even if you’re not into programming, you can still make use of this and give your site visitors a quick skill test (in just 10 questions and 120 seconds), by using their Smarterer Widget Builder.

Simply, search for a test and optionally name it:

and embed it to your widget area (wp terminology) on your site/blog:

Here are few examples you can try:

Recently I wanted to find out how to update field only if the updated value would be new (as in – different from the current one).

After a bit of googling I managed to find the solution which I’m now presenting here for anyone that may need a solution for such an use case:

UPDATE table SET db_field=(CASE db_field WHEN NULL THEN 'new_value' ELSE db_field END);

Here are my notes from a free CodeSchool tutorial sponsored by Google:

Things I wish I were told about Angular.js.

Binding

<!DOCTYPE html>
<html>
	<head>
		<title>AngularJS Tutorials</title>
	</head>
	<body>
		<div ng-app="">
			<input type="text" ng-model="data.message">
			<h1>{{data.message}}</h1>
		</div>
		<script type="text/javascript" src="angular.js"></script>
	</body>
</html>

Controllers

<html>
	<body>
		<div ng-app="">
			<div ng-controller="FirstCtrl">
				<h1>{{data.message + " world"}}</h1>
				<div class="{{data.message}}">
					Msg...
				</div>
			</div>
		</div>
		<script type="text/javascript" src="angular.js"></script>
		<script type="text/javascript" src="main.js"></script>
	</body>
</html>
//main.js
function FirstCtrl($scope){
$scope.data = {message: "Hello"};
}

Dot

https://www.youtube.com/watch?v=DTx23w4z6Kc

The initial setup:

<div ng-app="">
  <input type="text" ng-model="data.message">
  <h1>{{ data.message }}</h1>

  <div ng-controller="FirstCtrl">
    <input type="text" ng-model="data.message">
    <h1>{{ data.message }}</h1>
  </div>

  <div ng-controller="SecondCtrl">
    <input type="text" ng-model="data.message">
    <h1>{{ data.message }}</h1>
  </div>
</div>

function FirstCtrl($scope) {

}

function SecondCtrl($scope) {

}

In this setup, all three instances of data.message are bound to each other through the first data.message, which is in the scope of the entire application.

If we were to replace the instances of data.message with just message,

<div ng-app="">
  <input type="text" ng-model="message">
  <h1>{{ message }}</h1>

  <div ng-controller="FirstCtrl">
    <input type="text" ng-model="message">
    <h1>{{ message }}</h1>
  </div>

  <div ng-controller="SecondCtrl">
    <input type="text" ng-model="message">
    <h1>{{ message }}</h1>
  </div>
</div>

It breaks the scope inheritance that was binding all the data.message instances. Now, each new ng-model of message is creating a new instance of message, and so each model will be an unbound instance. So, important to note here is the data.message which will be available to all of the controllers!

Sharing data between controllers

https://www.youtube.com/watch?v=HXpHV5gWgyk

The initial setup:

<div ng-app="">
  <input type="text" ng-model="data.message">
  <h1>{{ data.message }}</h1>

  <div ng-controller="FirstCtrl">
    <input type="text" ng-model="data.message">
    <h1>{{ data.message }}</h1>
  </div>

  <div ng-controller="SecondCtrl">
    <input type="text" ng-model="data.message">
    <h1>{{ data.message }}</h1>
  </div>
</div>

function FirstCtrl($scope) {

}

function SecondCtrl($scope) {

}

With this setup, data.message is defined outside of either controller, scoped to the entire ng-app. The bindings within each of the controller divs both point to that ‘parent’ model. Because of this, all 3 instances of the data.message input are bound to each other because of the first instance, which is globally scoped in the application.

If one were to remove the first model that does not reside in a controller, there is no parent model for either controller to bind to, so each instance of data.message will be scoped within its respective controller. Thus, neither data.message will be bound to the other.

We’d like to share the data model between the two controllers without creating a parent scope. This requires a service within a formally defined Angular application.

<div ng-app="myApp">

  <div ng-controller="FirstCtrl">

var myApp = angular.module('myApp', []);

myApp.factory('Data', function () {
  return { message: "I'm data from a service" };
});

function FirstCtrl($scope) {

This Data service can be injected into each of the controllers as a parameter. By doing this, we are now attaching the data.model to an app service, which repairs the binding between the two controller models.

Stackoverflow thread on this.

<!DOCTYPE html>
<html>
<head>
	<title></title>
</head>
<body ng-app="myApp">
	<div ng-controller="FirstCtrl">
		<input type="text" ng-model="data.message">
		<h1>{{ data.message }}</h1>
	</div>

	<div ng-controller="SecondCtrl">
		<input type="text" ng-model="data.message">
		<h1>{{ data.message }}</h1>
	</div>
	
	<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
	<script type="text/javascript" charset="utf-8">
		angular.module('myApp', [])

		.factory('Data', function () {
		  return { message: "I'm data from a service" };
		})

		.controller('FirstCtrl', function ($scope, Data){
			$scope.data = Data;
		})

		.controller('SecondCtrl', function ($scope, Data){
			$scope.data = Data;
		});
	</script>
</body>
</html>

Method on a scope

function SecondCtrl($scope, Data) {
  $scope.data = Data;

  $scope.reversedMessage = function() {
    return $scope.data.message.split("").reverse().join("");
  };
}

Bootstraping https://docs.angularjs.org/guide/bootstrap

Changing the data in the service and then showing it again, the ultimate example which eluded me for some time (Plunkr):

<!DOCTYPE html>
<html>
<head>
	<title></title>
</head>
<body ng-app="myApp">
	<div ng-controller="FirstCtrl">
		<input type="text" ng-model="data.msg">
		<h1>{{ data.msg }}</h1>

		<button type="" ng-click="sayItBack()"></button>
	</div>

	<div ng-controller="SecondCtrl">
		<input type="text" ng-model="data.msg">
		<h1>{{ data.msg }}</h1>
	</div>
	
	<script src="https://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
	<script type="text/javascript" charset="utf-8">
		angular.module('myApp', [])

		.service('Data', function () {
			this.data = {};
			this.data.msg = "Howdy!";

			this.getMsg = function() {
			    return this.data;
			};

			this.setMsg = function(city){
				this.data.msg = city;
			};
		})

		.controller('FirstCtrl', function ($scope, Data){
			$scope.data = Data.getMsg();

			$scope.sayItBack = function(){
				Data.setMsg("Hello to you too!");
			}			
		})

		.controller('SecondCtrl', function ($scope, Data){
			$scope.data = Data.getMsg();
		});
	</script>
</body>
</html>