Tritlo's Web Log

I wrote a clock!

2015-01-17T23:54:00.000+00:00

So, I wrote a clock.

I based it on an analogue clock I had written for a tomato timer app (still working on that), but I added a color variation by the time, to make it cleaner. Writing the clock itself was just an exercise in Canvas, and the source code is all up there for everyone to browse. The hardest part to write was probably the color selection function, but it's tricky to make a function that's smooth, but also visually pleasing. I don't know if I've hit on a great one, but I think this one looks alright. It varies the red color based on the hour, the green based on the minutes and the blue based on the seconds, though it tweens a lot so that the transition is more smooth. I hope you like it!

Hy flow macros.

2015-01-17T23:46:00.000+00:00

While working on my new web framework Horn, written in Hy of course, I found myself lacking some flow controls. So I just wrote some macros!

;; Additional flow macros

(defmacro/g! guard [&rest args]
  (setv g!cond (car args))
  (setv g!body (car (cdr args)))
  (setv g!rest (cdr (cdr args)))
  (if g!rest
  `(if ~g!cond
       ~g!body
       (guard ~@g!rest))
  `(if ~g!cond
       ~g!body)))

(defmacro/g! switch [variable &rest args]
  (setv g!comp (car args))
  (setv g!body (car (cdr args)))
  (setv g!rest (cdr (cdr args)))
  (setv g!cond `(~(car g!comp) ~variable ~@(cdr g!comp)))
  (if g!rest
      (if (cdr g!rest)
        `(if ~g!cond ~g!body (switch ~variable ~@g!rest))
        `(if  ~g!cond ~g!body ~@g!rest))
      `(if  ~g!cond ~g!body)))

As you can see, switch is basically just a guard statement, but with the original variable playing a role in every comparison, and with an additional else clause (since guard can only do that with a True).
It's amazing how powerful macros are, and I'm really starting to like what I can do with them. I've already submitted these to hy.contrib, and I hope they get accepted. Try some Hy!

Framed theorems in Latex

2015-01-13T17:01:00.003+00:00

I just added framed theorems to my Latex repertoire. I've been using amsthm for marking theorems for a long time, but since I encountered notes that had colored frames around the theorems, I decided that I'd add them to my latex header file. The part of the header file that relates to theorems is now is thus:

\usepackage{amsthm}
\usepackage[framemethod=tikz]{mdframed}
\renewcommand{\qedsymbol}{\textbf{Q.E.D}}

\mdfdefinestyle{theoremstyle}{%
roundcorner=5pt, % round corners, makes it friendlier
leftmargin=1pt, rightmargin=1pt, % this helps with box warnings
hidealllines=true, % even friendlier
align = center, %
}

\theoremstyle{plain}
\newtheorem*{setn}{Setning}
\newtheorem*{hsetn}{Hjálparsetning}

\theoremstyle{definition}
\newtheorem*{skgr}{Skilgreining}
\newtheorem*{daemi}{Dæmi}
\newtheorem*{frumsenda}{Frumsenda}
\newtheorem*{lausn}{Lausn}


\theoremstyle{remark}
\newtheorem*{ath}{Athugasemd}
\newtheorem*{innsk}{Innskot}

\surroundwithmdframed[style=theoremstyle,backgroundcolor = green!20]{skgr}
\surroundwithmdframed[style=theoremstyle,backgroundcolor=blue!10]{setn}
\surroundwithmdframed[style=theoremstyle,backgroundcolor = orange!20]{daemi}
\surroundwithmdframed[style=theoremstyle,backgroundcolor = red!20]{ath}

(All my notes are in Icelandic, of course, This allows me to mark my theorems, my definitions, remarks and examples specially in the TeX, and to spot them easily, which is a lot of help when using the notes in open book exams.
First I tried using mdtheorem and newmdtheoremenv, but neihter would give me what I want (couldn't get it to be unnumbered without ntheorem, and that messed up the amsthm,... etc), so the ultimate solution was just to not use the built in features of mdtheorem, and just saying directly what I wanted (a colored box around my theorems). I hope this is useful to others.

Proper tail recursion in Python and Hy

2014-12-21T17:32:00.000+00:00

I recently came across a new language, Hy. It is a Lisp dialect of Python! This means that I can finally start programming as I want in a functional language, Lisp, and not have to worry about whether others can use my code or whether I hit a snag that I can't figure out in lisp, as I can always drop back down to Python if necessary.
Anyways, since it is a Lisp dialect, I wished that it had proper tail recursion, as I utilize tail recursion a lot when programming in Lisp, and hitting a maximum recursion depth exception is quite common for me. As proper tail recursion is missing in Python, I first had to implement tail recursion in Python . I did this using a decorator and an exception, which allows me to bail out of a function without returning anything, and the decorator tries to return from the function and catches these TailCall exceptions, and handles them so that it all works. This is probably a lot slower way of doing it than having it implemented in the interpreter itself, but seeing as you gain instead power to go much deeper in recursion, I think it is a fair trade-off.
The next step was implementing the decorator and exception in Hy. The tail recursion decorator and exception in Hy is a bit awkward, but works well enough.
The final step was implementing it in Hy itself, and I now have a pending pull request for the change. The implementation adds a new import,

(import [__future__ [TailRec]])

which the Hy compiler recognizes and turns on tail recursion during the compilation. This adds the decorator around every function that uses tail recursion, and switches the return statements for raising of the TailCall exception. This effectively gives us proper tail recursion in Hy!
This allows us to do things like:

    (defn tcodd [n]
      (if (= n 0)
          False
          (tceven (- n 1))))
    (defn tceven [n] 
      (if (= n 0)
          True
          (tcodd (- n 1))))

    (print (tceven 1000))

and

(defn fact [n]
  (defn facthelper [n acc]
    (if (= n 0)
        acc
        (facthelper (- n 1) (* n acc))))
    (facthelper n 1))
(print (fact 1000))

without ever hitting the recursion depth exceeded exception! Woo!
Here's hoping that it makes it into Hy!

Hy <-> Python Interop

2014-12-06T17:18:00.002+00:00

I added Hy <-> Python Interop documentation to the Hy documentation today! Best part of open source is that if you find something missing, you can just add it!

Hy <-> Python interop

By importing Hy, you can use Hy directly from Python!
If you save the following in greetings.hy:

(defn greet [name] (print "hello from hy," name))

Then you can use it directly from python, by importing hy before importing the module. In Python:

import hy
import greetings

greetings.greet("Foo")

You can also declare a function in python (or even a class!) and use it in Hy!
If you save the following in greetings.py in Python:

def greet(name):
    print("hello, %s" % (name))

You can use it in Hy:

(import greetings)
(.greet greetings "foo")

To use keyword arguments, you can use in greetings.py:

def greet(name, title="Sir"):
    print("Greetings, %s %s" % (title,name))

and then in Hy:

(import greetings)
(.greet greetings "Foo")
(.greet greetings "Foo" "Darth")
(apply (. greetings greet) ["Foo"] {"title" "Lord"})

Which would output:

Greetings, Sir Foo

Greetings, Darth Foo

Greetings, Lord Foo

Simple as that! Now keep on the Hy life!

A neat little result.

2014-02-15T19:48:00.001+00:00

While going over some homework as a TA in computer science 2 at the University of Iceland, I noticed something I did not know.

We already know that (assuming integer division) that
\[\left( \frac{x}{{10}^i} \right) \mod 10 \]

gives us the $(n-i)$-th digit of a number ($n =\left\lfloor{\log_{10}(x)} \right\rfloor $, and $ i = 0 $ gives you the last digit) when counting in a decimal system. But going over the homework batch where the students were supposed to implement radix sort, I noticed that

\[ \frac{x \mod {10}^{i+1}}{{10}^i} \]

gives you the $i$-th digit (where 0 gives you the first)! Pretty cool!

I'm not going to prove this, as I have far to little experience with integer division and the modulus operation, but it seems to work, judging by that my students queues all turn out sorted.

Orbital Mechanics

2013-11-21T02:25:00.001+00:00

This past few weeks I've been working on a game in Computer Game Programming, Jerbal Space Program.

You design a space ship, and then you fly around in it, trying to land on the moon, or what have you. It's a pretty open sandbox game.

During it's development, I had to dive into orbital mechanics, to figure out the orbit of the spaceship, and then to render that orbit.

I though it was pretty neat, but it was hard to figure out from wikipedia, so I thought I'd write a post about it.

Lets dive into the function:

Ship.prototype.updateOrbit = function() {
    //Calculate orbit from orbital state vectors
    //Get the primary body the ship is orbiting
    var terr = entityManager.getTerrain(this.cx,this.cy);
    
    //One focus is in the center of the primary body 
    var focus = terr.center;
    var M = terr.mass;

    //Mu in the equations
    var mu = consts.G*(M+this.mass)
    
    //The posistion and velocity vectors.
    //Note that posistion is relative to the focus,
    //But the velocity is just the current velocity of the ship
    var r = util.vecMinus(this.center,focus)
    var v = [this.velX,this.velY];

    //Calculate the orbit specific energy, and from that we find the
    //semi-major axis. Note that this makes sense, as the semi major axis
    //basically tells us how high we'll go.
    var speed = this.getSpeed(); 
    var eng = (speed*speed)/2 - (mu/util.lengthOfVector(r));
    var a = -mu/(2*eng);
    
    //Calculate the eccentricity vector, and from that the eccentricity
    var tripleprod = util.tripleProduct(v,r,v);
    var vtimeshovermu = util.mulVecByScalar(1/mu,tripleprod); 
    var unitr = util.normalizeVector(r)
    var eccVec = util.vecMinus(vtimeshovermu,unitr);
    var ecc = util.lengthOfVector(eccVec);
    
    //ae is the distance from the center to a;
    var ae = a*ecc;
    //semi minor axis

    var b = a*Math.sqrt(1-ecc*ecc);
    //Find the center from the distance
    var cen = [f[0]-ae,f[1]];
    
    //Here we find the rotation of the eccentricity,
    //which tells us where the orbit is from the focus
    var angl = util.angleOfVector(eccVec);

    //rotate the center around the focus according to the angle
    cen = util.rotatePointAroundPoint(cen,angl,focus[0],focus[1]);

    //Set the properties of the orbit
    this.orbit = [cen[0], cen[1],a,b,angl,focus[0],focus[1]];
}

Now, using this we can plot our ellipse, knowing the center, and the angle of it. And it works, just zoom far enough out in the game, and take off! Happy flying!

Function for quick adding tasks or events to google calendar.

2013-10-21T18:10:00.001+00:00

I have written a function so that you can quick add tasks as well as events to google calendar, using Google script.


"use strict";
/*
01234567890123456789012345678901234567890123456789012345678901234567890123456789
*/
/*
 * @author Matthias Pall Gissurarson
 * @usage quickAddTaskOrEventFromString(quickadd);
 * @param quickadd A String describing the event to quickadd
 */
function quickAddTaskOrEventFromString(quickadd) {
  //Add a task if the string includes " due ", otherwise add an event.
  if(quickadd.indexOf(" due ") !== -1){
    //Use the already implemented quickAdd to create an event.
    var event = CalendarApp.createEventFromDescription(quickadd);
    //This event gets automatically added to the users calendar, remove it.
    event.deleteEvent();

    /*
    Create a new task, and have it have the same properties as the event.
    Tasks don't have dueTime as of now, so we add that to the note of the task.
    Also add the events location and description, these are often empty.
    */
    var task = Tasks.newTask();
    task.setDue(event.getStartTime().toISOString());
    task.setTitle(event.getTitle());

    task.setNotes([event.getStartTime().toString(),
                   event.getLocation(),
                   event.getDescription()].join("\n"));

    //Add to the users default tasklist.
    Tasks.Tasks.insert(task,'@default');
  } else {

    //Add the event as normal
    CalendarApp.createEventFromDescription(quickadd);
  } 
}

function main() {
  var s = "Homework due tomorrow";
  var e = quickAddTaskOrEventFromString(s);
}

This function takes in a string, and if it contains " due ", it creates a task instead of an event on the default task list. Might this get implemented in the actual calendar?
I have posted a topic for this on the Google product forums. Let's see what happens.

Markdown blog posts via emacs/vim and pandoc

2013-06-10T16:50:00.001+00:00

Using Markdown on google blogs from the Commandline

As per the comment on my last post from Matthías Ragnarsson, I'm using pandoc to generate html from a md file, albeit I'm not using vim, but rather emacs (as setting up markdown-mode is simpler, and with evil, it's pretty much the same thing, only more easily extensible. It also fits better with the Unix philosophy of using external tools to do tasks, rather than hardcoding them into the program itself.

Google calendar from the desktop, and posting through vim

2013-06-08T21:13:00.001+00:00

Posting trough vim

Here I am, writing a blog post in vim. If this actually gets posted, I'll be pretty impressed, as this makes posting to the google blogs extremely simple to implelement via a server. The api program itself is just a python program, so porting the functionality over to haskell shouldn't be hard at all. I might even make it and put it on hackage. It'd be neat to have a package there!

Anyway, I hope this test works, as it'll make code examples way simpler.

Google calendar on the desktop

I recently made some commits so that it can display arbitrary colors in conky, and used it to create a neat display of my google calendar on the desktop, and you can see a picture of it included in the pull.

My .gcalclirc is as follows:

--calendar
icetritlo@gmail.com
--military
--monday
#Tomorrow-Night Palette
--conky_color0
    #282A2E
--conky_color8
    #373B41 
--conky_color1
    #A54242 
--conky_color9
    #CC6666 
--conky_color2
    #8C9440 
--conky_color10
    #B5BD68 
--conky_color3
    #F0C674 
--conky_color11
    #DE935F 
--conky_color4
    #5F819D 
--conky_color12
    #81A2BE 
--conky_color5
    #85678F 
--conky_color13
    #B294BB 
--conky_color6
    #5E8D87 
--conky_color14
    #8ABEB7 
--conky_color7
    #707880 
--conky_color15
    #F0C673 

#Viljum auka vidd ef a ad vera a isl
#--locale
#is_IS.UTF-8
#-w
#12

I have that last part if I should want to have the dates and day names in Icelandic, but as neither are capitalized (correct in the middle of a sentence, but not standalone), and the english version suits me fine, I don't think I'll bother fixing it.

[Edit: Rewrote this post in markdown, and used pandoc to translate it into html, as per the comment below. N.B. you need my fork of gcalcli for this to work, as the --conky_color options were added by me.]

Using GoogleCL to post from the terminal

2013-06-05T18:11:00.001+00:00

I'm really just testing out using googleCl to post from my terminal to the blog. As simple as pacman -S googlecl, then authenticate via oauth (almost totally automatic, just enter your username and password in the browser window, grant access and done), and then $ google blogger post etc. Very basic. I wonder if I can post a text file....

Using xmobar to display rcirc status from emacs

2013-04-20T16:45:00.001+00:00

I use the emacs rcirc as my main irc client, and via BitlBee, facebook and skype chat. I use XMonad as my window manager, and xmobar as my display bar. Today I added the rcirc status line to my xmobar, so that I can see if I have new messages on any channels/facebook chat/skype. I wrote a short bash scriptlet that I execute in xmobar with

Run Com "~/.scritpstouse/rcircActivity" [] "rcirc" 100

the script is as follows:

#!/usr/bin/env bash
if emacsclient -e rcirc-activity-string > rcirc-string;then
    if ircstr=$(cat rcirc-string | tr '"' '\n' | grep '\[');then
        echo "<fc=#00ff00>"$ircstr"</fc>"
    else
        echo "<fc=#0000ff>[]</fc>"
    fi
else
    echo "<fc=#ff0000>[]</fc>"
fi

This contacts my running emacs server and asks for the status string, and then displays it. I'd have it in the .xmobarrc, but it doesn't handle escaped " so well. If my server isn't running or rcirc isn't, there is no field that contains [, so the output will be empty and my xmobar will just have a few spaces. The echos give me different colors on the xmobar based on what happened, green and the status if rcirc on, blue if emacs on but rcirc not, and red if emacs turned off. Try it!

[Edit: I've decided to try and use erc instead. The command is almost the same (the ircActivity), but the if clause is replaced with:
i
f ercBuffers=$(emacsclient -e "(if (functionp erc-track-shorten-function) (funcall erc-track-shorten-function (mapcar 'buffer-name (mapcar 'car erc-modified-channels-alist))) (nil))");then
    if ircstr=$(echo ${ercBuffers:1:${#ercBuffers}-2} | tr ' ' ',' | tr -d '"');then
        echo "<fc=#00ff00>["$ircstr"]</fc>"

A little more complicated, but it works, and I believe erc is more feature rich.]

I'll later try to explain my xmonad config, and include the (current) file. It handles everything for me, from handling my workpaces, windows etc.. to changing my keyboardlayout and handling my media keys. It rocks!

The MIT License

2013-02-03T22:43:00.002+00:00

When I make code publicly available, I usually do it under the MIT License. Why? Because it is a so called copyfree license, which, in contrast to copyright, merely states that anyone is free to use the provided code, if they include the license (and thus preserving my name in the codebase). It is as follows:

Copyright (C) <year> <copyright holders>

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

This, in contrast to copyright, does not restrict use of my code in other work, and in contrast to copyleft, does not force them to apply a specific license to their own code. It is thus a true free software license, allowing anyone to use my ideas for free - as long as they acknowledge my participation by including the license. Thus I enrich society by showing more examples of code, maybe help someone out on the project, and gain better reputation - instead of burdening it with pointless legal battles about something no one can really own. If you ever give out any code, use the MIT License, or at least a copyfree license.

[Edit 2013-04-24: After reading tldr;legal, I've decided that the GPL is actually a better license, by making more software free as in freedom. I have thus changed most of my projects to the GPL, and I recommend that you read up on tldr;legal and decide for yourself what license fits your project best. I hope that you'll choose the GPL, though anyone should of course be free to do with their work as they please.]

Errata for "A note on the Icelandic crash from an amateur Austrian perspective".

2012-11-01T00:49:00.000+00:00

After receiving some comments on my previous post, I've decided to update it with some errata, and just leave the post as it currently is. The following is verbatim from a comment by user herbert_spencer on reddit.com:

>busts are mainly caused by low interest rates.

It may be more accurate to say that they are caused by unsustainable investments because of *artificially* low interest rates.

> Due to the large size of the Icelandic banks (among other things), the belief in Icelandic Krona was high, causing it to be seemingly overvalued.

The fact that that the CBI said it would act as a lender of last resort and that the IMF was believed to have the capability to provide stability seems more important than the size of the banking system (which was albeit probably oversized) to the proliferation of currency mismatching.

>Central Bank of Iceland, through the Floating exchange rate policy raised the exchange rate.

The CBI does not determine the exchange rate directly. The fact that the krona had a floating rate means that it can fluctuate on the market. There is the issue of foreign currencies having lower interest rates than the krona and the consequent currency mismatching because of the implicit guarantee of bailout from the IMF.

> They might have tried to offer the krona undervalued, and then foreign currency would have flowed into the Central Banks stash, as always happens between good money and bad money, for all would have wanted to get their hands on the krona instead of the foreign currency, seeing as it was seen as being better.

Again, a floating exchange rate does not allow the legal undervaluing or overvaluing of currencies. The state may however, as Iceland did following the crash of the krona, limit the use of foreign exchange.

> This enabled Icelanders to get pretty cheap loans

Its not so much the value of the currency that allowed this as the easy monetary policy pursued by the ICB along with the low worldwide interest rates. Short term borrowing expanded as those rates remained low, which, in conjunction with increased long term investment created maturity mismatching (classic Austrian malinvestment) during the boom period.

> for various items, and was used to buy cars etc.

It is also important to remember, and perhaps mention that the credit expansion was not limited to loans for purchases of consumer goods but also in industry and capital goods (and international business). This is where the malinvestment comes into play.

>The price of housing was also artificially high

It may be good to explain the causal relation between the monetary policy and housing prices.

>Then, when the Icelandic banks fell, due to being in a "liquidity trap"

The Keynesian notion of a liquidity trap is questionable and not exactly the cause of the bank crash. It is important to note the difference between the liquidity crisis we saw, where the ICB had lent to insolvent banks (and to the government, which was insolvent). This is where the currency mismatching came back to haunt the ICB. Since debt was owed in foreign currency, there could be no bailout.

>this of course raised the cost of capital to even higher levels than it should have been.

The bust merely reveals the malinvestment.

>The belief in the Icelandic Krona fell, and thus the exchange rate set by the Central Bank was too high, causing an outflow of foreign currency, as it was now determined as being overvalued, and now no one wanted the Icelandic Krona. They then lowered the exchange rate, and thus the foreign currency loans which so many thought were so cheap turned out to be not so cheap at all, merely a fluke.

Again, the exchange rate is not set but is determined by the foreign exchange market. When the bust reared its ugly head in Iceland, and bankruptcy ensued, faith in the krona collapsed, people tried to sell kronur for foreign currency, and its exchange rate naturally collapsed in consequence.

>How could the banks grow so large?
Also, it is important to ask how the banks could make such bad loans.

>We could start by going onto a gold standard, or some other standard in which the value of the currency is based on some commodity.

While it would definitely be an improvement, a denationalized currency may be even better from an Austrian perspective.

>It is a hassle to dig up more gold (certainly more than just to print more money/issue government bonds)

If gold money is mined (on the market. If done by governments, then yes, there is still a problem but the state would probably rather resort to debasing the currency than to mine) to make money, then it is not even inherently a problem. The mining entrepreneur is acting as an arbitrageur since he realized people value gold more than anything else those miners (and the mining equipment) could be doing.

End verbatim.

As I've previously stated, I'm still studying Austrian economics, and many of these points highlight some of my misunderstandings. I believe that reading the book Deep Freeze by Phillip Bagus will further clarify this, and I hope to make another post after having read said book.

A note on the Icelandic crash from an amateur Austrian perspective.

2012-10-10T18:58:00.000+00:00

[Disclaimer: I am not an authority on these matters, and there may be mechanics to which I am oblivious at play. You should by all means try to come to your own conclusions, rather than blindly trusting something on the internet.]

[Edit: This was posted on reddit, and after having received some feedback, there are some parts of this note which are wrong. I'll make a later post that will serve as errata for this post later.]

By ABCT, Austrian Business Cycle Theory, busts are mainly caused by low interest rates. We see the phenomenon here in Iceland, when Icelanders could borrow money in the form of foreign currency. Due to the large size of the Icelandic banks (among other things), the belief in Icelandic Krona was high, causing it to be seemingly overvalued.

This increased demand for the krona, and responding to this, the Central Bank of Iceland, through the Floating exchange rate policy raised the exchange rate. They might have tried to offer the krona undervalued, and then foreign currency would have flowed into the Central Banks stash, as always happens between good money and bad money, for all would have wanted to get their hands on the krona instead of the foreign currency, seeing as it was seen as being better.

This enabled Icelanders to get pretty cheap loans for various items, and was used to buy cars etc. The price of housing was also artificially high, causing many entrepreneurs to go into housing construction, trapping capital in projects in which there was not as much demand as it seemed.

Then, when the Icelandic banks fell, due to being in a "liquidity trap", this of course raised the cost of capital to even higher levels than it should have been. When capital was now more expensive, the nations companies could not delve into projects they had planned, and many had to stop existing projects, like the famous Harpa, and the building of the University of Reykjavik. The belief in the Icelandic Krona fell, and thus the exchange rate set by the Central Bank was too high, causing an outflow of foreign currency, as it was now determined as being overvalued, and now no one wanted the Icelandic Krona. They then lowered the exchange rate, and thus the foreign currency loans which so many thought were so cheap turned out to be not so cheap at all, merely a fluke.

But why did this happen? How could the banks grow so large? Well, for one thing, they can count on getting bailouts if they over extend themselves, causing them to take bigger risks. When the Icelandic banks were originally privatized, the Icelandic State guaranteed some portion of the deposits, thus leaving even less worries for those in charge to having to meet their obligations, if things should ever go wrong.

So what is the lesson here? How can we prevent this from happening again?

Well, we could start by going onto a gold standard, or some other standard in which the value of the currency is based on some commodity (though not many commodities, as this would fix the exchange rate between them). Gold is seen as a pretty good commodity to base this on, for there seems always to be demand for gold, it is a hassle to dig up more gold (certainly more than just to print more money/issue government bonds), and as it does not corrode, it does not decrease in value. It is also almost universally acknowledged that gold is valuable so people would accept gold as an exchange for other commodities.

This would stifle inflation, as it is caused mainly by more money entering the system, and through the gold standard this becomes hard. It also helps people pick up the notion that we have an economy because of scarce resources, and to actually raise prices of every thing (that is demand more resources for everything), there must be more resources to demand. Demand is caused by, as I've gone into before, people having supply and wanting to exchange it for something else. More demand for everything would mean that people had more supply of everything to demand for, and thus the problem would resolve itself.

Another step would be to not bailout banks, and letting the market actually control itself. Removing the safety net of guaranteeing the deposits would also force people to evaluate whether they trust the bank to store their money, and as they'd be on a gold standard, they wouldn't actually be losing money to inflation by keeping it at home. If they want to get interests, they will have to give their money to the banks, and face the fact that if you want your money to make money for you, you'll have to risk losing some of the money.

Not allowing the banks to borrow out their depositors money except when explicitly allowed to do so would also be a step, for if they have a deal with every depositor that they'll give them their money back at any time, they are actually committing fraud the moment when they can't pay all back at once. Don't worry though, they would still be able to loan out money, though this would have to be on money that people put into locked accounts, say for three months, and the bank could then loan out the money for those three months and pay them back after that time, without having committed fraud.

All this would create a much stabler banking system, which wouldn't have to rely on bailouts time and time again to be functional, nor having it committing fraud just to meet their expected obligations. With a stable banking system, the market could function as it should and inflation would be less.

Though I'm by no means a fan, I'd like to end this note by quoting Keynes via Wikipedia, on how the government can use inflation to confiscate wealth from the citizen, for he seems to have gotten this one right:

"John Maynard Keynes, who had argued against such a gold standard, proposed to put the power to print money in the hands of the [then] privately owned Bank of England. Keynes, in warning about the menaces of inflation, said, "By a continuous process of inflation, governments can confiscate, secretly and unobserved, an important part of the wealth of their citizens. By this method, they not only confiscate, but they confiscate arbitrarily; and while the process impoverishes many, it actually enriches some"." - Wikipedia: Gold standard

This turned out a bit longer than I anticipated (I actually removed "short" from the title), but I hope it leaves you a bit more understanding of the crash and how we could break the cycle. If you are interested in more, I recommend What Has Government Done to Our Money? by Murray N. Rothbard, available for purchase or free at the link provided.

tl;dr: Busts are caused by over expansion of credit. By limiting the possibility of this over-expansion we might be able to break the boom and bust cycle.

P.s.:
If you spot any error, feel free to notify me so I can rectify it.

Proposal for a 3D screen.

2012-10-04T00:26:00.002+00:00

This paste from Markus Persson (aka. Notch) got me thinking on how we could create a real life 3-D screen. Now, this has probably already been figured out before, but here is my proposal:

Have n^3 little translucent cube each with a built in radio/Wi-Fi/Bluetooth receiver (preferably translucent too) and LED light. Assemble them into a cube, and ta-da, you have a 3-D screen that is n pixels on each side. I think the main challenge here would be to a) create the transparent receivers/lights and b) make them small enough so that a high resolution screen could be built without it being too big. Then, one could use Notch's standard to control the screen, up to 1000 pixels, but it could of course be easily extended further. I think it would be pretty neat, especially for plotting various 3-D functions, and just general displaying of designs, many of which are already drawn up in 3-D. This might also help designers realize their designs better. I think the possibility of this warrants further investigation.

Fast multiplication using bitshift and addition.

2012-09-11T00:31:00.002+00:00

I have realized a method which one can use to multiply two numbers faster than using only addition, by utilizing bitshift in addition to addition. By using the same idea as the fast fast power adding, but utilizing operators of a lower degree, so instead of using powers and multiplication, we are using multiplication and addition.

Now, when multiplying by a power of two in a binary environment, we are simply preforming a number of bitshifts to the left equal to the power of two, so this is an efficient operation. To get the multiplication of a number which is not a power of two, we can simply go over the bits in the number we are multiplying with, and adding up the bitshifts of each power of two times the number where the bit is equal to one.

I think it is best to describe this with an example, e.g.:
Let us say we're multiplying 5 by 3, that is 0101 and 0011. Now, we go over the number and find that in 3, there are bits in slot 0 and 1 (enumerated from the left in a little-endian system such as this), so we find that
5*3 = (0101*0011) = (1010 + 0101) = 1111 = 15.
And all this pretty efficiently!

We can use this to efficiently compute multiplication, and we can also use this to efficiently compute powers. Might we also use it to efficiently compute addition, using addition and successors? Or even higher order operators? Probably!

Update: By efficiently, I mean that it minimizes the amount of additions needed to be done, in favor of the (I believe) computationally simpler bitshift operation, reducing the additions to floor(log_2(N)), where N is the lower number being multiplied with, if preformed correctly.

What is computation?

2012-08-20T16:44:00.001+00:00

Computation has many forms, but they all lead to the same result, and they are thus all equally valid. One of those forms is simplification, as in reduction. This is what allows lambda-calculus to compute. When I state the expression x + 5 = 8, the answer is already there. Every bit of information needed to "solve for x" is already embedded in the statement itself. Thus we can simplify, reduce it, to the statement x = 3. This makes it more clearer what x is, and is thus simplified.

That, in its essence, is what computation is. It's the simplification of statements into simpler statements. It is shown in languages such as Haskell, that one can do very powerful things without manipulating variables, by using just the reduction of statements into their simpler forms to compute. It has been shown that lambda-calculus is Turing complete, and can thus compute all efficiently computable expressions.

But what about NP problems? NP problems are problems that cannot be computed in polynomial time as of what we know now. It has however, not been proven that NP =/= P nor that NP = P, so we don't know whether they can or cannot be computed in P time. But as we have seen, they contain all the information needed to solve them, we just don't know any better ways than to try all the different combinations. But they are computable.

Say's Law

2012-08-11T17:05:00.004+00:00

Say's law is a fundamental law of economics, which Lord John M. Keynes claims to have refuted. In his work, The General Theory of Employment, Interest and Money, he states Say's law as "supply creates it's own demand". This statement however, leads to a wrong interpretation of the law. The true law is not that "supply creates it's own demand", but rather that to demand, one must supply, for how would one trade if one did not have anything to trade with? So a true statement of the law would be "one's own supply creates one's own demand", for what you can demand in trade is a function of what you can supply to trade with.

What entrepreneurs give back to society

2012-08-04T23:14:00.000+00:00

The trend when justifying tax on production, is that the framework that society provides made the profits that the entrepreneurs utilizing the resource got for their trouble possible, and thus it is only natural that the entrepreneurs give something back to society.

What is often forgotten is that these entrepreneurs have already given back to society. If they have made enough of the economic good so as if to satisfy their own demand, they lower the price by lowering the general demand for the good. If they have surplus and trade it for other goods, they have increased the supply, thus further reducing the price of that good. Both these effects lead to a lower price of the good, and thus people have easier access to it.

One could argue that this portion of the price which the entrepreneurial outfit lowers is what the entrepreneur gives back to society, and does this through the market. Whether this portion is enough, is another issue. But let it not be said that the entrepreneurs give nothing back to society.

Intuitive definitions of operations

2012-08-04T12:48:00.003+00:00

Disclaimer: All of this is pure speculation, and should not be take seriously. Inspiration taken from the Wikipedia articles on the Ackermann function and Hyperoperations.

It's interesting to note how the common operations in mathematics are easy to define from one another, on the set of positive natural numbers. The only thing we need for addition, multiplication and exponentiation is simply a function which gives us the next member of the natural number set, e.g. the next integer. We'll call this function S(x) (S for successor).

Now, onto the definitions:
S(x) is the function which maps x, a member of a set, to the next member of that set.
We can define Add(a,b)* as S(S(S(...S(a)...), where the S function is applied b times.
Then Mul(a,b) ** is Add(a,Add(a,...Add(a,a)..) where Add is applied b times,
And Exp(a,b)*** is Mul(a,Mul(a,...Mul(a,a)..) where Mul is applied b times.

Simple as that!****

From this we can see, that if you want a machine that's able to preform addition, multiplication and exponentiation on the positive natural numbers, it is sufficient that it can apply the successor function to the members, and that it can call functions recursively.

If we'd want to define subtraction, we'd simply swap the successor function for the predecessor function P. The multiplication function would then become a multiplication of a negative and a positive number, and the exponentiation function would be an exponentiation of a negative number. If we define the (-) sign, when joined with a as this operation (the swapping of S for P), we now have negative numbers (note however that b must remain a positive natural number, but a can be any integer).

It would be interesting to see what happens if we use this definition on other sets, and might be a cause for inquiry later.

Notes:

* Usually written as a+b
** Usually written as a*b
*** Usually written as a^b (not to be confused with the natural exponent)
**** We could of course logically continue this process, and get operations where OP_n(a,b) is OP_(n-1) (a,OP_(n-1)(a,...OP_(n-1)(a,a)..) where OP_(n-1) is applied b times.

p.s. If you spot an error, point it out!

The Dawn of a New Blog

2012-08-04T09:08:00.002+00:00

I've decided to publish some of my thoughts and tales, for whomever might be interested in reading them.

The first thing I'd like to do is link to my Github profile, where many of my programming projects will be published. Currently, it only has two, a program which simulates Conway's Game of Life (and other Life-like cellular automata), and a program which efficiently calculates all 2-parasitic numbers less than N in O(log_10(N)) time.

Recently, I've been taking a Standford Cryptography course through Coursera, which has involved some programming, but in order to encourage others to figure it out themselves, I've decided not to share those programs.

I hope you enjoy the tales!