wedesoft

Racket has hygienic macros.

Yes, if a library is implemented in a language which supports closures, the difference between it and a framework starts to vanish.

Nice idea because it would make for a more minimalistic core. One could then use some OO library (e.g. Guile's GOOPS) to implement polymorphic versions of+, -, *, etc.

Edit: ... as well as methods for reading and displaying numbers.

But the employer has to follow the manager's directions.

Note to myself: put all source code into one file ;)

Then you are biased towards papers which don't offer a clear choice. Sorry, couldn't resist ;)

Thanks for posting this. I wrote a whole thesis about computer vision using Ruby instead of C/C++ [1]. Now I am working on computer vision with GNU Guile (Scheme) [2]. Not that I have convinced many people apart from myself about it ;)

[1] http://www.wedesoft.de/ruby-computer-vision-thesis.html

[2] https://github.com/wedesoft/aiscm

No big deal. Just become an expert then. It is not that hard. Just have a look at Ian Piumarta's work [1,2]. Future systems will probably facilitate programming on every level from the bare metal to the highest abstraction. I.e. no strict boundaries between the implementation of the application and the implementation of the compiler/interpreter.

[1] http://piumarta.com/software/maru/

[2] http://www.youtube.com/watch?v=cn7kTPbW6QQ

EDIT: There are other reasons to write machine code than performance.

I was trying to implement an interpreter for a minimal (lazy) language in C [1]. It uses Church encoding and other encodings. E.g. here are the definitions of false, true, identity, and pair:

    f_ = proc_self(lambda(v0));
    t_ = proc(lambda(v1), f());
    id_ = proc(v0, f());
    pair_ = lambda3(op_if(v0, v1, v2));

For the moment I gave up on it though but maybe it might serve as inspiration ;)

[1] https://github.com/wedesoft/blc/blob/master/src/x.c#651

Cheers for that.

Yes, especially Halide looks interesting.

I am trying to develop a JIT for array processing [1]. Here are some resources I found useful so far

* Dr Paul Carter's tutorial [2]

* Intel processor reference [3]

* C ABI standard [4]

[1] https://github.com/wedesoft/aiscm

[2] http://www.drpaulcarter.com/pcasm/

[3] http://www.intel.com/content/www/us/en/processors/architectu...

[4] http://www.sco.com/developers/devspecs/abi386-4.pdf

I did something similar with Ruby. I used GCC and on-the-fly linking for JIT compilation: http://www.wedesoft.de/hornetseye-api/

:+1: And the same holds for rbenv and rvm for Ruby.

Intel provides FOSS graphics drivers [1]. I'm not sure though whether they do mobile graphics cards with free software drivers, too.

[1] https://01.org/linuxgraphics/

I'm not convinced that people will be more productive like this, but it will certainly make sure they keep moving their mouse cursor.

One can implement OO using closures: https://github.com/alvatar/code-ttrs/blob/master/scheme/pure...

Maybe Nokia should consider Firefox OS.

We Germans shouldn't forget that in 2009 our government tried to implement a similar kind of surveillance. This lead to Tauss leaving the social democrats and join the Pirate Party.

http://www.wedesoft.de/tauss-against-censorship.html

Somewhat related: I've developed a library for operations involving multi-dimensional arrays [1, 2]. When possible it uses GCC for jit-compilation to achieve higher performance.

  require 'multiarray'
  include Hornetseye
  # Object
  lazy(4) { |i| i + 2 }
  # Sequence(INT):
  # [ 2, 3, 4, 5 ]
  lazy(3, 2) { |x, y| x }
  # MultiArray(INT,2):
  # [ [ 0, 1, 2 ],
  #   [ 0, 1, 2 ] ]
  lazy(3, 2) { |x, y| x + 1 }
  # MultiArray(INT,2):
  # [ [ 1, 2, 3 ],
  #   [ 1, 2, 3 ] ]
  lazy(3, 3) { |x, y| y + 4 }
  # MultiArray(INT,2):
  # [ [ 4, 4, 4 ],
  #   [ 5, 5, 5 ],
  #   [ 6, 6, 6 ] ]
  lazy(3, 3) { |x, y| (x + 1) * (y + 4) }
  # MultiArray(INT,2):
  # [ [ 4, 8, 12 ],
  #   [ 5, 10, 15 ],
  #   [ 6, 12, 18 ] ]
  lazy { |x,y| Sequence['n', 'p', 'r', 't'][x] + Sequence['a', 'i', 'u', 'e', 'o'][y] }
  # MultiArray(OBJECT,2):
  # [ [ "na", "pa", "ra", "ta" ],
  #   [ "ni", "pi", "ri", "ti" ],
  #   [ "nu", "pu", "ru", "tu" ],
  #   [ "ne", "pe", "re", "te" ],
  #   [ "no", "po", "ro", "to" ] ]
  s = lazy(33) { |i| 3 * (i+1) }
  # Sequence(INT):
  # [ 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, .... ]
  s.mask((s % 2).eq(0)).collect { |i| i ** 2 / 3 }
  # Sequence(INT):
  # [ 12, 48, 108, 192, 300, 432, 588, 768, 972, 1200, 1452, 1728, .... ]

[1] https://github.com/wedesoft/multiarray [2] http://www.wedesoft.de/hornetseye-api/

Shameless plug. I did some Ruby bindings [1] for libfreenect. The Ruby example code to display data from the Kinect is very concise [2].

[1] https://github.com/wedesoft/hornetseye-kinect [2] http://www.wedesoft.de/hornetseye-api/file.Camera.html#Micro...

> since all objects in space are visible

The majority of objects in space are not visible to us. They only become visible when near and bright enough. Even known comets such as Halley are not visible to us most of the time.

As far as I know, Ruby has proper support for higher-order functions and lexical closures (aka code blocks).

http://stackoverflow.com/questions/4769004/learning-python-f...

IMO Meebo for Android is a really good multi-protocol chat client. A bit like the Pidgin free software for the desktop.

> Lisp is so powerful that problems which are technical issues in other programming languages are social issues in Lisp.

I think this is a rather stupid argument. The same way you could argue that a boat is a better means of transportation than an airplane. With the boat agreeing on a holiday destination is less of a social issue because it is limited by technical constraints anyway.

The Bitcoin network maintains a shared transaction chain to make double spending of Bitcoins impossible. However somebody controlling the majority of the network's processing power could compromise the transaction chain.

The actual content starts here: http://www.youtube.com/watch?v=6kalMB8jDnY&t=1m10s

The same thing has been going on in European countries for several decades. Manufacturing is cheaper in Asia where the workers can be forced to do their job for low salaries and no healthcare. The solution is to massively increase VAT (and lower income tax). The other possibility is that our (average) living standard will drop until we are able to compete again.

I would assume that somebody who participated in the implementation of a law and then broke it, would be the last person to be able to invoke a good-faith belief that their actions are legal.

It's much easier to just use Adblock to block third party code from Facebook and others when viewing web pages.

http://www.fanboy.co.nz/

As far as I know the full body scanners are terahertz scanners. They do not use X-rays. An X-ray scan would show your bones! Also if you really want to reduce your exposure to radiation, you should avoid flying itself.

That said, if there is a significant increase in cancer among TSA workers, that should be a cause for concern.