The employer mandate provision included in the House Democrats' bill requires employers to either provide health insurance (with upto 72.5% of the premiums) to all employees or pay an additional payroll tax. Based on the average employer-based family plans cost of $12,700 in 2008, it means additional $8,255 per employee per year. Dividing by the number of hours worked in a year (40 hours per week * 50 week), we get additional hourly wage increase of approximately $4 per hour. The current federal minimum wage is $7.25 per hour. Thus, the employer mandate effectively increases the minimum wage by more than 50%. Wonder what that will that do the already high unemployment ratio of more than 9%!

Paul Krugman ridicules the Matthew Yglesias's claim that Texas is rich due to its low taxes and less regulation because he used median income instead of per-capita income for the comparison. He goes on to point out that "free-market" Texas has a per-capita income of $37,187 vs $49,194 for nanny-state New Jersey.

As many people noted in the comments, this does not take into account cost of living differences between the two states (Texas has much lower cost of living than New Jersey). Additionally, the median incomes figures are before-tax. Since, the point is to compare economic well-beings of people living in states with different tax rates, we should be using after-tax income. I couldn't easily find after-tax median household income data for Texas and New Jersey, but I suspect, New Jersey will fare much more poorly on that measure. 

James Kroeger makes this ridiculous claim in the post "The New Deal Didn’t Always Work, Either":

The purchase of a piece of land, for example, is a financial investment if it appreciates in value over time, but it is not an economic investment if it just sits there, undeveloped. Purchases of stocks in secondary markets (e.g., NYSE, NASDAQ) are clearly financial investments if the stocks appreciate in value, but they are not economic investments because they involve nothing more than exchanges of titles of ownership of already existing assets. They do not typically put any money into the hands of firm managers that could be used for economic investments. That normally happens only when stocks are first sold to underwriters, prior to an initial public offering.

So what happens to the money paid to buy financial assets (say, stocks on NYSE)? The person who sold the stocks must either spend the money (increase consumption) or fund new real investment(s). The seller can indeed use to money to buy other financial assets but the chain has to end in real consumption or real investment ultimately!

In an earlier post, partial make replacement, I developed a small Haskell based DSL to express GNU make like rules. In this post, I take the idea further to support multiple dependencies per target.

testO = (return ["test.c", "test.h"]) ->> ccompile >>- "test.o"

testExe = testO ->> link >>- "test.exe"

main = testExe

The above example, expresses in a simple way, that test.o depends on test.c and test.h and can be "made" using ccompile (C compilation). Similarly, test.exe depends on test.o and can be generated by linking test.o. Checkout the Hmake module (30 lines, including the definition of ccompile and link) and try it out yourself. It now properly checks if a target is out of date with its dependency before trying to build to the target.

Compare the above with the elaborate topological sort based ermake implementation (232 lines) using erlang.

With the Haskell module above, one can even build multiple targets in parallel by using forkIO (part of the Concurrent Haskell).

My earlier post on Haskell described a small DSL for calendar apps. In this post, I will show a very simple DSL (written in just 6 lines of code) to replace (a small portion of) GNU make utility. Earlier, I had attempted the GNU make replacement in Haskell without the use of DSL concepts.

At a very basic level, GNU make allows one to describe how a particular goal (or target) is made (generated using a set of shell commands) from a set of its dependencies. In Haskell, I should be able to describe this relationship like this:

return "test.c" ->> ccompile >>- "test.o" ->> link >>- "test.exe"

In other words, test.exe is made from test.o, which in turn is made from test.c.
The plumbing code can be written in a few of lines like this:

import System.Cmd

dep ->> cmd = \target -> dep >>= (\xdep -> (cmd xdep target) >> return target)

tcmd >>- target = (tcmd target) >> return target

ccompile dep target = system("gcc -c " ++ dep ++ " -o " ++ target)

link dep target = system("gcc  " ++ dep ++ " -o " ++ target)

Notice, how the dataflow is made clear because of the notations used. In addition, the use of IO monad means you can keep on "linking" output of one stage to another. Compare and contrast this with the compiler based DSL using Ocaml described here.
For the sake of simplicity, I haven't added the code to check if the target is out of order with   
respect to its dependency. And only one dependency per target is currently supported. These features however, are not very hard to add. As usual, your feedback is highly welcome and is sincerely appreciated. You can download the code from here.