Structura

gcc -Winline and --param name=value

2011-03-21T03:06:00.000-07:00

While tuning my language, Impulse, I found the gcc inline-optimization parameters. Look for --param name=value at the bottom of the page.

http://tigcc.ticalc.org/doc/comopts.html#SEC10

-Winline --param inline-unit-growth=10000 --param large-function-growth=10000
 --param max-inline-insns-single=10000

0m2.450s 40000000 'self' message sends with --param options
0m2.650s 40000000 'self' message sends without options

That's a 7.5% boost. While the binary is now twice as large, in my case the binary is still small - 100K stripped.

Kaffeine.js - A cleaned up JavaScript

2011-03-11T00:15:00.000-08:00

Well, I found one language pretty close to what I was looking for in a better JavaScript:

http://weepy.github.com/kaffeine/

Backwards compatible with JavaScript
Uses @foo to to get the "real" this.foo
Uses CPS folding to flatten callbacks
Multiline strings, which come in handy
for(n of [1, 2, 3]) array iteration
String interpolation: "#{foo} was here"
Implicit functions: (foo) { alert(foo); }
Pipe operator for chaining the first arg
Default arguments, optional call parens
Implicit return (nice with implicit funcs)

Out of those, I think callback unfolding and the pipe operator are the most interesting beyond adding some niceties:

  ok = stomach.save!()
  meal.complete = ok

translates to:

  stomach.save(function(ok) {
    meal.complete = ok
  })

and...

  result = input | fn args

translates to:

  result = __.fn.call(this, input, args)

C++ nested class that inherits parent

2011-03-11T00:10:00.000-08:00

Ever wanted to nest a class that inherits from its parent class? It can be done simply by using a forward declaration:

class Value {

 public:

    Value( Frame& frame );

    template <typename T> class Type;

};

template <typename T>
class Value::Type : public Value {
 
 public:
  
    Type( T& frame ) : Value( frame ) { }

    T& getFrame() { return get<T>(); }

};

I use it to make Impulse values more specific and type safe:

Value value;  // Could be 10, "foo", WhoKnowsWhat
Value::Type<Symbol> symbol;  // Must be a Symbol

Limited numeric types in C++

2011-03-07T00:14:00.000-08:00

I don't want random indicies to be passed to a custom array, so this is the closest thing I could think of. It basically creates a few static member variables, and doesn't allow you to create any more of those types by making the constructor private. The "explicit" is optional, but demonstrates how to disable implicit conversion.

Value foo( const Array& args )
{
    return args[Index::_0];  // Don't give me any int!
}

class Index {

 public:

    const size_t index() const { return _index; }

    static const Index _0;
    static const Index _1;
    static const Index _2;

 private:

    explicit Index( const size_t index ) : _index( index ) { }

    const size_t _index;

};

const Index Index::_0( 0 );
const Index Index::_1( 1 );
const Index Index::_2( 2 );

JavaScript Array Iteration

2011-02-22T01:11:00.001-08:00

JavaScript Array Iteration

LESS: CSS done right

2011-02-21T19:04:00.000-08:00

I wanted to start a new browser-based project out right - with tools to make me uber-productive. I found LESS, and will never turn back to plain CSS. Mighty as CSS3 is, LESS extends it with:

Variables
Mixins
Nesting
Math
Comments

Example:

.box {
  // Assign a variable
  @base: #f938ab;

  // Color functions
  color: saturate(@base, 5%);
  border-color: lighten(@base, 30%);

  // Same as .box div
  div {
    .box-shadow(0, 0, 5px, 0.4)
  }
}

http://lesscss.org/

The Joy of HTM5

2011-02-21T17:50:00.000-08:00

...when most browsers support it :)

.button:before {
  display: block;
  content: attr(label);
  border-top: 1px solid #ffffff;
}

<div class="button" label="Save"></div>

http://www.w3schools.com/html5/tag_input.asp

Visual perception

2011-01-28T22:28:00.000-08:00

I'm always fascinated (ok, maybe too strong of a word) by perceptual vs real things, such as how contrast and color of nearby objects can change your perception of other objects. Another example is when syntax is too orthoganal, it can be harder to visually parse:

def square-of (x :: <integer>) :: <integer>
  x * x
end

In this hypothetical language (resembling Dylan), x is an integer, and square-of returns an integer. Because both use "::", I find it harder to very quickly distinguish the arguments and the return type. If we use "=>" instead:

method square-of (x :: <integer>) => <integer>
  x * x
end

it's much clearer, at least to me. So sometimes being pure is not the best choice. I remember reading an article or web page about this in the past, but I don't remember the details.

Abusing Ruby Operators

2011-01-21T23:31:00.000-08:00

I've been looking at different ways to "pipe" objects, where the previous pipe object becomes the scope of the next. The allows you perform multiple operations on an object, then pass it on to the next pipe operation. For example (not a real language):

"Foo,Bar".split "," | first.upcase + last.downcase | reverse

The closest I could get in Ruby is this:

"Foo,Bar".split(",") --> { first.upcase + last.downcase } --> { reverse }

and the code to make this happen:

module Pipe
  def -( expr )
    alias :minus :-
  
    if expr.instance_of? Proc
      self.instance_eval( &expr )
    else
      minus( expr )
    end
  end
end

class String
  include Pipe
end

class Array
  include Pipe
end

I would never abuse the minus operator so badly though. Or would I :)

Mirroring git repositories

2011-01-19T15:27:00.000-08:00

I found it's easy to have both a codaset and github repository that point to the same local repository. In my local repo, I typed:

git remote add github git@githum.com:mikeaustin/impulse-language.git

Now I can do "git remote update" and pull from both, and "git push origin" and "git push github" to update both repositories.

pull/push from multiple remote locations
[stackoverflow.com]

Juice: JS Web Framework

2011-01-19T13:51:00.000-08:00

"Juice is a server-side web framework built around CommonJS modules and specifically the JSGI 0.3 proposal. Its an open-source stack released under the MIT license that comes bundled with its own development server and a javascript interpreter."

Lower barriers.

With your client-side and server-side code in the same language, your development won't hit as many communication blocks or gear changes.

Share code between client and server.

Common helpers and validation routines written only need writing once and can be used in your controllers, templates and client-side code.

Sounds like the right way to do it. http://juicejs.org/

Law and Order: The programming language

2011-01-17T23:39:00.000-08:00

Law and Order: The programming language

Language feature trends

2011-01-17T22:01:00.000-08:00

Some of the trends I've noticed while looking at new languages:

Parser combinators and parsing libraries
Actors/coroutines and concurrency
Prototype inheritance
Structural typing
Pattern matching
Domain Specific Languages
Breaking away from C syntax
Static type-checking in dynamic languages
Dynamic elements in statically typed languages
Minimalism

It's great news for me since I like all these. Well, I'm trying to like structural typing :)

Treetop: Expression parser

2011-01-17T21:06:00.000-08:00

"Treetop is a language for describing languages. Combining the elegance of Ruby with cutting-edge parsing expression grammars, it helps you analyze syntax with revolutionary ease."

grammar Arithmetic
  rule additive
    multitive ( '+' multitive )*
  end

  rule multitive
    primary ( [*/%] primary )*
  end

  rule primary
    '(' additive ')' / number
  end

  rule number
    '-'? [1-9] [0-9]*
  end
end

Treetop on Rubyforge.com

Conditionals via callable booleans

2011-01-17T00:45:00.000-08:00

I bumped into a language called "tofu" which has an interesting conditional concept:

(number < 0)(-1, 1)

or, in simplified terms:

true(-1, 1)

which translates to:

true ? -1 : 1

I'm not sure it's my favorite way to do it, but still an interesting concept.

Tofu Programming Language

Active Objects with Ruby & Revactor

2011-01-15T20:37:00.000-08:00

I wanted to try going back to basics by writing a MUD in Ruby. MUDs are simple, but are also good candidates for testing concurrency in a language. Handling multiple connections, persisting state, and handling events that happen asynchronously seems like a good job for Active Objects. Here's a simple implementation using Revactor:

#
# Revactor requires Ruby >= 1.9.0
#

require 'revactor'

class ActiveObject

  def initialize( klass )
    @actor = Actor.spawn( klass.new(), &method( :actor_run ) )
  end

  def actor_run( object )
    loop do
      Actor.receive do |filter|
        filter.when( Case[Symbol, Array] ) do |method_name, arguments|
          object.send( method_name, arguments )
        end
      end
    end
  end

  def method_missing( method_name, *arguments, &block )
    @actor << [method_name, arguments]
  end

end

class MudPlayer

  def foo( bar )
    puts bar
  end

end

actor = ActiveObject.new( MudPlayer )
actor.foo( 10 )
actor.foo( 20 )

Actor.reschedule()

The Visual 6502 in JavaScript

2011-01-09T17:49:00.000-08:00

JavaScript VM without the JavaScript?

2011-01-08T14:34:00.000-08:00

Why require JavaScript rather than supporting a standard browser virtual machine?

Question on stackoverflow.

Sony's 3D new HMD Prototype

2011-01-08T13:37:00.000-08:00

Hoping the next wave of VR glasses will be cheaper and have a higher resolution.

Microsoft's next generation Surface

2011-01-08T13:33:00.000-08:00

I don't know about you, but that image is a little disturbing :) The technology looks cool though.

CoffeeScript: JavaScript + Python?

2011-01-05T23:14:00.000-08:00

CoffeeScript:

yearsOld = max: 10, ida: 9, tim: 11

ages = for child, age of yearsOld
  child + " is " + age

JavaScript:

var age, ages, child, yearsOld;
yearsOld = {
  max: 10,
  ida: 9,
  tim: 11
};
ages = (function() {
  var _results;
  _results = [];
  for (child in yearsOld) {
    age = yearsOld[child];
    _results.push(child + " is " + age);
  }
  return _results;
})();

'nuf said.

Flot: JavaScript charting library

2011-01-05T14:40:00.000-08:00

JavaScript has its fair share of warts, but you can do some awesome things with it now that it's blazingly fast. I recently discovered the Flot charting library, which uses the canvas element to make beautiful charts.

It's fun to run remote X apps

2011-01-04T23:43:00.000-08:00

I forgot how simple and fun (your millage may vary) it is to connect to Linux box from a Mac:

$ ssh username@somehost -X
somehost$ xlogo

Beautiful. And actually productive since you can run all your apps remotely.

Job trends by language

2011-01-02T14:01:00.000-08:00

Nemerle: Functional + OO

2011-01-02T13:54:00.000-08:00

In my quest for language discovery, I have run into Nemerle:

"Nemerle is a high-level statically-typed programming language for the .NET platform. It offers functional, object-oriented and imperative features. It has a simple C#-like syntax and a powerful meta-programming system."

It has some really cool features: functional values, variants and pattern matching, type inference, and a powerful macro system. In some regards, it's very similar to Scala. Example:

variant RgbColor {
  | Red
  | Yellow
  | Green
  | Different {
      red   : float;
      green : float;
      blue  : float;
    }
}

string_of_color (color : RgbColor) : string
{
  match (color) {
    | RgbColor.Red    => "red"
    | RgbColor.Yellow => "yellow"
    | RgbColor.Green  => "green"
    | RgbColor.Different (r, g, b) => $"rgb($r, $g, $b)"
  }
}

Shorthand anonymous functions in Ruby

2011-01-01T14:52:00.000-08:00

In Scala, the anonymous function (n) => n * 2 can be shortened to _ * 2, which can be handy when dealing with only one or two arguments. Why don't we try this in Ruby :)

class Symbol
  def method_missing(name, *args)
    lambda { |n| n.send(name, *args) }
  end
end

puts (1..10).map &:n * 2
puts (1..10).map { |n| n * 2 }
puts (1..10).map &lambda { |n| n * 2 }

If you're not familiar with Ruby, the "&" turns the argument into a block - which is usually passed in with block syntax such as { |n| n * 2 }.

Coroutines, futures and actors

2011-01-01T14:28:00.000-08:00

I've been reading up on Scala and Erlang lately - I'd like to try implementing coroutines with support for multiple threads in Impulse to take advantage of multiple cores. This is how I understand the current languages/frameworks that are related to concurrency:

Erlang            =>    Extremely light preemtive(*)
                        coroutines + async IO +
                        multithreaded + distributed

Io                =>    Coroutines + async IO

Stackless Python  =>    Coroutines + blocking IO
+ Tasklets

Scala             =>    Event callbacks or OS threads
                        (to have continuations soon?)

Twisted, Node.js  =>    Event callbacks

(*) VM instruction preemtion, as in yielding after N number of reductions (function calls). Native C bindings can still block.

Event callbacks are stateless, which means nested loops need to handle state explicitly. Non-preemtive coroutines means that a "while (true);" can block all other coroutines. Blocking IO means that a IO call will block all other coroutines.

So apart from making every value immutable, I assume I could give each actor its own global environment, ensuring that it doesn't have access to objects that could be running in a different thread. I believe in Scala you just have to follow convention and not access mutable state?

Using futures is a great way to write your programs in a data-flow style. But without immutable state, even with cooperative coroutines, values
from change from underneath you. Io allows any object to become a temporary actor by sending asynchronous methods that return a future - but in a multi-threaded environment, there doesn't seem to be enough control without moving the object to it's own global environment (which seem pretty tricky).

So, would a combination of non-shared state between actors, coroutines, non-blocking IO, futures and one thread per processor with a scheduler do the trick? Example in Io:

calc = Actor clone do (
  product = method (value,
    range(1, value) reduce(*)
  )
)

value = calc product(5)
// do other stuff
writeln(value + 10)

Pointer to Member Functions in C++

2010-12-26T16:52:00.000-08:00

Pointers to member functions in C++ are quite useful when you need to store behavior. A pointer to a member function doesn't store the address of one function implementation - it allows you to call overriden member funtions in subclasses. For example:

#include <iostream>

using namespace std;

struct View
{
    virtual void mouseMove() { cout << "View.mouseMove()" << endl; }
};

struct Button : public View
{
    virtual void mouseMove() { cout << "Button.mouseMove()" << endl; }
};

typedef void (View::*EventType)();

struct MouseEvent
{
    EventType _eventType;

    MouseEvent( EventType eventType ) : _eventType( eventType ) { }

    void dispatch( View* view ) { (view->*_eventType)(); }
};

int main( int argc, char* argv[] )
{
    MouseEvent* event = new MouseEvent( &View::mouseMove );

    event->dispatch( new Button() );
}

This is somewhat similar to using generic functions in Dylan - there's a level of indirection between the reference and the function implementation. In very dynamic languages like Ruby, you can use symbols to achieve the same behavior:

class View
  MOUSE_MOVE = :mouse_move

  def mouse_move()
    puts "View.mouse_move()"
  end
end

class Button < View
  def mouse_move()
    puts "View.mouse_move()"
  end
end

class MouseEvent
  def initialize( event_type )
      @event_type = event_type
  end

  def dispatch( view )
    view.send( @event_type )
  end
end

event = MouseEvent.new( View::MOUSE_MOVE )
event.dispatch( View.new() )

Liberate Me Ex Null

2010-12-26T15:34:00.000-08:00

Not sure if I got the Latin perfect, but please, future language designers, save us from null!
Even bright new languages like Scala can't help us from the land of null:

def foo( string: Some[String] ) = {
  string.get
}

foo( null )

java.lang.NullPointerException at Main$$anon$1.foo(test.scala:2)

"Some" (and "None") are from the "Option" type, which is a way of letting you say you have something or nothing, while still preserving type safety.  But because of null compatibility with the JVM, Some[] is nullable!  A more dynamic language, Dylan, can type check this pattern:

define method foo (string :: <string>) end;

This method takes a string - and does not accept a null value.  If you want to allow nulls (or false, in Dylan's case), you write:

define method foo (string :: false-or(<string>)) end;

which is ultimately shorthand for a type union:

define method foo (string :: type-union(<string>, singleton(#f))) end;

Anonymous function syntax across languages

2010-12-26T15:07:00.000-08:00

One of my favorite references is the "Syntax Across Languages" site:
Anonymous function syntax across languages

It's amazing how many different (although some very similar) ways you can write an anonymous function. I have to confess, even in the development of my own language, Impulse, I have added yet another variation: |a, b| a + b, which is essentially Ruby without the braces { }.

Static + Dynamic Typing

2010-12-26T14:21:00.000-08:00

Sometimes you want the strictness of static type checking, but also want the flexibility of dynamic binding. C# expression trees, for example:
http://msdn.microsoft.com/en-us/library/bb397951.aspx

This is basically a LISP embedded in C#, or rather, the .NET runtime. The flip side to this is to add static type checking (with type inference) to a dynamic language. Examples of this would be Dylan and Dr Scheme. In the end, does it matter which direction you start from?

http://lambda-the-ultimate.org/node/1311
http://axisofeval.blogspot.com/2010/07/c-40-industrial-response-to-lisp.html
http://c2.com/cgi/wiki?SoftTyping

Welcome to Structura

2010-12-26T13:54:00.000-08:00

Welcome to Structura, a blog about programming languages and patterns. I'm a language enthusiast, so topics will range from old and new languages, to new patterns and ideas, to rants about why a language took a particular direction. I will be biased, of course, but I will be fair. Enjoy!

Regards,
Mike