Coffee-enabled Musings

What's wrong with P mode?

2011-09-09T20:55:00.000-07:00

Ok - just a short rant!

Since we all went off "Full Auto" mode on our DSLRs some years ago, it's now all the rage and a sign of professionalism to shoot in "Full Manual" mode, right?

So, you can either guess the proper exposure - I grew up with that and I'm still pretty good at it, then take a shot and check the exposure (preferably via histogram), correct and shoot again. Works perfectly for e.g. dragonfly pictures with no dragonflies in them!

Or you can use the little wheel(s) to adjust f-stop and exposure time and turn it/them until the bar is somewhere in the center - selecting which of the two to change requires some good "finger memory", and yes! it's (more or less) always in the center when you have your camera in "Auto ISO" anyway, because it compensates for a change of EV by adjusting the ISO value, just dreadful!

So, message 1: Get off "Auto ISO" - I loved for 10 days and now I'm back to selecting ISO first: sunny: 100, not so sunny: 200, not really sunny: 400, pretty dark: 640 etc. If all goes wrong, the 60D lets you adjust ISO without even taking the camera down - I love this little "nubby" on the ISO selector button!

Now in "M" I'm adjusting f-stop and exposure time manually, until the little exposure bar is centered (unless I have a weird lighting situation in which that doesn't work). I'm looking at different combinations estimating depth of field and moving speed, then I see that it's underexposed or overexposed, correct and then the shot is lost (unless it's a building or mountain both of which luckily have the pleasant habit of moving quite slowly or not at all).

Well, message 2: If it's moving fast, why not get a decent ISO preset, switch into "Tv" mode, select 1/1000 sec and see what the display says? Actually, I still think that 1/250 is fast enough for everything - some of my butterfly and horse photos are proof to the contrary :-)

Or, message 3: If I need some decent DOF why not switch into "Av" and select f/11?

Or. message 4 -and that's what I'm doing right now, if I have more than 5 seconds to take a shot: Use "P" mode and then turn the (one!) wheel until it comes up with a combination of f-stop and exposure time that seems usable?

And what about weird lighting situations? I see the point, of course! In these cases Exposure Compensation and/or Spot Measuring work perfectly if you can predict the effect.

Sorry, "M" aficionados - I'm back in "P", "Av" and "Tv"!

RawTherapee

2011-07-05T09:57:00.000-07:00

Here's a nice one: RawTherapee - something that can make life a little easier under Linux (works quite nicely under Windows, too).

When you use GIMP and UFRaw, you might have had some issues, but RawTherapee helps a lot. It's not really a Adobe LR or Digikam replacer, but once you got it installed, it's really easy to use and the RAW processing capabilites are among the best available.

Once you got it installed, yes! While getting it to run under Windows is a no-brainer, under Ubuntu Linux it's just a little - difficult. Amazing, since it's a native Linux app.

So here's what I did do get 3.0 set up under Ubuntu 11.04

sudo add-apt-repository ppa:rawtherapee/ppa

sudo apt-get update

sudo apt-get install rawtherapee

And that took some time to figure out!

Why use Turing Machines when there's Haskell

2011-05-18T19:40:00.000-07:00

Predicates and algorithms in Haskell

The nice thing about using Haskell (or lambda calculus) against using Turing machines is the possibility to talk about signatures of predicates and/or algorithms in a more natural manner. It is even easier to describe languages in terms of partial predicates rather than grammars or TMs.

So, let's do that:

A one-place predicate (1pp) P is defined by a Haskell expression of the form

P :: String -> Bool
P = \x -> ...

returning either True or False. Since Haskell allows for Type Synonyms, we define as an abbreviation:

type OnePP = String -> Bool

The extension or language of the predicate P - denoted as L(P) - is given by those values for which P returns True. If P returns True or False for every argument, it is called total and can be regarded as a decision procedure for L(P), else it called partial and can be regarded as an acceptor, recognizer, semi-decider or enumeration procedure for L(P).

If a language L = L(P) for a 1pp P, we refer to P as a representation of L.

Note that when we will talk about decision problems regarding languages, we assume the language in question is given by a representation. Another representation could be a Turing Machine, Type-0 grammar or another equivalent formalism.

Examples

The Acceptance Problem A_TM can now be stated and proved like this:

Problem: Is there a total predicate

H :: OnePP -> String -> Bool

such that (H A w) returns True, iff A returns True for w and False, if not (i. e. A returns False or no value at all)

Answer: No.

Proof: Assume H exists as specified. Then consider the following Haskell program:

D :: OnePP -> Bool
D = \A -> not (H A A)

Then the program

main = (D D)

shows the desired contradiction.

The fact that A_TMis recursively enumerated is neatly shown by

Acc :: OnePP -> String -> Bool
Acc = \A w -> (A w)

That should work nicely - more about that when Rice's Theorem comes up in some days...

More Cassandra

2011-05-10T08:14:00.000-07:00

There's a lot written about the Cassandra data model, here's a good one: http://javamaster.wordpress.com/2010/03/22/apache-cassandra-quick-tour/

Let's set up a small system to work together with one little web app I did some years ago (at that time with MySql). Prepare a glossary for the Distributed Software Architecture Course for the fall. The data model should support two operations:

* List all terms/explanations in alphabetic order (over the term of course)
* List all terms/explanations in alphabetic order in a given interval

Shouldn't be too difficult, once you forget about ACID. Actually, in this case, with the small amount of "use cases", it seems I can just copy the basic SQL idea, equating a table with a column family. How did the SQL look like?

CREATE DATABASE IF NOT EXISTS DSAGlossary;
USE DSAGlossary;
DROP TABLE IF EXISTS Reference;

CREATE TABLE DSAGlossary.Reference (
 refID INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
 term VARCHAR(50) NOT NULL,
 description VARCHAR(250) NOT NULL,
 PRIMARY KEY (refID)
)

That doesn't look too difficult - the problems may arise with more cases. Here it's more or less the same structure - apart from the missing artificial primary key.

create keyspace DSAGlossary;
use DSAGlossary;

create column family Reference with
  comparator = UTF8Type and
  column_metadata =
  [
      {column_name: term, validation_class: UTF8Type,
                          index_type: KEYS},
      {column_name: expl, validation_class: UTF8Type}
  ];

We need this KEYS in order to have access to a column over the term. Feed this into the Cassandra implementation - in the Cassandra home directory:

1. Start it with bin/cassandra start&
2. Use the CLI to feed the script in:

bin/cassandra-cli -host localhost -port 9160 -f glossary.txt
Connected to: "Test Cluster" on localhost/9160
1361c18a-7b18-11e0-b561-e700f669bcfc
Waiting for schema agreement...
... schemas agree across the cluster
Authenticated to keyspace: DSAGlossary
13eb63eb-7b18-11e0-b561-e700f669bcfc
Waiting for schema agreement...
... schemas agree across the cluster

Sounds like a success (you're never completely sure); so add one entry:

bin/cassandra-cli -host localhost -port 9160
Connected to: "Test Cluster" on localhost/9160
Welcome to cassandra CLI.

Type 'help;' or '?' for help. Type 'quit;' or 'exit;' to quit.
[default@unknown] use DSAGlossary;
Authenticated to keyspace: DSAGlossary
[default@DSAGlossary] set Reference['Cassandra']['term']
                     = 'Cassandra';
Value inserted.
[default@DSAGlossary] set Reference['Cassandra']['expl']
                     = 'http://en.wikipedia.org/wiki/Apache_Cassandra';
Value inserted.

Still fine! Get it back, maybe?

[default@DSAGlossary] get Reference where term
                     = 'Cassandra';
-------------------
RowKey: Cassandra
=> (column=expl, value=http://en.wikipedia.org/wiki/Apache_Cassandra,  
     timestamp=1305041351336000)
=> (column=term, value=Cassandra,
     timestamp=1305041338862000)

1 Row Returned.

Ok! Next time: Get access from Java (or any other language).

Chess Search Algorithms 1: Minimax Search

2011-05-06T12:05:00.000-07:00

Here's a series of little things I wrote around 10 years ago. Maybe it's time to resurrect them. You probably would have guessed that from the Pascal-ish pseudocode anyway.

It's all about basic Chess Search Algorithms - I wrote that mainly because I never felt too comfortable with the way they're coded in text books. Here "ref" before a parameter means that it should be passed by reference making it an out or in-out parameter; everything else is a value parameter.

1. MiniMax

Minimax search embodies two almost identical routines for the maximizing and minimizing player. It's usually less useful than NegaMax search (next issue), since you have two pieces of code to maintain. Watch out, to make sure it works always evaluate from the max player's side - this will change with NegaMax!

bestVal: best value for max/min player
bestMove: best move leading to this value

Maximizing level

procedure maxSearch(ref bestVal,
                   ref bestMove)
if atLeaf then
 // leaf: static evaluation
 // from maxPlayer's side
 bestVal := evalu8(maxPlayer)
else
 // generate successor moves...
 generate(moves,nMoves)
 // ...and preset return value
 bestVal := -infinity

// loop over all moves
for i := 1 to nMoves do
  // execute move and call min player
  makeMove(moves[i])
  minSearch(succVal,reply)
  // take back before continuing
  retractMove(moves[i])

// compare returned value: update value/move
if succVal > bestVal then
  bestVal  := succVal
  bestMove := moves[i]

Minimizing level

procedure minSearch(ref bestVal,
                 ref bestMove)
// really (almost) identical
if atLeaf then
  // always evaluate from maxPlayer's side
  bestVal := evalu8(maxPlayer)
else
  generate(moves,nMoves)
  bestVal := infinity

for i := 1 to nMoves do
  makeMove(moves[i])
  // now call the max player
  maxSearch(succVal,reply)
 retractMove(moves[i])

if succVal <  bestVal then
  bestVal  := succVal
  bestMove := moves[i]

How to move big buildings

2011-05-05T10:50:00.000-07:00

As we all know, walking is wearing out your muscles, soles and motivation. Wouldn't it be much nicer if it would just take a moment's thought to move your target closer? Look at the mile long walk to the building in the background on the picture to the left. The silvery car in the front is just a couple of steps away, but then the strenuous part beckons.

The magic unveils itself when you hire someone with big tools that can move buildings in a heartbeat. Actually, it looks like he pushed all and everything behind the silver car closer up - nice!

Of course, that's cheating! In two respects, actually:

1. I had to walk quite a bit away from the scene to take the second picture.

2. The focal length of the lens went from wide (17mm = 27.2mm/35mm equivalent) to long (should call it "narrow", 200mm = 320mm/35mm equivalent).

So, combining a short walk with an increase in focal length had this "compression" effect. As opposed to some statements about this phenomenon, it's not the focal length that is responsible for it. The picture on the left was also shot with 17mm focal length, only from the same spot where the second picture was taken: Behold, the same "compression" effect!

The reason: it was cropped out of the one on the right (hence the little blurriness and the weird white balance).

So, what's responsible for the compression effect? Angle! Our friends W (the one with the wide-angle lens) and T (with the telephoto lens) are taking a picture of a tree so that it appears the same size in both sensors (layer A).

The house in the background (layer B) fills about a third of the frame for W but still almost the full frame for T. No wonder it looks closer. Since cropping has the same effect of reducing the angle, pictures 2 and 3 show the same compression effect.

I assume that the confusion about perspective compression stems from the fact that the idea of a wide-angle lens is to get close to the subject, so the wide angle effect hits. Per se, the focal length has nothing to do with it (at least ideally).

Memorizing Modes

2011-05-04T18:20:00.000-07:00

Right! After months of lazying around without playing, grab the bass and go back to getting the modes back engraved in the brain.

Takes a couple of hours and then the fingers get them back in. Here's my way of memorizing them (as long as my fingers don't recall them automatically).

Generally they come in two "basic shapes" (here for the bottom three strings):

|---|-*-|-y-|-y-|-*-|---| Major
|---|-*-|-x-|-x-|-*-|---|
|---|---|-*-|---|-*-|---|

|---|---|-*-|---|-*-|---| Minor
|---|---|-*-|-y-|-y-|-*-|
|---|---|-*-|-x-|-x-|-*-|

For x and y we can have the lower position (1) or the higher position (2). So, for example,

Mode I (Ionian) is "Major 1,2" (or systematically 4, 7)

|---|-*-|---|-*-|-*-|---|
|---|-*-|-*-|---|-*-|---|
|---|---|-*-|---|-*-|---|

Mode ii (Dorian) is the only one that doesn't work that way (because it's the only minor scale with an undiminished 6th). We'll look at it in a moment.

Mode iii (Phrygian) is "Minor 1,2" (systematically b2, 5)

|---|---|-*-|---|-*-|---|
|---|---|-*-|---|-*-|-*-|
|---|---|-*-|-*-|---|-*-|

Mode IV (Lydian) is "Major 2,2" (systematically #4, 7)
Mode V (Mixolydian) is "Major 1,1" (systematically 4, b7)
Mode vi (Aeolian) is "Minor 2,2" (systematically 2, 5)
Mode vii (Locrian) is "Minor 1,1" (systematically b2, b5)

So, apart from Dorian it all works nicely (as long as you remember the Major/Minor alternations, but that's more or less trivial - I use uppercase roman for Major and lowercase roman for Minor. And, no!, that doesn't refer to CS majors or minors.)

1,2
??
1,2
2,2
1,1
2,2
1,1

Dorian is obviously Minor 2,2 but it has this pesky 6th that maybe Jaco Pastorius could have reached on the second string (well, at least starting at F#) - I can't. In any case, I memorize it as "Minor 2,2,+1" and use the third string for the 6th:

|---|-*-|-*-|---|-*-|---|
|---|---|-*-|---|-*-|---|
|---|---|-*-|---|-*-|-*-|

So it all comes out to
1,2
2,2,+1
1,2
2,2
1,1
2,2
1,1

The pattern is easy, except for Dorian, which I treat as a special case anyway. So, it boils down to 1,2 - 1,2 - 2,2 - 1,1 - 2,2 - 1,1. Not too difficult.

With some special training in pattern recognition, the inquisitive mind now immediately stumbles on the questions: What then is "Major 2,1" and "Minor 2,1"? Easy:

Major 2,1: 1 2 3 #4 5 6 b7 8
Minor 2,1: 1 2 b3 4 b5 b6 b7 8

Well, they're obviously not modes; Minor 2,1 to me is Locrian with an undiminished 2nd - scaled back to Ionian that's a #1 and that's an Avoid Note in my book. I'm not so sure about that with respect to Major 2,1. Without any experience, I guess the 2 could work as a Passing Note on V (Mixo) - I might have to try that...

Setting up Cassandra under Ubuntu and VMWare

2011-05-02T05:26:00.000-07:00

Nope! Not the Greek mythical figure; Apache Cassandra, the "Distributed Database". Let's see how that works...

The issue is that I'm not sure if this beast runs together with OpenJDK, the web seems to be positive about the issue, but you never know (seems to become this year's catch phrase).

As fas as I know, two disks are better than one. So, create another virtual disk under VMWare for this VM and check if it works:

sudo fdisk -l
Yep! Shows up with "Disk /dev/sdb doesn't contain a valid partition table" - we should be able to change that...

sudo fdisk /dev/sdb - then "n" (new), "p" (primary), "1" and accept all settings, exit with "w"

Check back with "sudo fdisk -l" - it's dev/sdb1 now. All as planned!

Create an ext3 file system with "sudo mkfs.ext3 /dev/sdb1" (check!)

Give it a nice name: sudo e2label /dev/sdb1 hd2

Thank you... next!

Downloaded the latest version of Cassandra from the website - I think there's also a way to use apt for that, but I'd really like to make sure I got the latest version (0.7.5).

Unpack the archive into my home folder - I'm not in the mood to deal with permissions at this stage; it's going to be difficult enough. So, here's what we have:

/bin
/conf
/interface
/javadoc
/lib

and a couple of well-know readme, license etc. files.

Check the readme: Tells you how to unpack the file (little late for that, but thanks anyway) and how to set up the logs. Let's do that!

sudo mkdir -p /var/log/cassandra
sudo chown -R `whoami` /var/log/cassandra
sudo mkdir -p /var/lib/cassandra
sudo chown -R `whoami` /var/lib/cassandra

Next dreaded issue: ports. The Cassandra Wiki is clear about that:
By default, Cassandra uses 7000 for cluster communication, 9160 for clients (Thrift), and 8080 for JMX. These are all editable in the configuration file or bin/cassandra.in.sh (for JVM options). All ports are TCP.

8080, of course! As if there's no other choice of ports; everybody and his brother listens on 8080. Just joking - I know that makes sense!

Change that in conf/cassandra-env.sh under the Cassandra install directory:

JMX_PORT="8080" changed to JMX_PORT="10036"

Now - last for this session - check if it responds to the CLI:

~/apache-cassandra-0.7.5/bin/cassandra-cli

Yep! Something happens...

[default@unknown] connect localhost/9160;

Did I mention I very much dislike a prompt like "default@unknown"?

Connected to: "Test Cluster" on localhost/9160

Enough success for one night... More later!

Finally back

2011-04-29T04:43:00.000-07:00

Semester's almost over - grading almost done. Now for some fun: brand new toys!

24 inch monitor
Ubuntu Natty Narwhal (11.04) under VMWare Player
OpenJDK
Libre Office
NetBeans 7.0
GlassFish 3.1

Life can be good! Now: setting up NetBeans under Natty. First attempt to run it all under Open JDK - it should work; let's see.

Install Open JDK: sudo apt-get install open-jdk-6-jkd (check!)
Run NetBeans 7 installer: sh netbeans-7.0-ml-linux.sh (don't sudo! - check!)
Add Tomcat - you never know!
Make a note about the locations: all under mu home directory (you never know!)
Open NetBeans, program "Hello, world!" (check!)
Set up the GlassFish server: ~/glassfish-3.1 does it
Start it, start admin console - it's running on 4848 (check!)
Will do Tomcat later - enough to play with GlassFish for the moment.

RFC 2549 - IP over Avian Carriers with Quality of Service

2009-07-30T09:46:00.000-07:00

RFC 2549 - IP over Avian Carriers with Quality of Service

Pfft - and 10 years later?? Nothing has been done! Nothing!

Oh well

Running Perl on IIS 7 : Wade Hilmo : The Official Microsoft IIS Site

2009-07-28T06:04:00.000-07:00

Running Perl on IIS 7 : Wade Hilmo : The Official Microsoft IIS Site

After hours getting ActivePerl to run on my 64-bit Vista IIS7, finally that's the thing that did it.

Important: download the 32 bit version!

100 in 100: The Rule of Thirds from Adorama Learning Center

2009-07-15T20:04:00.000-07:00

100 in 100: The Rule of Thirds from Adorama Learning Center

Reminds me of something I learned some time ago - well, during an exhibition and some pro seminars, actually.

Sometimes the RoT really doesn't work too well, like in this image which used some Photoshop to create this slightly strange appearance of a street portrait. I somehow liked the proportions and the idea - the man with his back to the main scene showing a detached attitude, so that's all very much ok. Problem: No "power point" on any thirds!

What the speakers at the seminar did was obvious once someone tells you: You place the image into a mat via Photoshop (or Gimp, works just as well) in a way that now a power point of the whole print is on a third. Of course, that means the image is matted asymmetrically, but that gives it another unusual "twang".

Finally, here's the result without the aux lines - it's set for a 3x2 ratio, changing that would of course mean to reposition the main image, but that shouldn't be too difficult.

Twitter / Search - #iranelection

2009-06-16T10:07:00.000-07:00

Twitter / Search - #iranelection

Looks like Twitter is in full swing! Smartmobs are rallying again... Let's see if this will work!

Wolfram|Alpha Launch

2009-05-14T05:03:00.000-07:00

Looks like Wolfram|Alpha will go live on Friday, May 15 @ 7p.m. CDT. A life transmission is going to be seen here.

Say Hi to Hagrid

2009-05-11T16:20:00.000-07:00

Indeed, now's the time to introduce the new kid: Hagrid - an old and wise former WinXP machine, now revitalized to run Ubuntu Server 9.04, just in time to study Apache httpd and Apache Tom cat in more depth.

As a rule, all machines in our household are named after movie characters from Scrat - a long-gone laptop - over Yoda - my trusty Thinkpad - to Falkor, the Quad Core.

And now Hagrid.

Looks like Server installed fine, Gnome now sitting on top of it all - which might be not such a great idea, because it makes some updates really a bit troubling, but we'll see.

Using DNG safely

2009-04-25T19:41:00.000-07:00

Using DNG safely

Interesting development, and I missed most of that, I admit. It looks like the only pieces of my software that can read this is Picasa 3 and (interestingly enough!) GIMP via UFRaw.

For the moment, it doesn't look like a must to convert from my various RAWs into DNG, but I'll play around with it.

More about Ruby - Briefly

2009-04-02T17:26:00.000-07:00

Ok, I'm also training some gifted students at UWF to be competitive programmers, that means that I need to find some nice problems to solve, solve them myself and see how it goes.

Let's try something fancy - The Problem of having two jugs with different integer capacities and a target volume that has to be reached by filling/emptying jugs or pouring the content of one jug into the other - with the minimum number of operations, of course!

It's important to know how to do that, in case you have to prevent a bomb from exploding!

In principle it's clear how to do it with Jugs with an arbitrary capacity (> 0) and an arbitrary target value: Exhaustive search (breadth-first) through all the states and hope for the best.

The actual implementation is a bit nasty, because you need to "ariadne-thread" all the states together to their immediate predecessors before placing them in the queue, so let's come up with a Queue class first.

Ok! There actually is one, but it's always nice to check how you would do that in your host language - let's base it on arrays then:

class Queue
 def initialize
   @a = []
 end

 def enqueue(x)
   @a << x  
 end

 def dequeue
   @a.delete_at(0)
 end

 def empty?
   @a.empty?
 end
end

Looks quite simple! These Ruby arrays are pretty flexible. If I could only remember to place this pesky ampersand in front of my instance variables! How may run-time errors did I get by omitting that.

I'm not really crazy about static typing, so I think most errors are not really type-related in reality (well, maybe one or two a year).

I love how Smalltalk lets you deal with identifiers: you have to declare them and there's no way I can sneak in a variable by misspelling the name! In Ruby I find such a problem at run-time, but I guess that's how you're supposed to learn it...

Gmail - Settings

2009-03-25T16:18:00.000-07:00

Gmail - Settings

Little did we know what we can actually do with Gmail. If you have a Gmail account the Gmail Labs offers some interesting ideas to use in your settings. Yes, I'm technically a Thunderbird affcionado, but Gmail offers a couple of things in the meantime that make it an interesting alternative.

I know, Gmail is a bit "intrusive" to say the least, but apart from viable privacy concerns there are a couple of idea I really like:

Undo Send: That's the main reason for looking into this a bit deeper - triggered by a CNN article.

Mark as Read Button: Interesting it's not in the Gmail standard, sometimes I like to keep a message even without reading it; maybe I'll look at it later.

Forgotten Attachment Detector: A heavenly idea! I'm famous for announcing attachments and not attaching them - mostly followed by an "Oops! I forgot to attach the attachment", in most cases with the attachment attached. I'm just waiting to make this blunder to see it it really works.

I think I'll try some more, maybe there are some that are more useful than they sound.

Mate in One

2009-03-15T09:08:00.000-07:00

Gosh! I just found this little piece somewhere on an old old old website I created back in 2001 or so... White to move and mate!

Oh, well... White mates with 1. a5xb6 e.p.

Yes! Black's last move must have been b7-b5!

Why? Think about it...

Cheers

From Java to Ruby 1

2009-03-13T06:08:00.000-07:00

All right! After dabbling around in Java for more than a decade now, working in C++, Lisp and Smalltalk even before that, it's now time to expand the horizon a bit and get my hands on Ruby.

It's promised to make things easier, faster and to speed up the development process significantly.

Assuming you have some deeper knowledge about object-orientation in general and in Java in particular, let's start with a simple example: A trivial Java class vs. its version in Ruby.

Here it is in Java - I won't use comments to save some space:

public class Person {
 private String name;
 private int age;

 public Person(String name, int age) {
     this.name = name;
     this.age = age;
 }

 public String getName() {
     return name;
 }

 public int getAge() {
     return age;
 }

 public void setAge(int age) {
     this.age = age;
 }

 public String toString() {
     return "A person named " + name + " aged " + age;
 }
}

Nothing special here, just two instance fields, "name" is read-only (just a get method) and "age" is read/write (both get and set method).

In Ruby this seems to be a bit more condensed:

class Person
  attr_reader :name, :age
  attr_writer :age
  def initialize(name, age)
    @name = name
    @age = age
  end
   def to_s
    "A person named #{@name} aged #{@age}"
  end
end

Yep! It is more "condensed". Two reasons: No static typing (I love that!) and the nice idea of declaring the accessibility of a variable directly (attr_reader means read access, attr_writer means write access).

Also nice: Disambiguating instance fields by the "@" prefix - makes is optically clear you're referring to the instance field and not any old identifier that suddenly "slipped into the scope".

Mains and stuff: next post.

CU

Pattie Maes demos the Sixth Sense | Video on TED.com

2009-03-11T06:20:00.000-07:00

Pattie Maes demos the Sixth Sense | Video on TED.com

Oh yes! This seems to be one of the more fascinating ideas of the last time... Ultimate wearablity!

A quick polaroid effect with the GIMP

2009-03-07T05:51:00.000-08:00

That's just an outline - good thing I can use this blog to take notes rather than having this all stores in my little brain or in some obscure text files.

The idea is to create a polaroid effect with GIMP, like shown here. Many ideas are out to do this in photoshop, the work in GIMP is similar.

It's not as tricky as it sounds; some transparency issues are somewhat made easier in the meantime. So let's see

Create a new image, here it's 300x300
In the selection tool select rounded corners with 5px radius
Copy the selection
Paste as new image
In the "Filters" menu, select Light and Shadow, then Drop Shadow. Make both offsets 5px. This filter creates the necessary Alpha layer - else it would take some work to do that!
Lock pasted image and drop shadow layer (just for safety reasons, in case you want to move them around)
Load the image you want to paste into the picture
Rescale to 250 pixels by whatever it produces
You might consider an "Unsharpen Mask" with 1 pixel
Select all of the picture, copy it.
Back to the frame: Paste as new layer
Place the caption, maybe rotate the text layer
Save as .gif

That's it, I guess

Abstract data types

2009-03-05T10:57:00.000-08:00

Interesting topic - I used to follow the definition not unlike given here:
Abstract data type - Wikipedia, the free encyclopedia

But somehow I'm not so sure anymore. The reason is that the separation of interface and implementation - which is a very good idea, don't get me wrong! - makes it difficult to do a thorough complexity analysis of an algorithm that uses this particular ADT.

This cannot be done correctly, unless the operations of the ADT can be analyzed in terms of their intrinsic complexity, at least aymptotically.

Obviously, this depends on the well-hidden implementation of the ADT. E. g. a "Priority Queue" can be implemented in a way that insertion and removal have a complexity of O(log n) or in a way that one of them is O(n) and the other is O(1).

This also raises the question of how to perform an average-case analysis of the surrounding algorithm - would you need to specify the average complexity of the ADT operations as well (e. g. as amortized costs).

Let me see what's around on the subject - there's a 1980 paper by Ehrig and Mahr. Just need to get a hold of it.

Until then

Photography Legality

2009-03-03T04:35:00.001-08:00

Bert P. Krages Attorney at Law Photographer's Rights Page

As a photographer it looks like you're living on the edge a bit if you're taking pictures of anything else but the eight feet tall sunflower in your backyard.

Bert Krages has put together a leaflet that helps to assess the process of taking pictures and it seems that under United States law this process is relatively liberal in favor of the photographer (I just wonder who will now take on this law - after I used this term "liberal").

It does not address the issue of "publishing" yet - i. e. it seems you can take hundreds of pictures in public places (I do that a lot), but you might be supposed to let them rot in your binders, drawers or on your hard drive.

I think I'll explore more of this issue, especially the role of "Model Releases" in a later post.

Cheers

GIMP - The GNU Image Manipulation Program

2009-03-02T20:20:00.000-08:00

GIMP - The GNU Image Manipulation Program

Let's face it: Photoshop still is the standard, but
the GIMP is slowly catching up in terms of power and popularity.

Yes: Photoshop is still my tool of choice, but more and more tasks are pushed over to GIMP, because once you're getting into the learning curve with it - even coming from Photoshop - it starts to grow on you.

Guess, I'll talk a bit more about both in the coming weeks, probably by first outlining the various sources of information and then going into some slightly more advanced ideas to work out in GIMP.

It's worth it, it seems...

Until then