LXPanel is the gnome-panel equivalent for LXDE. There doesn’t seem to be a Trash can plugin for it, and I think that’s just sad. So, I decided to learn how these plugins are coded and make one of my own. I’m not sure if I’ll end up succeeding, but at least it will be a learning experience either way.

I found this page, which outlines a simple plugin that doesn’t do anything. It seems to be a good starting point. I followed the directions and ended up looking at an autoconf project that required a lot of work to get running in Ubuntu. Even though I finally got it to compile, I decided it took way to long to do so. I converted it to a scons project, and now it’s just one directory with a simple build script:

The shared object that’s output is exactly the same size as the one created by autoconf, so that’s good enough for me at the moment. Time to keep hammering away. The code for the example is available here for reuse.

This is super alpha, and I’ll happily take patches. Cheers!

I’m extremely happy with how well this performs.  Using the latest ooc Java compiler from the github trunk to handle the each() functions, this compiles down to a bunch of C code, and then is automagically compiled behind the scenes into an ELF Binary!  This is totally awesome, and I have to commend nddrylliog and the other contributors for their work on this awesome project.  Now I should use it for something useful :D

A quick note about getting it running on Ubuntu:

sudo apt-get install sun-java6-jdk
git clone git://github.com/nddrylliog/ooc.git
cd ooc
JAVA_HOME=/usr/lib/jvm/java-6-sun/ make

At least, that’s how I did it. Then I compile all my ooc with a Makefile like this:

INPUTS=$(wildcard *.ooc)
TARGETS=$(patsubst %.ooc, %, $(INPUTS))

all: $(TARGETS)

%: %.ooc
  java -jar ~/repos/ooc/bin/ooc.jar $@

That will compile all ooc files in the directory.

gcc -x c -o /tmp/out - -lgmp <<< '#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <gmp.h>
void omg_i_love_leonardo_of_pisa(uint32_t num, mpz_t * result) { mpz_t retval, last, tmp; mpz_init(retval);
 mpz_init(last); mpz_init(tmp); uint32_t i = 1; if(num == 0) return; mpz_set_ui(retval, 1U);
mpz_set_ui(last, 0U); for(; i < num; i++) { mpz_set(tmp, retval); mpz_add(retval, retval, last);
mpz_set(last, tmp); } mpz_set(*result, retval); } int main() { uint32_t num; mpz_t fibo; mpz_init(fibo);
omg_i_love_leonardo_of_pisa(1000001, &fibo); mpz_out_str(stdout, 10, fibo); printf("\n"); return 1; }
' && time /tmp/out

It compiles a C program given from STDIN, puts it in /tmp/out, and runs it with time to find the time it takes to run. It generates the 1,000,000th Fibonacci number. Try it!

Update May 21, 2011

I changed the algorithm to do a matrix multiplication trick. The only problem is it goes over the number you ask for currently. I'm going to fix this with memoization soon.

gcc -x c -o /tmp/out - -lgmp <<< '#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <gmp.h>
void print_state(mpz_t* fm2, mpz_t* fm1, mpz_t* f, uint32_t n){gmp_printf("fib(%d) = %Zd\n", n, f);}
#define NEXT_FIB() mpz_set(oldfm1, fm1);mpz_set(oldf, f);mpz_mul(f, f, f);mpz_mul(tmp, fm1, fm1);\
mpz_add(f, f, tmp);mpz_mul(fm1, oldf, fm1);mpz_mul(tmp, oldfm1, fm2);mpz_add(fm1, fm1, tmp); \
mpz_set(tmp, fm2);mpz_mul(fm2, oldfm1, oldfm1);mpz_mul(tmp, tmp, tmp);mpz_add(fm2, fm2, tmp);\
n += i;i *= 2;
int main(){mpz_t fm2, fm1, f;uint32_t n = 2;uint32_t i = 1;mpz_inits(fm2, fm1, f, NULL);mpz_set_si(fm2,
0);mpz_set_si(fm1, 1);mpz_set_si(f, 1);mpz_t oldf, oldfm1, tmp;mpz_inits(oldf, oldfm1, tmp, NULL);
uint32_t g = 1000000;while(n<g){NEXT_FIB();}print_state(&fm2, &fm1, &f, n);return 0;}' && time /tmp/out

This outputs almost immediately on my Intel Atom:

fib(1048577) = 19202837189514814.................

real	0m0.840s
user	0m0.280s
sys	0m0.010s

The code is here. Feel free to fork and improve!

I usually use Ruby for this because it offers Hpricot, a very nice and fast scraper and XPath interface. This time, I resolved to find something that does RSS generation better, and I stumbled upon RubyRSS, which happens to be in the core ruby distribution!

Here’s what I ended up with after about an hour:

Now this is impressive if you look at the fail of html id and class attributes coming out of the original page. I had to base everything off of the links to the items that were not images, and then the structure up the tree from there (see the liberal use of .parent). I’ve rediscovered that Hpricot is awesome (_why, come back to us!), and that it truly only takes 30 lines of code to generate a nice RSS feed in ruby. The resultant RSS feed for MDShooters Classifieds site is here.

And now, yet another RSS feed generator: MD Super Ads

Here’s the code:

All you have to do is copy the room name into the Join Chat window, and put in groupchat.google.com as the server.  I hope you find it useful.  If anyone knows how to make this a link that GNOME will throw at Pidgin, let me know.  That would be awesome.

Get the Script

I plan to write some code implementing the algorithm.  That should be fun.

I was on IRC tonight and someone was having trouble with their NASM homework. I decided to help them by learning NASM and coding up their homework problem for fun. It was pretty cool. Here’s the resultant program:

; Goal: (a+b)*c+d*b
; PARI/GP says:
; ? (1.234+5.678)*9.012+3.456*5.678
; %1 = 81.91411200000000000000000000
;
;=== Output ===
;hank@rofl:/tmp$ nasm -felf floating_point_arith.asm && \
; gcc floating_point_arith.o && ./a.out
;Answer: 81.91411
;===
;QED

  extern printf

  section .data
  a: dq 1.234
  b: dq 5.678
  c: dq 9.012
  d: dq 3.456
  e: dq 7.890
  fmt: db "Answer: %.5f",10,0

  section .bss
  f: resq 1

  section .text

  global main
  main:
    fldz
    fld   qword [a]
    fadd  qword [b]
    fmul  qword [c]
    fstp  qword [f]

    fld   qword [d]
    fmul  qword [b]
    fadd  qword [f]
    fstp  qword [f]

    push  dword [f+4]
    push  dword [f]
    push  dword fmt
    call  printf
    add   esp, 12
    mov   eax, 0
    ret

Code is also available here:

http://modzer0.cs.uaf.edu/repos/hank/code/asm/floating_point_arith.asm

All this does is add some floats and call printf, but it was fun to monkey around low-level again.