Corecool's Home

Emacs: View and Set Environment Variables within Emacs

Wed, 13 Jun 2012 11:10:27 -0400

Emacs: View and Set Environment Variables within Emacs:

When you start emacs from a shell, emacs inherits shell’s environment variables. (true on Windows, Mac, Linux)

On Windows, when you start emacs from GUI, emacs also inherit environment variables, from the Registry.

On Mac OS X, when you start emacs from GUI, emacs does not inherit environment variables from your shell, but does inherit the system-wide environment variables from 〔~/.MacOSX/environment.plist〕.

On Mac OS X, you can start GUI emacs from shell, like this: nohup /Applications/Emacs.app/Contents/MacOS/Emacs &. This way, it’ll inherit shell’s environment variables.

Recursive Greps

Thu, 07 Jun 2012 05:51:11 -0400

Recursive Greps :

—include=”xxx”

New Garbage Collector

Sat, 02 Jun 2012 03:57:11 -0400

New Garbage Collector:

The following design document describes the the new garbage collector (GC) to be introduced with LuaJIT 2.1. This document is very much a work in progress right now. Anything may change for the actual implementation. No code is available, yet.

The purpose of this document is to gather early feedback on all design aspects and to present the planned work to sponsors.

Note to potential sponsors: This feature is in need of sponsorship! Work on LuaJIT 2.1 probably won’t start until I’m able to get full covenants for this and other planned new features. Please refer to the LuaJIT Sponsorship Page. Thank you!

You probably need to have at least some background knowledge on garbage collection algorithms to fully enjoy the following document. There are plenty of books, research papers and other freely available online resources for this. A good start would be the Wikipedia article on Garbage Collection.

Default grep options | Arabesque

Sun, 20 May 2012 21:42:12 -0400

Default grep options | Arabesque:

The environment variable of grep.

Steve's Awk Acadamy

Sun, 20 May 2012 21:26:44 -0400

Steve's Awk Acadamy:

Don’t use awk!

Unless:

The task at hand is primarily the parsing of files or piped streams.
You’re willing to ignore OOP and Structured Programming principles.
You’re willing to learn the awk way of doing things.
The program is not expected to grow larger than 400 lines.

12 Ways to Increase Throughput by 32X and Reduce Latency by 20X

Sun, 06 May 2012 22:26:40 -0400

12 Ways to Increase Throughput by 32X and Reduce Latency by 20X:

Do not use locks in the main transaction flow because they cause context switches, and therefore latency and unpredictable jitter.
Never have more threads that need to run than you have cores available.
Set affinity of threads to cores, or at least sockets, to avoid cache pollution by avoiding migration. This is particularly important when on a server class machine having multiple sockets because of the NUMA effect.
Ensure uncontested access to any resource respecting the Single Writer Principle so that the likes of biased locking can be your friend.
Keep call stacks reasonably small. Still more work to do here. If you are crazy enough to use Spring, then check out your call stacks to see what I mean! The garbage collector has to walk them finding reachable objects.
Do not use finalizers.
Keep garbage generation to modest levels. This applies to most JVMs but is likely not an issue for Zing.
Ensure no disk IO on the main flow.
Do a proper warm-up before beginning to measure.
Do all the appropriate OS tunings for low-latency systems that are way beyond this blog. For example turn off C-States power management in the BIOS and watch out for RHEL 6 as it turns it back on without telling you!
Macro-benchmarking is much more valuable than micro-benchmarking.
Amazing results are achieved by truly agile companies, staffed by talented individuals, who are empowered to make things happen. Make sh*t happen is more important than following a process.

Calling Constructors with Placement New

Thu, 26 Apr 2012 21:20:58 -0400

Calling Constructors with Placement New:

The placement new in C++. It can be used in many embedded systems.

Useful Unix Tools

Thu, 26 Apr 2012 05:52:37 -0400

Useful Unix Tools:

The following is a special collection of freeware tools for system administration written in Perl. They cover advanced topics for the experienced admin, and are a valuable addition to a senior admin’s collection or those wishing to be a senior admin. Most are related to performance or fault prevention.

Note: These are freeware programs and have nothing at all to do with the respective Operating System vendors.

Understanding Client-Side Storage in Web Apps

Wed, 25 Apr 2012 02:22:40 -0400

Understanding Client-Side Storage in Web Apps:

Compares the four major APIs for browser-side storage and explains how to balance performance, data size, and browser support.

Elegant exact string match using BWT

Tue, 24 Apr 2012 11:10:01 -0400

Elegant exact string match using BWT :

String matching algorithm named BWT.

Michael Feathers: Tell Above, and Ask Below - Hybridizing OO and Functional Design

Mon, 23 Apr 2012 00:35:30 -0400

Michael Feathers: Tell Above, and Ask Below - Hybridizing OO and Functional Design:

‘Tell, Don’t Ask.’ The idea was that objects are really best when you tell them to do something for you rather than asking them for their data and doing it yourself.

In OO, it is better to tell.

Put the object layer on top and allowed the objects to use functional pieces below

Benchmarking Block-Swapping Algorithms | Dr Dobb's

Sat, 21 Apr 2012 23:51:15 -0400

Benchmarking Block-Swapping Algorithms | Dr Dobb's:

Algorithms for swapping blocks of data appear simple, but vary widely in their performance profiles. Choosing the right one can be crucial to good performance.

Conclusion

Three sequential O(n) in-place algorithms for swapping/exchanging blocks of unequal sizes were explored. The Gries-Mills algorithm is the performance leader with the Reversal algorithm coming in a close second, and the Juggling algorithm a distant third. The Reversal algorithm is the gem of the three, having high and consistent performance, the smallest and simplest implementation, and being the easiest to understand. The Gries-Mills and Reversal algorithms performed well due to their cache-friendly memory access patterns. The Juggling algorithm performed the fewest memory accesses, but came in over 5x slower due to its cache-unfriendly memory access pattern.

20 awesome node.js npm modules we use every day

Sat, 21 Apr 2012 22:36:39 -0400

20 awesome node.js npm modules we use every day:

Node.js modules list

YouTube Strategy: Adding Jitter isn't a Bug

Sat, 21 Apr 2012 00:55:36 -0400

YouTube Strategy: Adding Jitter isn't a Bug:

Any time you have a lot of nodes that all need to do an operation at a specific time you rely on jitter to keep resources from bottlenecking.

No Silver Bullet

Fri, 20 Apr 2012 23:18:01 -0400

High level languages
Object oriented programming
Declarative languages
Functional programming
Data oriented design
Metaprogramming
Static typing
Duck typing
Garbage collection
Allocating on the stack
Tail calls
Resource acquisition is initialization
Symmetric multitasking
Heterogeneous multitasking

Parsing numbers with regular expressions

Fri, 20 Apr 2012 23:04:42 -0400

Parsing numbers with regular expressions

Visual Studio Asynchronous Programming

Fri, 20 Apr 2012 21:30:39 -0400

Visual Studio Asynchronous Programming:

The resource of Async Programming in VS.

HBase: ACID in HBase

Mon, 16 Apr 2012 00:06:01 -0400

HBase: ACID in HBase:

HBase employs a kind of MVCC. And HBase has no mixed read/write transactions.

Many kinds of memory-centric data management : DBMS 2 : DataBase Management System Services

Sun, 15 Apr 2012 22:57:38 -0400

Many kinds of memory-centric data management : DBMS 2 : DataBase Management System Services:

Excellent overview of the approached used by various in-memory databases by Kurt Monash.

The MySQL “swap insanity” problem and the effects of the NUMA architecture « Jeremy Cole

Sun, 15 Apr 2012 22:41:09 -0400

The MySQL “swap insanity” problem and the effects of the NUMA architecture « Jeremy Cole:

The memory allocated by MySQL looks something like this: Allocating memory severely imbalanced, preferring Node 0