I’ve written a very simple ASCII table printer for python.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  def print_table(lines, separate_head=True):
      """Prints a formatted table given a 2 dimensional array"""
      #Count the column width
      widths = []
      for line in lines:
          for i,size in enumerate([len(x) for x in line]):
              while i >= len(widths):
                  widths.append(0)
              if size > widths[i]:
                  widths[i] = size

      #Generate the format string to pad the columns
      print_string = ""
      for i,width in enumerate(widths):
          print_string += "{" + str(i) + ":" + str(width) + "} | "
      if (len(print_string) == 0):
          return
      print_string = print_string[:-3]

      #Print the actual data
      for i,line in enumerate(lines):
          print(print_string.format(*line))
          if (i == 0 and separate_head):
              print("-"*(sum(widths)+3*(len(widths)-1)))

1
2
3
4
5
6

  rows = []
  rows.append(("Name", "Age", "Gender"))
  rows.append(("Fred", "2", "Male"))
  rows.append(("Amy", "90", "Female"))
  rows.append(("Iguanas Are Lame", "97", "Male"))
  print_table(rows)

1
2
3
4
5

  Name             | Age | Gender
  -------------------------------
  Fred             | 2   | Male
  Amy              | 90  | Female
  Iguanas Are Lame | 97  | Male

If you’ve read me previous post An Argument Against the Cascade then you know I don’t like scripting languages. Scripting languages are inherently slow and has caused the market to flood with inept programmers who can’t handle pointers or manage their own memeory. That being said, there are times when scripting lanauges are important.

For example: I plan to add an in-game console window to my current project (like hitting ~ in source games). If I want to allow for any sort of complex behavior then I will need a scripting language. The route that so many people seem to take is writing their own scripting language. This is a plague that has gone on for far too long. As much as I hate scripting languages, I hate having to know the syntax to 50 scripting languages more. Instead, I plan to use Lua.

Don’t get me wrong, I have my issues with Lua. In Lua arrays tend to be indexed starting at 1 instead of 0. Classes don’t really exist, but rather are tables inheriting from meta-tables. And finally, worst of all, its not Lisp! So why then should we be using Lua? Its simple really:

1. Its under a BSD style license allowing it to be integrated into anything with almost no restrictions
2. Intgrating it with C/C++ is a breeze through the use of oolua or luabind.
3. If it can integrate with C/C++ it can integrate with almost anything else because most languages have bindings to C/C++
4. Lua is tiny, allowing it to be used almost anywhere with no significant cost

To put in perspective how tiny Lua is, heres an excerpt from their website:

Adding Lua to an application does not bloat it. The tarball for Lua
5.2.1, which contains source code and documentation, takes 245K
compressed and 960K uncompressed. The source contains around 20000
lines of C. Under Linux, the Lua interpreter built with all standard
Lua libraries takes 182K and the Lua library takes 243K.

A perfect real-life example of how this change can help is through CMake and Premake. CMake is a build system that has its own scripting language. It is often criticized for its syntax. Here is a mailing list therad to show just how ugly the syntax is.

Premake is instead built on top of lua. This allows me to use any knowledge I already have about Lua (syntax, how to write functions, how to concatenate strings, variable types, …) and apply it to my build system. This allows you to create a make file using a clean syntax without having to learn yet-another-language. Right now premake has not caught up to cmake in terms of features (for example, it is missing CPack functionality), but I am willing to put up with that for a much cleaner syntax and more direct control. I’ve even been toying with the idea of implementing “prepack” to make up for that shortcoming next time I have some time.

One may wonder why I don’t simply advocate using Lisp as the one true language since it is the purest form of elegance and the best scripting language ever made. The simple answer is that it is not embeddedable. There are few projects trying to get it embeddable and those projects either have far too many issues or are under a virus license like the GPL.

What is happening to the world of great code? Has anyone else noticed a trend towards scripting languages? At work I had to switch from a Java platform (Java is already horrible) to Javascript. At my college (RPI) the early computer science courses are switching from C++ to Python. Looking at the web, the Javascript world exploded over the past few years (remember when all you did with javascript was form validation?). Don’t get me wrong, Scripting languages have their place. I simply feel that scripting languages are more and more getting used to write entire applications instead of allowing your application to be extensible.

One argument for the diminishing quality of code was dubbed the Cascade of Attention Deficit Teenagers. The idea behind this is that new teenagers are constantly discovering open source projects and rewriting the modules in it so no progress is made since everyone spends all their time re-implementing the same functionality. While this can be a problem, its important to remember that reinventing the wheel isn’t always a bad thing. One of my major projects are Intel last year got taken over by a new intern this summer. He took the entire code base (around 10,000 lines) and ripped it apart. Through this process he managed to find multiple bugs and clean up sections of code that hadn’t been touched in a year. He then was able to build upon the cleaner code base and significantly improve its functionality and add a user interface that completely changes how people interact with the program.

This experience has taught me two important things:

1. Reinvent the wheel but don’t stop with a wheel, add something more to it.
2. Get multiple hands on a project, chances are someone out there is better than you at some aspect of your code.

In regards to #2, I want to point out that simply getting multiple eyes on a project is not enough. People can find bugs and suggest areas that need improvement but you will need someone else to radically redesign your code in a paradigm you have not considered.

Finally, in regards to the script languages: stop. Scripting languages are meant for making your program extensible or for rapid prototyping. Once you move beyond that programmers need to ditch their fear of pointers and move onto C/C++.

I recently re-wrote my entire portfolio website in Google Dart. Dart is a new programming language that is designed to replace javascript, although it also can run server-side allowing it to also replace technologies like PHP. Sadly, my web host doesn’t have Dart installed on their servers, so I was limited to just client-side code.

Since most browsers do not support Google Dart yet, Google Dart gets compiled into javascript through their compiler dartc frogc dart2js. This can then be run by any browser.

For this post I am not going to have any tutorials for using Dart; Those will follow later. Instead, I merely want to point out that my portfolio website is open source so feel free to browse through it and use the code to learn and build your own websites. I generate almost the entire website with Dart including managing browser history and asynchonously loading JSON data to populate fields. The code for my website is available at https://github.com/craftkiller/paphuscom.

Bitmaps are quite possibly the simplest image format we use today. They are supported on every platform and in every browser. Bitmaps suffer from one major shortcoming: They are uncompressed. Thankfully harddrive space has never been cheaper, so if you want simple image writing in your program without having to link an image library like libwebp or libpng then writing your own bitmaps is the way to go.

In this post I will attempt to explain the bitmap format. I also have written all the code you need, which will can be downloaded here.

1
2
3
4

  //                          Blue        
  //                       B     G     R  
  //                      |--------------|
  unsigned char data[] = {0xFF, 0x00, 0x00};

1
2
3
4

  //                          Blue                Purple
  //                       B     G     R      B    G     R
  //                      |--------------|  |--------------|
  unsigned char data[] = {0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF};

1
2
3
4

  //                          Blue                Purple
  //                       B     G     R      B    G     R     Padding
  //                      |--------------|  |--------------|  |--------|
  unsigned char data[] = {0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00};

1
2
3
4
5
6
7
8
9
10

  //                          Blue                Purple
  //                       B     G     R      B    G     R     Padding
  //                      |--------------|  |--------------|  |--------|
  unsigned char data[] = {0xFF, 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00,

  /*                          Red                  Green*/
  /*                       B     G     R      B    G     R     Padding*/
  /*                      |--------------|  |--------------|  |--------|*/
                          0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00
  };

1

  size_t bitmap_encode_rgb(const uint8_t* rgb, int width, int height, uint8_t** output);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  #include <cinttypes>
  #include <fstream>

  size_t bitmap_encode_rgb(const uint8_t* rgb, int width, int height, uint8_t** output);

  int main(int argc, char** argv)
  {
      //                      Red              Green
      //                |---------------| |--------------|
      uint8_t data[] = {0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00,
                        0x00, 0x00, 0xFF, 0xFF, 0x00, 0xFF};
      //                |--------------|  |--------------|
      //                     Blue              Purple
      uint8_t* output;
      size_t output_size = bitmap_encode_rgb(data, 2, 2, &output);

      std::ofstream file_output;
      file_output.open("output.bmp");
      file_output.write((const char*)output, output_size);
      file_output.close();

      delete [] output;
      return 0;
  }

1

  $CXX -std=c++11 bitmap.cpp main.cpp

On an earlier post I described a method for exporting Emacs Org-Mode to Octopress. The main feature that simply exporting to HTML lacked was syntax highlighting. The method from my old post sadly was unreliable so I went back to the drawing boards and now I have a far better solution.

First you will need to set up Octopress Following their instructions. I find that after cloning their repository and entering it I have to run these commands:

1
2
3
4
5
6
7
8
9

  #!/bin/sh
  #
  curl -L https://get.rvm.io | bash -s stable --ruby
  source ~/.rvm/scripts/rvm
  rvm install 1.9.2
  rvm rubygems latest
  gem install bundler
  bundle install
  rake install

1
2
3
4
5

  (defun save-then-publish ()
    (interactive)
    (save-buffer)
    (org-save-all-org-buffers)
    (org-publish-current-project))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

  (setq org-publish-project-alist
        '(("blog-org" .  (:base-directory "~/git/blog/source/org_posts/"
                                          :base-extension "org"
                                          :publishing-directory "~/git/blog/source/_posts/"
                                          :sub-superscript ""
                                          :recursive t
                                          :publishing-function org-publish-org-to-octopress
                                          :headline-levels 4
                                          :html-extension "markdown"
                                          :octopress-extension "markdown"
                                          :body-only t))
          ("blog-extra" . (:base-directory "~/git/blog/source/org_posts/"
                                           :publishing-directory "~/git/blog/source/"
                                           :base-extension "css\\|pdf\\|png\\|jpg\\|gif\\|svg"
                                           :publishing-function org-publish-attachment
                                           :recursive t
                                           :author nil
                                           ))
          ("blog" . (:components ("blog-org" "blog-extra")))
          ))

1
2
3
4
5
6
7
8
9
10
11
12
13

  ## -- Misc Configs -- ##

  public_dir      = "public"    # compiled site directory
  source_dir      = "source"    # source file directory
  blog_index_dir  = 'source'    # directory for your blog's index page (if you put your index in source/blog/index.html, set this to 'source/blog')
  deploy_dir      = "_deploy"   # deploy directory (for Github pages deployment)
  stash_dir       = "_stash"    # directory to stash posts for speedy generation
  posts_dir       = "_posts"    # directory for blog files
  org_posts_dir   = "org_posts"
  themes_dir      = ".themes"   # directory for blog files
  new_post_ext    = "org"  # default new post file extension when using the new_post task
  new_page_ext    = "org"  # default new page file extension when using the new_page task
  server_port     = "4000"      # port for preview server eg. localhost:4000

1
2
3
4
5
6
7
8
9

      post.puts "#+BEGIN_HTML"
      post.puts "---"
      post.puts "layout: post"
      post.puts "title: \"#{title.gsub(/&/,'&')}\""
      post.puts "date: #{Time.now.strftime('%Y-%m-%d %H:%M')}"
      post.puts "comments: true"
      post.puts "categories: "
      post.puts "---"
      post.puts "#+END_HTML"

1
2

  (add-to-list 'load-path "~/git/orgmode-octopress")
  (require 'org-octopress)

1
2
3
4
5

  cd blog
  rake "new_post[title]"
  mv source/_posts/2012-08-01-title.org source/org_posts/
  # I keep my posts in GIT so then I add it to the repo
  git add source/org_posts/2012-08-01-title.org

The main feature that I added was the ability to have syntax highlighted blocks. Right now this will only work with all lower-case begin_src end_src blocks. It supports options for :title :url and :urltext. If you would like to see an example of this, the source code to this post is located at http://blog.paphus.com/org_posts/2012-08-01-introducing-octopress-blogging-for-org-mode.org. If anyone wants to help improve the exporter please join me on github!

Finally, You may want to edit your .htaccess file to redirect image requests. I redirected all SVG image requests to the root directory so perma-links dont fail to access the images. You want to locate the .htaccess file in the source directory

1
2
3
4

  Options +FollowSymlinks
  RewriteEngine on
  RewriteBase /
  RewriteRule /([^/]+)\.(svg)$ /$1.$2 [R,L]

As projects grow bigger, name collisions become a hazard. Back in the old C days they had a static keyword that would restrict access to the function or variable to the file it was created in. This made is unaccessible to extern and allowed global variables of the same name to exist in other files. This can be a slight bit confusing since static variables in C++ mean that the value of the variable persists through multiple function calls or through multiple instances of a class, but luckily the C-style static keyword is deprecated.

In C++ to restrict variables to only be accessible from within the current file you simply need to create an unnamed namespace. To demonstrate this I created a file named child.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

  #include <iostream>

  using namespace std;

  namespace
  {
      void internal_function()
      {
          cout << "child: internal_function\n";
      }
  }

  void external_function()
  {
      cout << "child: external_function\n";
      internal_function();
  }

Now I can drive this function with a main.cpp which can have its own internal_function() without naming conflicts!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

  #include <iostream>

  using namespace std;

  void external_function();

  void internal_function()
  {
      cout << "main: internal_function\n";
  }

  int main(int argc, char** argv)
  {
      internal_function();
      external_function();
  }

1
2
3
4
5
6

  $ $CXX main.cpp child.cpp
  $ ./a.out
  main: internal_function
  child: external_function
  child: internal_function
  $ 

1
2
3
4
5
6
7
8
9
10
11
12
13
14

  #include <iostream>

  using namespace std;

  void internal_function()
  {
      cout << "child: internal_function\n";
  }

  void external_function()
  {
      cout << "child: external_function\n";
      internal_function();
  }

1
2
3
4
5
6

  $ $CXX main.cpp child.cpp
  ~/AppData/Local/Temp/child-688096.o:fake:(.text+0x50): multiple definition of `internal_function()'
  ~/AppData/Local/Temp/main-688094.o:fake:(.text+0x50): first defined here
  collect2: ld returned 1 exit status
  clang++: error: linker (via gcc) command failed with exit code 1 (use -v to see invocation)
  $ 

Recently I’ve been seeing a lot of code that accesses variables and functions that start with ::. I didn’t know what that meant, and information online seemed scant, so I decided to test it myself. Luckily, my first guess was right and it is a way to access the global namespace. One easy way to think about it is in Unix paths, if you start with a / it accesses the root the of the filesystem, whereas if you don’t then its a relative path starting from where you currently are in the folder structure.

To test this I created three files:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

  #include <iostream>
  #include "header.h"

  using namespace std;

  namespace a
  {
      void print_a()
      {
          cout << "a\n";
      }
  }

  int main(int argc, char** argv)
  {
      a::print_a();
      b::print_b_local();
      b::print_b_global();
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  #include <iostream>
  #include "header.h"

  using namespace std;

  namespace b
  {
      void print_b_global()
      {
          cout << "b ";
          ::a::print_a();
      }
      void print_b_local()
      {
          cout << "b ";
          a::print_a();
      }

      namespace a
      {
          void print_a()
          {
              cout << "b::a\n";
          }
      }
  }

1
2
3
4
5
6
7
8
9
10
11
12
13

  namespace a
  {
      void print_a();
  }
  namespace b
  {
      void print_b_global();
      void print_b_local();
      namespace a
      {
          void print_a();
      }
  }

1
2
3
4
5
6

  $ $CXX a.cpp b.cpp
  $ ./a.out
  a
  b b::a
  b a
  $ 

I recently came across an interesting feature to C++11: std::tie. One of the features I love about python is that you are able to return multiple values from a function. These get returned in a structure called a “Tuple”. Here is a basic example of what I mean:

1
2
3
4
5
6
7
8
9
10
11

  class rectangle:
      def __init__(self, width, height):
          self.width = width
          self.height = height

      def get_dimensions(self):
          return self.width, self.height

  r = rectangle(3,4)
  w, h = r.get_dimensions()
  print w,h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  #include <iostream>
  using std::cout;

  class rectangle
  {
    public:
      rectangle(int _width, int _height) : width(_width), height(_height) {}
      int width, height;

      void get_dimensions(int & _width, int & _height)
      {
          _width = width;
          _height = height;
      }
  };

  int main(int argc, char** argv)
  {
      rectangle r(3,4);
      int w,h;
      r.get_dimensions(w,h);
      cout << w << ' ' << h << '\n';
      return 0;
  }

Luckily C++11 has introduced tuple types and a way to return multiple values from a function. To use this all you need to do is return a tuple from a function, and then use std::tie to accept the return value. std::tie create its own tuple storing references to the variables it needs to throw the data into. Heres the same example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

  #include <tuple>
  #include <iostream>

  using std::tuple;
  using std::tie;
  using std::make_tuple;
  using std::cout;

  class rectangle
  {
    public:
      rectangle(int _width, int _height) : width(_width), height(_height) {}
      int width, height;

      tuple<int, int> get_dimensions() {return make_tuple(width, height);}
  };

  int main(int argc, char** argv)
  {
      rectangle r(3,4);
      int w,h;
      tie(w,h) = r.get_dimensions();
      cout << w << ' ' << h << '\n';
      return 0;
  }