touch ~/.forward
chmod 644 ~/.forward
vi ~/.forward

Contents of ~/.forward should be a comma or newline separated list of email addresses to forward mail to.  The following are correctly formatted: .forward files and a brief description of each.

Forward all local email to email@example.com:

email@example.com

Forward all local email to both email@example.com and alternate@domain.com:

email@example.com, alternate@domain.com

Use the local mail spool, keep a copy in the user’s ~/archive/mail file, and forward a copy to email@example.com:

\user, "/home/user/archive/mail", email@example.com

The permissions of the .forward file must be read-only for group and other. Failure to secure your .forward file will cause sendmail to ignore its existence.

GOTCHA!

Set your DNS to use Google’s DNS:
8.8.8.8 and 8.8.4.4

Then flush the existing DNS cache and register the new DNS.

In Windows 7, you’ll need elevated privileges to changes to the DNS. Make sure you start cmd.exe as Administrator.

1. Press the window Key
2. Type “cmd”
3. Right click the cmd.exe that’s found.
4. Select “Run as administrator”
5. Type ipconfig /flushdns
6. Then type ipconfig /registerdns

Now you’re free to roam the internet.

CHECK TABLE mytable QUICK reported ‘warning : Keyfile is almost full, 17179867136 of 17179867136 used’ Then myisamchk -dv mytable reported similar information under ‘Max keyfile length,” and reported “Keyfile pointer (bytes): 3′

After a little digging around, I realized that a 3-byte keyfile pointer only allows the index file to hold 2^24 blocks (about 16 million blocks of 1024 bytes each). My index file was holding about 110 keys per block (e.g., each record needed 4 bytes for the key value, plus 4 bytes for the datafile pointer, and maybe one byte for null/housekeeping, and then each block kept a little more empty space). So the 3-byte keyfile pointer only allowed MySQL to index about 1.8 billion records. Then it gave up, leaving a corrupted index file.

I have found no documentation for how MySQL decides how big a keyfile pointer to use in the .MYI file. I had no trouble adding 3-4 billion records to the MYD file, so it didn’t occur to me that there would be a problem with the MAX_ROWS clause of the CREATE TABLE command (which I hadn’t specified). But that turned out to be the problem.

I recovered my data table without the index file, then issued ALTER TABLE MAX_ROWS=4000000000, ADD INDEX (mykey); and now it looks like everything will be OK.

Here’s how I got my table back, without the index file (similar to what’s described above):

1. make a backup of the data file (mytable.myd), just in case
2. create a new empty table with the same structure as the existing table, but no index keys.
3. copy the .FRM and .MYI files from the new (empty) table over the existing mytable.frm and mytable.myi files.
4. issue REPAIR TABLE mytable USE_FRM; It is very important to include the USE_FRM clause. That way, MySQL knows to make a new (empty) .MYI file that matches the .MYD file, rather than truncating the .MYD file to match the .MYI file. You will eventually get a message along the lines of “Number of rows changed from 0 to xxxx”.
5. Now you have a working table, with no indexes. Then you can set MAX_ROWS to something appropriate, and try again to make the indexes.

PHP Parse error: syntax error, unexpected T_STRING in /var/www/default/docs/out/lib/lib/_php---obj---FFT.php.html on line 1, referer:...

I wanted script.php.html to be treated as an HTML file and not be processed by the php engine.  This double-extension was causing me grief.  The docs claimed that only files ending in the extension will be handled by the AddHandler command.  I was incredulous of this claim, especially in light of Apache’s ability to do content negotiation with those .var language files.

Q: Why was this happening? I first guessed it may have been due to mod_mime, but quickly ruled that out.  I then guessed it was the MultiView option… Maybe, this is one mechanism that governs content negotiation… The documentation claims:

# The index.html.var file (a type-map) is used to deliver content-
# negotiated documents.  The MultiViews Option can be used for the
# same purpose, but it is much slower.

This statement lead me to suspect that my problem may actually be caused by an issue with the AddHandler option, since an AddHandler command must be executed to associate type-map with that .var extension.

Ah me, time is money, and in the end, I actually didn’t diagnose the problem, but I did discover (by trial and error) a workaround.

In file /etc/httpd/conf.d/php.conf, I surrounded

AddHandler php5-script .php
AddType text/html .php

with

<Files ~ "\.php$">
  AddHandler php5-script .php
  AddType text/html .php
</Files>

Now, only files explicitly ending in “.php” will be treated as a php5-script.  Take that!

int hash(const void * str) {
  int val = 0;
  const char *ptr;
  int tmp;
 
  while (*ptr != '\0') {
    val = (val << 4) + (*ptr);
    if (tmp = (val & 0xf0000000)) {
      val = val ^ (tmp >> 24);
      val = val ^ tmp;
    }
  }
  ptr++;
  return val;
}

Or in PHP:

function hash($str) { 
  var $val = 0;
  for($i=0,$n=strlen($str); $i<$n; $i++) {
    $val = ($val<<4) + ord($str{$i});
    if( $tmp = ($val & 0xf0000000) ) { 
      $val = $val ^ ($tmp>>24);
      $val = $val ^ $tmp;
    }
  }
  return $val;
}

Now all you have to do is mod the returned value by the size of the hash table and you have the target address for the first pass of a hash table with double-hashing.

Naive:

function interest($initial=1000,$apr=0.015,$years=10) {
  $rate = $apr/12;
  $periods = 12*$years;
  $sum = $initial;
  for($i=0; $i<$periods;$i++) {
    $sum = $sum + $sum * $rate;
  }
  return $sum;
}

Log style:

function interest($initial=1000,$apr=0.015,$years=10) {
  $rate = $apr/12;
  $periods = 12*$years;
  return $initial * pow(1 + $rate, $periods);
}

Watch the boundary conditions. The above assumes the compounding occurs 12 times. Note that this log approach would not be appropriate if we were to add money to the fund after the compounding began. If the amount added per compounding period were consistent, we could devise a new log scheme.

Naive with additions:

function interest($initial=1000,$addition=100,$apr=0.015,$years=10) {
  $rate = $apr/12;
  $periods = 12*$years;
  $sum = $initial;
  for($i=0; $i<$periods; $i++) { 
    // Add interest earned in previous term.
    // Add $addition in preparation for next compounding period.
    $sum = $sum + $sum*$rate + $addition;
  }
  // Remove last $addition because there is no addition at the end-of-term.
  return $sum - $addition;
}

Log (via Geometric Series) with additions:

/**
 * Compute the balance on an account after some period of time.
 * The account may receive an initial deposit and/or regular deposits
 * at the start of every compounding period, after the first.
 * The APR, duration, and number of compounding periods may be specified.
 *
 * @see http://en.wikipedia.org/wiki/Geometric_series
 * @param float $inital Initial deposit amount
 * @param float $addition Amount added at start of each compounding period
 * @param float $apr Annual percentage rate (percent/100) earned on balance
 * @param float $years Number of years ($years>0) to compute interest for.
 * @param uint $ppyr Number of compounding periods per year.
 * @return float Balance after $years time accruing interest at $apr rate.
 */
function interest($initial=1000,$addition=100,$apr=0.015,$years=10,$ppyr=12) {
  // Use geometric series to calculate the cumulative rate of return
  // with recurring, inter-period deposits (periods 0..N-1)
  // $initial is initial deposit, interest accrues immediately.
  // $rate is interest earned per period (percent/100).
  // $addition is amount added at beginning of period after first period.
 
  // Over time, interest accrues on the additional deposits:
  // let R = (1 + rate)
  // v0 = 0  -- we'll deal with the initial deposit elsewhere.
  // v1 = v0 * R + additional
  // v2 = (v1) * R + additional
  // v2 = (v0 * R + add) * R + add
  // v2 = 0 + add*R + add
  // v2 = add*R + add
  // v3 = v2 * R + add
  // v3 = (add*R + add)*R + add
  // v3 = add(R^2 + R + 1)
  // v4 = v3 * R + add
  // v4 = (add*R*R + add*R + add)*R + add
  // v4 = add(R^3+R^2+R^1+R^0)
  // v5 = v4 * R + add
  // v5 = (v3 * R + add) * R + add
  // v5 = ((v2 * R + add) * R + add) * R + add
  // v5 = (((v1 * R + add) * R + add) * R + add) * R + add
  // v5 = ((((v0 * R + add) * R + add) * R + add) * R + add) * R + add
  // v5 = add * (R^4 + R^3 + R^2 + R^1 + R^0)
  // ... using geometric series ... a = add, r = (1+rate)
  // vN = a * (1 - pow(r,N)) / (1-r)
 
  $rate = $apr / $ppyr;
  $periods = $years * $ppyr;
 
  // Geometric series:
  // a + ar + ar^2 + ar^3 + ... + ar^n 
  //   = sum(k=0..n)[ar^k]
  //   = a * (1-r^(n+1)) / (1-r)
  // Where:
  //   a = $addition
  //   r = 1 + $rate
  //   n = $periods - 1
  //   k = [0..n]
  $a = $addition;
  $r = 1 + $rate;
  // Compute series from first period to last period
  $geom = $a * (1 - pow($r,$periods)) / (1-$r);
  // Remove $add from last period because next period didn't begin yet.
  $additional = $geom - $addition;
 
  // Compute interest on initial deposit + additional interest from above.
  return $initial * pow(1+$rate,$periods) + $additional;
}

Same as above, but without all those comments:

function interest($initial=1000,$addition=100,$apr=0.015,$years=10,$ppyr=12) {
  $R = 1 + $apr / $ppyr;
  $pow = pow( $R, $years * $ppyr );
  return ($initial * $pow) + ($addition * (1 - $pow) / (1-$R) - $addition);
}

There is a camera attached to your car facing forward. It has computer vision to detect stop-lights. There is a GPS device on-board to geo-tag these stop-lights. Associated with the stop-light location is its yellow-light duration. Ideally, whenever possible, the app would synchronize with other apps, sharing location and duration information as well. Using this information and GPS data, an app would be able to calculate how long it will take the driver to reach the light. If the light turns yellow, the driver will know whether he/she must stop or may continue through the yellow without running a red light.

An added feature would be a local database of start/stop acceleration data. This data could be used to calculate how must faster or slower the driver would/could travel to still make the light before it turns red.

Finally, a moisture sensor would need to be present, or other traction-like sensor, to determine road conditions and stopping distance. Correlation between historic acceleration data and moisture could be used to statistically compute stopping distance.

Future modifications might include a car detection system indicating how much space is needed between cars to stop in the event of a sudden incident.

Synchronization of traffic speed data is also achievable using this same architecture, thereby providing an alternative to in-ground traffic sensors.

Disclaimer: I know of at least one company using cell phone GPS data to measure traffic speed.

Edit: Waze – Real-time maps and traffic information based on the wisdom of the crowd
Edit: INRIX

The question is: How do you get the directory path of the script? dirname? Not reliably.

#!/bin/bash
ABSPATH="$(cd "${0%/*}" 2>/dev/null; echo "$PWD"/"${0##*/}")"
CWD=`dirname "$ABSPATH"`

Nice!

Of note, there is a good example of using iptables, and a description of how to bind your local mysql client to a remote mysql server.

http://www.cyberciti.biz/tips/how-do-i-enable-remote-access-to-mysql-database-server.html

Ref: LaunchPad » Ubuntu » Questions » Question #108951

The surest way to corrupt a youth is to teach him to hold in higher regard those who think the same as him

If voting made any difference, they wouldn’t let us do it. Mark Twain

Yesterday is yesterday. If we try to recapture it we will only lose tomorrow. Bill Clinton

Lower your voice and strengthen your argument. Lebanese proverb

Time is a great teacher, but unfortunately it kills all its pupils. Louis Hector Berlioz

Most people are other people. Their thoughts are someone else’s opinions. Their lives a mimicry. Their passions a quotation. Oscar Wilde

I do not feel obliged to believe that the same God who has endowed us with sense, reason, and intellect has intended us to forgo their use. Galileo Galilei

In linux-land, there’s always more than one way of doing things… even if it’s not the right way. Today, we’ll explore find piped to awk piped to the shell.

find . -type d -maxdepth 1 -mtime +60 | sort | 
awk -F"/" '{print "tar czf " $2 ".tar.gz --remove-files ./" $2 "; rmdir " $2 }' | sh

Basically, find all sub-directories in the current directory — don’t go recursive. Sort for sanity. Extract the file name portion (lots of ways to do this). Generate a shell command tar czf {{dirname}}.tar.gz --remove-files ./{{dirname}}; rmdir {{dirname}} to build the tarball and remove the empty directory when done. Finally, we just tell sh to execute it all… one directory at a time. Bam!

Plenty of business deals (and romantic rendezvous) have been foiled because someone failed to recall the right name at the right time. There are tricks to remembering names. Benjamin Levy, author of Remember Every Name Every Time, advocates the FACE method: “focus, ask, comment and employ.” Focus: Lock in on the person’s face. Ask: Inquire which version he prefers (“Is it Ted or Theodore?”). Comment: Say something about the name and cross-reference it in your head (“My college roommate’s name was Ted.”) Employ: Put the name to use–”Nice seeing you, Ted”–to drive it home. Here are nine more tricks.

1. Repeat, Repeat, Repeat
   The most surefire strategy is to repeat the person’s name–both in your head, and out loud–as soon as possible after you’ve been introduced. Occasionally use the person’s name in conversation. “Pleasure to meet you, Bob,” or “Bob, so good to see you.” Don’t overdo it, of course, but don’t worry that Bob will recoil, either. He’d rather you remember his name than not.
2. Picture This
   Turn someone’s name into an image that you can remember. When you meet Shirley, think of a Shirley temple. Don’t laugh–it works.
3. Spell It Out
   Another imagery-based tactic: Ask someone to spell out his or her name. If you can picture the letters in your mind, you’ll have a better chance of remembering the name. A derivation on that: Imagine the person’s name written across his forehead, like a billboard.
4. Connect
   Try to associate names with things people tell you about themselves (careers, hobbies) that will trigger the sound or association of the name in your mind. Fred likes to fish, Margarita runs a bar, you get the idea.
5. Word Play
   Let the words do the work for you. Mnemonic devices (Dale works in sales) work nicely, as does alliteration (Jim from Jersey).
6. Lead the Way
   If you know that your name will be hard to remember or pronounce, do other people a favor and help them out. They’ll return the favor–or, if you’re chatting with a Mike or a Bob, maybe they’ll make some big production out of their own common name, making it stick in your mind.
7. Put Pen to Paper
   It’s not enough to write down a person’s name as soon as possible after meeting them. Record the name in a “new contacts” file, and include when and where you met.
8. Speak Up
   Embarrassing as it seems, don’t be afraid to ask someone to repeat his or her name. Start out with a compliment, such as “I’ve had so much fun talking with you, and I’ve completely forgotten your name.” If you realize you’ve blanked on a name a few seconds after introduction, just say “I’m sorry, I missed your name.”
9. Prime the Pump
   You spy a person, whose name you’ve forgotten, making her way toward you. What to do? If you’re speaking with someone you know, introduce them right off the bat. The newcomer will probably introduce herself on her own. Problem solved.
10. [...There is no 10... Maybe #0 is the intro]

Disclaimer:
This post is 100% copied from: http://www.forbes.com/2010/04/20/how-to-remember-names-entrepreneurs-human-resources-remember-names_slide.html
This is a reference post, and since this blog is for reference purposes, I’ve posted it here in the name of fair use.

[Humble edit] To the authors of these books (or any book for that matter), I realize there is a ton of effort that goes into writing any book, especially those of a technical nature, and I sincerely appreciate your efforts. However, if you are the author of a book that simply copies the Python documentation and adds a few half-baked examples, then you are who I’m talking to. I’m also talking to the authors of so-called “advanced” Python books who have very poor programming style.

Ok, end rant 1.

What’s with the syntax? Everything looks like a GOTO: statement. Rule #1: No GOTO. It’s ugly and feels dangerous. Let’s not forget to mention the (one_element_tuple,) language artifact. I get it, but it’s ugly. /rant2

NumPy: Excellent and essential tool for data arrays. The strength of interpreted languages is rapid development. NumPy saves Python from the greatest weakness of interpreted languages: numeric operations on large arrays. This is the only reason to use Python IMO.

SciPy: I don’t know where this fits in yet, but I’m sure they’ve created highly specialized modules for various scientific fields, just like MatLab has created … whats the word… toolboxes? for various industrial sectors.

Python 2 or 3? 2. Until NumPy supports v3, I wouldn’t even think about it. Python is just too slow on its own… for dealing with arrays of numbers, that is.
EDIT: Yay! Python 3 support

Please, if there is one good Python book for programmers that involves numeric processing of millions to billions of data points, please speak up.

I with to retract my unbridled like for the language. Please replace that an appreciation for NumPy and interpreted languages.

Let’s keep it short and sweet (details from our reference):
man biosdecode
man dmidecode

Ref: Linux System Information Decoded, Hess, Ken. 2010-04-23.