function lerp(start, end, t) {
  return (1 - t) * start + t * end;
}

Many demo can be created from this, but for now here's a example how to transition between 2 colors in Canvas.

See it on CodePen

Full demo code:

const canvas = document.getElementById('canvas');
const context = canvas.getContext('2d');

function lerp(start, end, t) {
  return (1 - t) * start + t * end;
}

function lerpColor(from, to, t)
{
    var color = {r:0, g: 0, b: 0};

    color.r = lerp(from.r, to.r, t);
    color.g = lerp(from.g, to.g, t);
    color.b = lerp(from.b, to.b, t);

    return color;
}

var now, last, t;
var duration = 2000;
var current = 0;
var colorA = {
  r: 0,
  g: 250,
  b: 250
};
var colorB = {
  r: 255,
  g: 0,
  b: 255,
};

function draw() {
  context.clearRect(0, 0, canvas.width, canvas.height);
  
  now = performance.now();
  var dt = now - last;

  current += dt;
  last = now;
  t = current/duration;
  
  if (current>duration) {
    t = 0;
    current = 0;
    var c = colorA;
    colorA = colorB;
    colorB = c;
  }
  
  var CC = lerpColor(colorA, colorB, current/duration);

  context.fillStyle = `rgba(${CC.r}, ${CC.g}, ${CC.b}, 1.0)`;
  context.fillRect(0, 0, canvas.width, canvas.height);
  
  context.restore();
  
  window.requestAnimationFrame(draw);
}

// start
last = performance.now();
window.requestAnimationFrame(draw);

• By using PHP_VALUE on .htaccess or <VirtualHost> directive on Apache
• By using fastcgi_param PHP_VALUE on NGINX
• By code during execution, as example, using ini_set

To get the configuration value defined in php.ini, there's another built-in function called get_cfg_var, that actually do this. This function will ignore any values set by a webserver or during runtime and return the value set on the configuration file.

This function will not return configuration information set when the PHP was compiled, or read from an Apache configuration file. PHP get_cfg_var Manual

It can be possible that PHP is not loading values from the configuration file (php.ini), well in that case no value will be returned from get_cfg_var.

To check whether the system is using a configuration file, try retrieving the value of the cfg_file_path configuration setting. If this is available, a configuration file is being used. PHP get_cfg_var Manual

One thing to keep in mind is that defining a configuration option using php -d, even when php didn't load the values from php.ini this value will be available through get_cfg_var.

function get_config($key)
{
    if (get_cfg_var('cfg_file_path')) {
        return get_cfg_var($key);
    }

    return ini_get($key);
}

In the example above the function's goal is to return the value from php.ini, otherwise is going to fallback to retrieve the value present during runtime by using ini_get.

To create a checksum of a file we need to read its whole content and hash it. Reading the whole content of a big file could result in an undesired error due to not enough memory, because the content loaded into memory.

To overcome this we can use Hash.update method from the crypto module. It allows us to incrementally hash a string by appending new data, which makes it the perfect option to hash big files with low memory consumption.

We can read the file by chunk and incrementally update the hash by adding chunk to the hash object.

Below there's a snippet on how to generate a md5 checksum using Hash.update.

const crypto = require('crypto');
const fs = require('fs');

function getChecksum(path) {
  return new Promise(function (resolve, reject) {
    // crypto.createHash('sha1');
    // crypto.createHash('sha256');
    const hash = crypto.createHash('md5');
    const input = fs.createReadStream(path);

    input.on('error', reject);

    input.on('data', function (chunk) {
      hash.update(chunk);
    });

    input.on('close', function () {
      resolve(hash.digest('hex'));
    });
  });
}

// Usage
// node ./file.js path/to/file
getChecksum(process.argv[2])
  .then(console.log)
  .catch(console.error);

The algorithm is dependent on the available algorithms supported by the version of OpenSSL on the platform.

Example of some algorithms you can use are: md5, sha1, sha256, and sha512.

References

• crypto.createHash(algorithm[, options])
• fs.createReadStream

echo "name" | ./hello.js

The example above should output "Hello " + any output of the first script.

const stdin = process.stdin;
let data = '';

stdin.setEncoding('utf8');

stdin.on('data', function (chunk) {
  data += chunk;
});

stdin.on('end', function () {
  console.log("Hello " + data);
});

stdin.on('error', console.error);

Using the input stream (stdin), we read the input data that was sent by the first script.

This can be rewrite to use promises, so it looks like this:

getInput().then(sayHello).catch(console.error);

Complete example below:

function sayHello(name) {
  console.log("Hello " + name);
}

function getInput() {
  return new Promise(function (resolve, reject) {
    const stdin = process.stdin;
    let data = '';

    stdin.setEncoding('utf8');
    stdin.on('data', function (chunk) {
      data += chunk;
    });

    stdin.on('end', function () {
      resolve(data);
    });

    stdin.on('error', reject);
  });
}

getInput().then(sayHello).catch(console.error);

We are going to create the query below using Zend DB.

SELECT `id`, `name`, `language`, `country`
FROM `customers`
WHERE `country` = 'jp'
    AND (`language` = 'en' OR `language` = 'ja')

use Zend\Db\Sql\Sql;
use Zend\Db\Sql\Where;

$sql = new Sql($adapter);
$select = $sql->select();
$select->columns([
  'id',
  'name',
  'language',
  'country'
]);
$select->from('customers');

$where = new Where();
$where->equalTo('country', 'jp');

// Open nesting
$whereNest = $where->nest();
$whereNest->equalTo('language', 'en');
$whereNest->or;
$whereNest->equalTo('language', 'ja');

// Close nesting
$whereNest->unnest();
$select->where($where);

$statement = $sql->prepareStatementForSqlObject($select);
$results = $statement->execute();

There's a problem with this character when you use it with DateTime::createFromFormat – it fails.

// Returns false
$datetime = DateTime::createFromFormat('c', '2019-02-06T23:19:33-01:00');

The character can be used with date function, and it works.

$date = date('c');

It also works when it's used with DateTime() class.

$datetime = (new \DateTime())->format('c');

I couldn't find the reason behind this, but I found a workaround. From the datetime string we can use the date and time character formats, what's missing it's what format character to use for the timezone offset.

Why I am trying to do here? I want to confirm the input datetime is of an c format.

After looking at the date function format list, there's a format character to determine the offset time.

P Difference to Greenwich time (GMT) with colon between hours and minutes (added in PHP 5.1.3) Example: +02:00

Instead of using c, we are going to use the following format: Y-m-d\TH:i:sP.

$datetime = DateTime::createFromFormat('Y-m-d\TH:i:sP', '2019-02-06T23:19:33-01:00');

We can avoid the .babelrc file by adding these configuration to the webpack.config.js file.

.babelrc file:

{
  "presets": [
    "@babel/preset-env"
  ],
  "plugins": [
    ["@babel/plugin-transform-react-jsx", {
      "pragma": "h"
    }],
  ]
}

Below there's the new webpack.config.js file.

module.exports = {
  entry: './app.js',
  output: {
    path: __dirname,
    filename: 'bundle.js'
  },
  module: {
    rules: [
      {
        test: /\.js$/,
-       loader: 'babel-loader',
+       use: {
+         loader: 'babel-loader',
+         options: {
+           presets: [
+             '@babel/preset-env'
+           ],
+           plugins: [
+             ['@babel/plugin-transform-react-jsx', {
+               'pragma': 'h'
+             }],
+           ]
+         }
        }
      }
    ]
  }
}

Now we can delete .babelrc, and everything should work the same.

Webpack allow us to convert the preact package into a preact module. While in the other hand babel-loader is a webpack loader that allow us to convert ES6 code into ES5.

Following the previous example, I am going to use the same HTML file, but removing the Preact script tag, so it looks like the code below:

<!doctype html>
<html>
  <head>
    <title>Hello Preact</title>
  </head>
  <body>
    <div id="root"></div>
    <script src="bundle.js"></script>
  </body>
</html>

Now I'm replacing the following line from app.js to use import.

From:

const { h, render, Component } = window.preact;

To:

import { h, render, Component } from 'preact';

Webpack & Babel Loader

I need to install webpack, webpack-cli, and babel-loader using npm.

npm install --save-dev babel-loader webpack webpack-cli

I am going to install webpack-cli to execute webpack from the command line.

Webpack Configuration

I need to create a new file for the webpack configuration named webpack.config.js. This file will tells webpack what's the input and output file, and to use the babel-loader to convert the ES6 features.

In the previous example this was done using the babel command, now webpack will take care of all this.

module.exports = {
    entry: './app.js',
    output: {
        path: __dirname,
        filename: 'bundle.js'
    },
    module: {
        rules: [
            {
              test: /\.js$/,
                loader: 'babel-loader'
            }
        ]
    }
}

Webpack is ready to be used to convert app.js into bundle.js, allowing us to use import as well.

Build Script

We are now replacing the build script from package.json to use webpack instead of babel.

From:

"scripts": {
  "build": "babel app.js -o bundle.js",
  "test": "echo \"Error: no test specified\" && exit 1"
},

To:

"scripts": {
  "build": "webpack",
  "test": "echo \"Error: no test specified\" && exit 1"
},

Run the build command, and access index.html to see the result.

$ npm run build

See final code here: WellingGuzman/hello-preact.

Preact describes itself as an React lightweight alternative with the same API.

Fast 3kB alternative to React with the same modern API.

I have sit it down – well, lay down – to try create a "hello world" using Preact, with the minimal tooling possible to understand how this all modern front-end development framework works. As most tutotials, and guides I have found they all assumed you are familiar with all these tools, I didn't find much straight up guide for curious newbies that want to know how this all glue together.

At this point of time, your browser probably cannot understand JSX or some of the new ES6/2015 features, there's where Babel comes into action.

Setup Project

First thing first, let's create a new directoty and create a package.json file.

$ mkdir hello-preact
$ cd hello-preact
$ npm init -y

After executing npm init -y, a file called package.json should have been created.

Add HTML Page

<!doctype html>
<html>
  <head>
    <title>Hello Preact</title>
  </head>
  <body>
    <div id="root"></div>
    <script src="https://cdn.jsdelivr.net/npm/preact/dist/preact.min.js"></script>
    <script src="bundle.js"></script>
  </body>
</html>

Babel is going to transpile our app file into a single bundle.js file.

Add Preact Component

Create a new simple component:

const { h, render, Component } = window.preact;

class HelloPreact extends Component {
  render() {
    return <div>Hello Preact</div>
  }
}

render(<HelloPreact />, document.getElementById('root'));

And save it in a file named app.js, or any name you prefer.

The window.preact reference comes from the script tag inside the HTML file.

What is Babel?

In Babel own description:

Use next generation JavaScript, today

It is a tool that allows you to convert javascript features not yet implemented, into something actual javascript engine understands.

Install Babel

We are going to use @babel/cli package to transpile app.js into bundle.js.

There's different way you can use Babel, see instructions in Babel installation page.

$ npm install --save-dev @babel/core
$ npm install --save-dev @babel/cli

# Or both together
# npm install --save-dev @babel/core @babel/cli

@babel/cli allows us to execute @babel/core from the terminal.

Add Babel Plugins

Now we've installed Babel, but we need make it useful by installing some plugins. What we want is to convert the modern JS code from app.js into something our browser understands.

@babel/preset-env helps us convert any code from ES2015 and newer standard.

Let's install and enable this preset. Preset is a collection of plugins.

$ npm install --save-dev @babel/preset-env

All modern/future features can be converted, but JSX are not.

Let's install the React JSX transform plugin. React and Preact have the same API, which means we can use the React plugin with a minor change.

$ npm install --save-dev @babel/plugin-transform-react-jsx

The preset and plugin are installed, but we need to tell @babel/cli that we want to use it.

Create a file named .babelrc, it will holds the configurations for @babel/cli.

$ touch .babelrc

To enable the preset and plugin we need to add it to .babelrc file.

{
  "presets": [
    "@babel/preset-env"
  ],
  "plugins": [
    ["@babel/plugin-transform-react-jsx", {
      "pragma": "h"
    }],
  ]
}

By default @babel/plugin-transform-react-jsx because is a React specific plugin, it will translate <></> from JSX into React.createElement, instead of Preact h function, we must substitute this by changing the pragma option to h.

Pragma option reference

Transform JavaScript

Add a new command to package.json inside the scripts property to execute the babel command.

"scripts": {
  "build": "babel app.js -o bundle.js",
  "test": "echo \"Error: no test specified\" && exit 1"
},

Run the build command, and access index.html to see the result.

$ npm run build

See final code here: WellingGuzman/hello-preact.

See also:

• Hello Preact Modules

With this command you can do more than just change the timezone, such as change the date and time.

To change the timezone you should use timedatectl set-timezone <timezone>. If you don't know the names of the timezone, use timedatectl list-timezones to list all timezones available.

Replace <timezone> with any of the value listed by the timedatectl list-timezones command.

timedatectl set-timezone America/Vancouver

Run timedatectl again to confirm the changes.

// Equals
$result = 0 == '';
$result = 0 == '0';
$result = 0 == 'string';
$result = 0 == '0string';

// Not Equals
$result = 0 == '1string';

When there's an integer in one of the operands, PHP converts the other to an integer. If it starts with a number, all the subsequent numbers will be returned when casting the string value to an integer. 1string will result in 1, and 123string will result in 123.

I spent sometime trying to figure out why my code wasn't working. This could be avoided by using the identical operator ===, or casting the integer value to string, rather the equal operator ==.

Pagination refers to the process of dividing a large dataset into smaller parts.

The ability to send data to the user faster by fetching a whole dataset by small pieces at a time is one of the benefits of using pagination.

How it works

Pagination works by defining the maximum number of rows in the results per request and what page is being requested.

The table below represents the items on a table named users, that is going to be used an example.

+----+----------+
| id | Name     |
+----+----------+
| 1  | John     |
| 2  | Jane     |
| 3  | Peter    |
| 4  | Joseph   |
| 5  | Mary     |
| 6  | Jack     |
| 7  | Ann      |
| 8  | Bill     |
| 9  | Sam      |
| 10 | Rose     |
| 11 | Juan     |
+----+----------+

For this example the maximum number of rows will be 2, which means on every request we are going to get at most 2 rows.

The table has 11 rows, and we are limiting the result by 2 rows per request, resulting in a 6 pages of 2 items. The number of pages are determined by dividing the number of rows (11) by the number of rows per page (2), and making sure the result is rounded to the next integer number.

Total pages = CEIL(Total number of rows / Limit number of rows)

MySQL doesn't have a PAGE clause, but it has a OFFSET clause, which allow to move the position from where to start counting up to the LIMIT number.

The value of OFFSET is done by multiplying the LIMIT clause value by the page number your are looking for minus 1.

OFFSET = LIMIT * (PAGE - 1)

In the table above there is 11 users and to get the first 2 users we use the following query:

PAGE = 1
LIMIT = 2
OFFSET = (PAGE-1) * LIMIT
OFFSET = (1-1) * 2
OFFSET = 0 * 2
OFFSET = 0

The offset initial value is 0, and not 1, that's why we subtract 1 from the page number.

SELECT `id`, `name`
FROM `users`
LIMIT 2
OFFSET 0

The previous query will produce the following result which represents the page 1 of the pagination:

+----+----------+
| id | Name     |
+----+----------+
| 1  | John     |
| 2  | Jane     |
+----+----------+

MySQL has a different way to use offset, without using the OFFSET clause.

SELECT `id`, `name`
FROM `users`
LIMIT 0,2

The first parameter is the offset and the second parameter is the rows count.

To get the second page, or in other word the next two rows, we must calculate again the OFFSET or increase by one the previous value.

PAGE = 2
LIMIT = 2
OFFSET = (PAGE-1) * LIMIT
OFFSET = (2-1) * 2
OFFSET = 1 * 2
OFFSET = 2

SELECT `id`, `name`
FROM `users`
LIMIT 2
OFFSET 2

Below can be seen the result of the previous query:

+----+----------+
| id | Name     |
+----+----------+
| 3  | Peter    |
| 4  | Joseph   |
+----+----------+

The query translate to skip the first 2 items and get the next 2 rows.

So getting the third page we use the following OFFSET of 4, to skip the first 4 items.

PAGE = 3
LIMIT = 2
OFFSET = (PAGE-1) * LIMIT
OFFSET = (3-1) * 2
OFFSET = 2 * 2
OFFSET = 4

SELECT `id`, `name`
FROM `users`
LIMIT 2 OFFSET 4

+----+----------+
| id | Name     |
+----+----------+
| 5  | Mary     |
| 6  | Jack     |
+----+----------+

OFFSET and ORDER BY

Using OFFSET and ORDER BY together could make the pagination non-functional returning in rows random orders, and unexpected rows on each page.

If multiple rows have identical values in the ORDER BY columns, the server is free to return those rows in any order, and may do so differently depending on the overall execution plan. In other words, the sort order of those rows is nondeterministic with respect to the nonordered columns. MySQL documentation

The most common situation is that if you are sorting by a column that doesn't have an index, MySQL Server cannot determine a proper order of the rows.

One way to solve this is by adding an index to the column or columns. Although this may not be as optimal if you don't want or need to add indexes to multiple columns only for this purpose.

If it is important to ensure the same row order with and without LIMIT, include additional columns in the ORDER BY clause to make the order deterministic. MySQL documentation

What this means is there's another way to solve this is by adding to the ORDER BY clause an unique column, for example a primary key column.

SELECT `id`, `name`
FROM `users`
LIMIT 2
OFFSET 2
ORDER BY `name`, `id`

Instead of:

SELECT `id`, `name`
FROM `users`
LIMIT 2
OFFSET 2
ORDER BY `name`

This way you can make sure that MySQL sorts the rows by an unique column before finding the LIMIT number of rows.

I noticed that the server has an outdated version of nodejs. Running a 0.x nodejs version while everything was created under 8.x.

After trying to update to a new version can be tricky as there's a tons of way documented on how to install it and easier on windows and mac systems.

How to install or update nodejs can be found on the package manager section of nodejs's downloads page.

This method also works for any Debian and ubuntu based distributions.

Update Source List

First, You would need to update your system package source list. Depending on the version you want to upgrade, there's different script that will try to update your source list.

NOTE: Be carefully, these are bash scripts and can execute dangerous code, if you are a little bit skeptical you can see the content first before you use it or you can read the manual installation

# Node.js v4
curl -sL https://deb.nodesource.com/setup_4.x | sudo -E bash -

# Node.js v5
curl -sL https://deb.nodesource.com/setup_5.x | sudo -E bash -

# Node.js v6
curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -

# Node.js v7
curl -sL https://deb.nodesource.com/setup_7.x | sudo -E bash -

# Node.js v8
curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -

# Node.js v9
curl -sL https://deb.nodesource.com/setup_9.x | sudo -E bash -

# Node.js v10
curl -sL https://deb.nodesource.com/setup_10.x | sudo -E bash -

Install package

After the source list has been updated, the next step is installing the new nodejs version.

sudo apt-get install -y nodejs

Confirm

The last step will be to confirm the version installed are correct, or pointing to the right path as multiple nodejs can be installed in the same system.

Try running:

$ node -v
$ which node
$ npm -v
$ which npm

In conclusion you may want to have node and npm point to the right path. For example, you can look into /usr/bin or /usr/local/bin to make sure which node and which npm points to the right version.

Fortunately, browsers have a Canvas API that allows us to draw graphics using JavaScript. We can actually draw images to the <canvas> from the video itself, which gives us the ability to manipulate and play with those pixels.

Everything you learn here about how to manipulate pixels will give you a foundation to work with images and videos of any kind or any source, not just canvas.

Read full article.

I learned english almost by myself. I was taught english at school, but the same thing for a decade, nothing useful at the long run. about 5 years ago I put myself into a intensive english course for grammar and allow myself to speak with people in english, since then I have not talk much.

I would say I am good at listening and reading, I read and listen english every day, but I write from time to time, and speak not very often (almost zero time).

My goals is to get used to speak and write english more often. The way I want to accomplish this is by writing every day or record myself talking or both.

I hope by the end of the 100 days I've improved my skill of communicate.

This will count as the first day.

Follow my progress on Twitter.

I feel bad when I have to search for a simple task, such as, how substring minus start position works? I have used it a lot of times and still forget how it works.

I used to create a lot of things, even useless app because I like to make things. Lately it has been different as I was believing I should act more "Pro" and just build things that matter and useful to at least a group of people.

I realized I should go back to my roots and create things just for fun. I don't have to worry about whether or not is perfect or useful just make things works and learn something new.

I have been thinking on challenging myself on coding a project each week or code something everyday for a n period of time, but I did not find any strong motivation until today.

Today I came across a tweet and a video that looked like it was directly written to me, these put the cherry on top and I decided to make the #100DaysOfCode challenge.

The rules are basically:

• Code minimum an hour every day for the next 100 days.
• Publish your progress

The goals will be create around 20 mini projects in the next 100 days.

Follow my progress on Twitter and GitHub.

The way this mock response works is by attaching fake response objects to the http client, and on every request it will pick the result from the queue instead of making a real request to the server.

Guzzle HTTP 5

Let's take a look how mocking was done on version 5 in the example below:

// Guzzle http client
$client = new \GuzzleHttp\Client([
    'base_url' => 'http://localhost'
]);

// Create Mock
$mock = new \GuzzleHttp\Subscriber\Mock();

// Attach mocking subscriber to the client
$client->getEmitter()->attach($mock);

// Add response to a queue
$mockPath = '/path/to/raw/response.txt';
$mockContent = file_get_contents($mockPath);
$mock->addResponse($mockContent);

The content of /path/to/raw/response.txt is a raw http response.

HTTP/1.1 200 OK
Date: Wed, 15 Jun 2016 17:02:51 GMT
Server: nginx
Content-Length: 86
Content-Type: application/json; charset=utf-8

{"id":1,"active":1,"title":"Article 1","body":"Content","tags":"tags,tugs","author":1}

The next request the client makes it will pick the first response on the queue as the result.

You can add more responses to the queue, and make sure you the queue is not empty before you send a new request.

$mockPath = '/path/to/raw/http/response/file.txt';
$mockContent = file_get_contents($mockPath);
$mock->addResponse($mockContent);

Guzzle HTTP 6

On version 6 they removed the Mock class and introduce a new MockHandler class. docs.

We now need to create a http client and attach the MockHandler object as the client handler

// Guzzle http client
$handler = new \GuzzleHttp\Handler\MockHandler();
$client = new \GuzzleHttp\Client(['handler' => $handler]);

There is not way to access the handler, so you have to keep a reference somewhere.

Now all the response needs to be added to the mock handler using the append method.

// Add response to a queue
$mockPath = '/path/to/raw/http/response/file.txt';
$mockContent = file_get_contents($mockPath);
// Convert the raw http response into a Response Object
$response = \GuzzleHttp\Psr7\parse_response($mockContent);
$handler->append($response);

Same as previous version each request pull the first response from the queue on each request.

From NSViewController source file:

On 10.10 and higher, a nil nibName can be used, and NSViewController will automatically attempt to load a view with the same class name.

It is important to notice that even this comment states that will attempt to load a view with the same class name, it seems to be attempting the file name instead.

NSViewController -loadView comment:

Prior to 10.10, -loadView would not have well defined behavior if [self nibName] returned nil. On 10.10 and later, if nibName is nil, NSViewController will automatically try to load a nib with the same name as the classname. This allows a convenience of doing [[MyViewController alloc] init] (which has a nil nibName) and having it automatically load a nib with the name "MyViewController".

Having a controller with the name MyViewController and a view with the name MyView wouldn't work because the controller will attempt to load a nib with the name MyViewController. Naming a view MyViewController doesn't make sense because it is not a controller.

What should we do here? use the method -nibName to set the default nib name.

In your controller implementation file add the following method:

- (NSNibName)nibName
{
    return @"MyView";
}

NSNibName is an alias for NSString.

Now the controller will attempt to load MyView nib instead of a MyViewController.

remote: Permission to directus/directus.git denied to WellingGuzman.
fatal: unable to access 'https://github.com/directus/directus.git/': The requested URL returned error: 403

For some reason this started to happen after I installed Github Desktop Application.

I don't know the reason why it got invalid or corrupted, but I did find a way to re-authenticate myself.

On Mac OSX Git uses the Keychain Access to store credentials information, you can either update or remove the credentials from the keychain.

Removing this information the next time you try to push it will ask you to enter your username and password

$ git push origin master
Username for 'https://github.com': wellingguzman
Password for 'https://wellingguzman@github.com':
remote: Invalid username or password.

Terminal

git credential-osxkeychain erase

Application

1. Using the method of your preferences, Finder search, manually search the application directory or CMD (⌘) + Spacebar look for "Keychain Access".
2. Search for "Github.com"
3. Find and edit/remove the one that says to be "Internet password" kind, to make sure this is the one, open this entry and on the access control tab should says credentials-osxkeychain.
4. After you are sure about this, edit or delete to get back your git access control.

Hope it helps, hope I can remember this next time.

Fetching a table information can be done with the following query:

SELECT TABLE_NAME, ENGINE, TABLE_COLLATION
FROM INFORMATION_SCHEMA.TABLES
WHERE
  TABLE_SCHEMA = "mydatabase"
  AND TABLE_NAME = "Products"

Result:

+------------+--------+-----------------+
| TABLE_NAME | ENGINE | TABLE_COLLATION |
+------------+--------+-----------------+
| products   | InnoDB | utf8_general_ci |
+------------+--------+-----------------+

This result is what we expected, the name, the engine and the collation. The problem comes when the table have uppercase letter, as the result always seems to be in lowercase.

I can't tell if this is a configuration issue or a mysql bug.

Making a the condition for table name twice solves the issue.

SELECT TABLE_NAME, ENGINE, TABLE_COLLATION
FROM INFORMATION_SCHEMA.TABLES
WHERE
  TABLE_SCHEMA = "mydatabase"
  AND (
    TABLE_NAME = "Products"
    OR TABLE_NAME = "Products"
  )

The query above will result with the table name in the original case it was created.

+------------+--------+-----------------+
| TABLE_NAME | ENGINE | TABLE_COLLATION |
+------------+--------+-----------------+
| Products   | InnoDB | utf8_general_ci |
+------------+--------+-----------------+

#1071 - Specified key was too long; max key length is 767 bytes
#1071 - Specified key was too long; max key length is 1000 bytes
#1071 - Specified key was too long; max key length is 3072 bytes

It can be any of previous errors depending on what is the storage engine of the table. MySIAM, InnoDb or InnoDb with innodb_large_prefix enabled have differents key length limitation.

TL;DR

The difference between utf8 and utf8mb4 charset is the bytes requires to store each characters. utf8 requires 3 bytes, while utf8mb4 requires 4 bytes. This means using utf8mb4 charset in a table with innodb engine with innodb_large_prefix disabled, at most 191 characters in a string column must be used.

191 characters × 4 bytes = 764 bytes which is less than the maximum length of 767 bytes allowed when innodb_large_prefix is disabled. Since MySQL 5.7 innodb_large_prefix is enabled by default allowing up to 3072 bytes.

String Storage

String storage size vary depends on whether the column is fixed-length or variable-length. It also depends on the charset, it takes more bytes to storage a japanese character than an ASCII/Latin letter.

As an example, CHAR is a fixed-length while VARCHAR and TEXT are variable-length.

All fixed-length data types uses all the bytes they were declared. For example CHAR(16), no matter what its value is, it's right padded with spaces to fill up to the specific length. On the other hand VARCHAR only uses 1 byte + the content size.

VARCHAR requires a prefix value of 1 byte to store the length of the string if the size is less than 256, otherwise it will uses 2 bytes.

One tip is not to use CHAR if you are not going to use all the characters almost all the time, because the size can pile up with empty strings column.

Character Set

The UTF8 character set uses a maximum of 3 bytes per character and only contains Basic Multilingual Plane (BMP) characters, which is the home of 65,536 characters (16 bits) from U+0000 to U+FFFF.

The UTF8mb4 character set uses a maximum of 4 bytes per character including all of BMP characters and Supplementary Multilingual Plane (SMP) which include another possibility of 65,536 new characters from U+10000 to U+1FFFF.

Emojis (Unicode characters)

UTF8 can support emojis, but not all of them. All of the new emojis are part of the SMP, so in order to support both basic and supplementary multilingual plane UTF8mb4 must be used.

The sparkle emoji (✨ U+2728) value is between U+0000 and U+FFFF then it can be used on utf8 charset, but the Woman Health Worker (👩 U+1F469) value which is not between U+0000 and U+FFFF, must use the utf8mb4 charset that range between U+10000 and U+1FFFF.

Index length

Now after using utf8mb4 all the characters use 4 bytes instead of 3, so all columns that has more than 191 characters now uses more than 767 bytes, because 192 x 4 bytes is 768 bytes.

Keep in mind the 768 bytes limit is only when using innodb engine and innodb_large_prefix is disabled. Since MySQL 5.7 innodb_large_prefix is enabled by default allowing up to 3072 bytes. MySIAM has a maximum length of 1000 bytes.

Solutions

The solve this will depend on what we actually need it can be either removing the index, keep using utf8, add a length to the index key or reduce the length of the column.

Reduce length

For us removing the index wasn't a good option, neither keep using the utf8. Reducing the length was possible because the columns will probably never met the actual length which is 255 characters, reducing it to 191 was optimal and in no way impact the table.

Index length

If changing the length was not possible or desired option, changing the column index to only a chunk of n characters, is another possible option.

CREATE INDEX `index_name` ON `posts` (title(191));

php5-mcrypt : Depends: libmcrypt4 but it is not installable

Running apt-get install php5-mcrypt didn't work.

Running apt-get update first didn't work either.

After some time figuring out what was the problem, I end up noticing that the source.list file was missing.

The next question would be where do I find the official ubuntu repositories? Luckily I found this generator where you can select a ubuntu release and all the repositories you need and it generates a source.list file.

Copying and pasting the new generate content to source.list file, and then running apt-get update, will updates the ubuntu package repositories.

Now apt-get install php5-mcrypt works.

<?php
use Zend\Db\Sql\Sql;
use Zend\Db\Sql\TableIdentifier;

$sql = new Sql($adapter);
$select = $sql->select();
$select->from(new TableIdentifier('table', 'database'));
$select->where(array('id' => 1));

$statement = $sql->prepareStatementForSqlObject($select);
$results = $statement->execute();

nohup

Running a script in the background in linux can be done using nohup, using nohup we can run node application in the background.

$ nohup node /nodeapp/index.js &

Kill Process

You can stop the process using the kill command as well:

First you need to know which process ID to kill, list all the process running node by running:

ps axl | grep node

The second column of your result is probably the PID, take that number and run the command below:

kill -9 [PID]

Forever

Forever is another solution for Node.js scripts.

Installation

$ npm install forever -g

Usage

$ forever start /nodeapp/index.js
$ forever restart /nodeapp/index.js
$ forever stop /nodeapp/index.js
$ forever list

PM2

Another tool I found is PM2, it has a lot of extras features that I have not used, except process management.

Installation

$ npm install pm2 -g

Usage

$ pm2 start /nodeapp/index.js
$ pm2 restart /nodeapp/index.js
$ pm2 reload /nodeapp/index.js
$ pm2 stop /nodeapp/index.js
$ pm2 delete /nodeapp/index.js
$ pm2 list

References

• Forever
• nohup(1)
• PM2

From PHP documentation:

Note that the parameters for call_user_func() are not passed by reference.

<?php

function increment(&$var)
{
    $var++;
}

$a = 0;
call_user_func('increment', $a);
echo $a."\n"; // $a is equals to 0

In order to solve this problem call_user_func_array() must be used instead.

<?php
function increment(&$var)
{
    $var++;
}

$a = 0;

call_user_func_array('increment', array(&$a));
echo $a."\n"; // $a is equals to 1

Example:

server {
  auth_basic "Restricted content";
  auth_basic_user_file /etc/nginx/.htpasswd;

  location /public/ {
    auth_basic off;
  }
}

$ cat file1.txt file2.txt > newfile.txt

If permission is needed to create and write into new files in the specified path you must use sudo, so you do this:

$ sudo cat file1.txt file2.txt > newfile.txt

But that doesn't work because the output is handle by the shell and not sudo, and by that it means it won't let you create the new file returning something like this: -bash: newfile.txt: Permission denied. Note: This only happen when the current user doesn't have permission to create/write on the new file.

There's several solutions to this but a one-liner solution is to run a shell command inline:

sudo sh -c 'sudo cat file1.txt file2.txt > newfile.txt'

There is a comparison that start with "Javascript is related to java as something is to some" is a clever and funny comparison to me.

So this would be a list of this comparison phrases:

• JavaScript is related to Java as Hamburger is to Ham.
• JavaScript is related to Java as Hamster is to Ham.
• JavaScript is related to Java as Rocket is to Rock.
• JavaScript is related to Java as Carnival is to Car. From YDKJS Books
• More to come...

If you love something and want to say how much you love it, say it while you love it, and when you stop loving it, you can share it again and compare saying why you stop loving it.

If you want to share something today, and if you are like me, there's a high chance that tomorrow you won't feel that spark that make you feel you need it to share something.

I want to share so much, but then I end up thinking, who wants to read this anyway, who will find this anyway. Don't be that person.

Don't be me and share your thoughts, it doesn't matter that you think it's worthless, someone will find it worth it.

I'm saying this not because I do it, because I don't, but because I've been on the other side as a reader, reading comments about how they hate the post AND the author, while I'm sitting here thinking why do they hate them, they are awesome and this content is great. The author probably is thinking is all true, because people who liked the content are not expressing their love to them and their content, but rather they just stare at how other people hate (or don't like) them.

Please, share your thoughts and let people know if you liked their content or not, but do not offend them, they can talk, if not, move along.

I'll take my own advice and do the same. Let's

In 2003, I found out that anyone were able to make websites, that it wasn’t something just for big company to show their product and information. So started digging and searching on Altavista and Yahoo (Remember those search engine?), “where” and “how” do I start making websites.

I found Geocities, it was a great service from Yahoo. but as far as I remember it was only HTML, CSS, images and glitter, then I found Lycos, here I could upload PHP code and MySQL databases, it was all about CuteFTP and PHPMyAdmin. I uploaded CMS, forums, blogs (I think it were called news back then, don’t recall), and thousands of PHP scripts for any purpose, such as PHPNuke and PHPBB.

I didn’t know programming at all, but I loved how easy it was, you didn’t need to know OOP, just open a text editor and write some basic c-style code instruction and you are all set, no framework, no nothing.

I really learned how to program in PHP (or build websites) by analyzing for hours a pagination script, and since then I’ve been using and learning more and more PHP.

I’ve built so many sites, for different type of clients, I buy my first PC by selling my first website, a well-configured and customized PHP-Nuke script.

Until last year I thought PHP was death, but I realized that I was around different people, because I was surprised how many people still using php, so it makes go back to PHP.

I don’t mind the people who hate PHP and PHP Developers, the most common thing question I get after I say I’m a PHP developer is: “why?”.

Thanks to PHP I got into Web Development, and I love it.

I would like to thanks: Rasmus Lerdorf, PHP core developers and the whole PHP community and web folks.