I mostly agree with most of the technical issues he raises and I think the lesson here is that it does, in fact, pay to use open standards. However, there are some things he says that I take issue with as a developer:

Replacing flash with H.264 is not an option right now for several reasons. Firstly, flash isn’t simply a way to view video. At present there is no way to have interactive elements in a web page that work on desktop and iP* other than javascript, which has its interoperability problems (though the jQuery and prototype folks usually do a good job at sorting that out for you). Second is the notion that H.264 already is the default format for HTML5. No, it is not. That has not been decided yet. Hopefully H.264 doesn’t win since it, too is proprietary, the very thing Jobs takes issue with for Flash! I even notice that at Apple stores, the employees are basically told to tell this tale to customers who are web developers that they should just replace everything with HTML5 and H.264. I hope that Google does open-source VP8 and that it becomes the format that wins, or VP8 and Ogg and that Apple doesn’t kick and scream in protest when they win the HTML5 video format wars. We don’t want .gif part 2!

Jobs also has a disdain for 3rd party development tools. Here I see the motivation as business, not technical. We developers have only so much time-money and Jobs knows that making it difficult to support multiple platforms with the same source tree more or less will make a lot of developers chose to develop only for Apple’s products. Jobs knows this very well and I believe it was behind the decision not only to not allow Flash but also to not allow Java. Jobs even boldly chided Java as something no one uses anymore. No one? Well, except for their mobile devices’ biggest upcoming competitor, the Android platform. That’s all.

When developing C++ desktop applications, I don’t want to waste my investment. I use Qt. It doesn’t block me from using the latest innovations in Windows, Mac OS X or Linux’ desktops (KDE and Gnome), but it gets me most of the way easily. 90% of the time for 90% of the people making business apps (not games), OS specific GUI code shouldn’t be necessary. I believe the same is true for mobile devices. Without writing with the iphone in mind, I believe you can have your tool translate your menus, form items, etc. into the appropriate code for different platforms. Apple won’t allow this. My understanding is they won’t even allow this if such a tool (including the tool Adobe made earlier to translate Flash into Obj-C) even if you hand-edit the code after generation or make your own regexp to modify after generation (so at least minor edits won’t require a rewrite to remove wasteful routines, etc.) This is a shame. It’s bad for developers and consumers, but good for Apple. It also directly affects me as I was planning on making an XUL to iphone gui converter.

So again, I absolutely agree with Jobs’ assessment of Flash’s shortcomings. If he is serious about them, though, I trust that he will allow Flash once they are addressed? If Adobe fails to correct these issues and it may be impossible without breaking backwards compatibility, their prize platform may go the way of the Dodo, with or without Apple’s sabotage. At the very least, I believe something that creates obj-c from an AS3/Flex project should technically address the issues.

Lately, I’m increasingly thinking, especially after reading this article, that evolutionary computing would benefit greatly from using a more bacterial type of evolution, where genes are shared between often unrelated organisms, rather than brute inheritance. Another way of looking at it, is it might be good to deal with the complexities of subroutine sharing (which functional programming would make easier) than the complexities of sexual reproduction which make my eyes glaze over to read the solutions offered for. Maybe I’m just not clever enough (my earlier post on genetic programming had a little ruby script and it only uses asexual reproduction).

I am skeptical of the article’s claim that the shared genetic code of all organisms must mean that genes were shared between organisms like bacterium do today. Firstly, bacterium don’t all share some common genes due to the passing of genes between species as it is. Secondly, clade evolution – where clades that are just better at evolving edge out others over time could be sufficient explanation. Surely DNA-based life had immense advantages over life with less fault-tolerant code. Just the same, the article makes a good point that biologists are, being human macro-centric – they focus on multi-cellular organisms even though most of the biomass, even more of the variety, along with the vast, vast majority of the history of life on this planet, is prokaryotic.

[erlang]
-module(sort).
-export([quicksort/1,mergesort/1]).

less([Head|Tail], Pivot) when Head >= Pivot ->
less(Tail, Pivot);
less([Head|Tail], Pivot) when Head < Pivot ->
[Head|less(Tail, Pivot)];
less([],_) ->
[].

more([Head|Tail], Pivot) when Head >= Pivot ->
[Head|more(Tail, Pivot)];
more([Head|Tail], Pivot) when Head < Pivot ->
more(Tail, Pivot);
more([],_) ->
[].

quicksort([Head|Tail]) ->
quicksort(less(Tail,Head)) ++ [Head] ++ quicksort(more(Tail,Head));
quicksort([]) ->
[].

% For reference, here’s the quicksort from wikipedia’s page on erlang… much better-looking than my crap (but in my defense, I didn’t know how to do this kind of list construction… cool!)
% quicksort([]) -> [];
% quicksort([Pivot|Rest]) ->
% quicksort([Front || Front <- Rest, Front < Pivot])
% ++ [Pivot] ++
% quicksort([Back || Back <- Rest, Back >= Pivot]).

merge([Head1|Tail1],[Head2|Tail2]) when Head2 > Head1 ->
[Head1] ++ merge(Tail1,[Head2|Tail2]);
merge([Head1|Tail1],[Head2|Tail2]) when Head2 =< Head1 ->
[Head2] ++ merge([Head1|Tail1],Tail2);
merge([],[]) ->
[];
merge(End,[]) ->
End;
merge([],End) ->
End.

mergesort([]) ->
[];
mergesort([Left]) ->
[Left];
mergesort(List) ->
{Left, Right} = lists:split(length(List) div 2, List),
merge(mergesort(Left), mergesort(Right)).

[/erlang]

[erlang]
-module(db_lists).
-export([new/0, destroy/1, write/3, delete/2, read/2, match/2]).

new() ->
[].

destroy(Db) ->
ok.

write(Key, Element, Db) ->
Db ++ [{Key, Element}].

delete(Key, List) ->
lists:keydelete(Key, 1, List).

read(Key, List) ->
case (lists:keyfind(Key, 1, List)) of
{MatchKey, Element} ->
{ok, Element};
_ ->
{error, instance}
end.

match(Element, [{DbHeadKey, DbHeadElement}|DbTail]) ->
case DbHeadElement of
Element -> [DbHeadKey] ++ match(Element, DbTail);
_ -> match(Element, DbTail)
end;
match(Element, []) ->
[].

[/erlang]

[erlang]
-module(list).
-export([filter/2, reverse/1, concatenate/1, flatten/1]).

filter([Head|Tail],Num) when Head =< Num ->
[Head|filter(Tail,Num)];
filter([Head|Tail],Num) when Head > Num ->
filter(Tail,Num);
filter([],_) ->
[].

reverse([Head|Tail]) ->
reverse(Tail) ++ [Head];
reverse([]) ->
[].

concatenate([Head|Tail]) ->
Head ++ concatenate(Tail);
concatenate([]) ->
[].

% Probably possible to make this a LOT more efficient, ne
flatten([Head|Tail]) ->
flatten(Head) ++ flatten(Tail);
flatten([]) ->
[];
flatten(NotArry) ->
[NotArry].
[/erlang]

[code lang="erl"]-module(db).
-export([new/0, destroy/1, write/3, delete/2, read/2, match/2]).

new() ->
[].

destroy(Db) ->
ok.

write(Key, Element, Db) ->
Db ++ [{Key, Element}].

delete(Key, [{DbHeadKey, DbHeadElement}|DbTail]) ->
case DbHeadKey of
Key -> delete(Key, DbTail);
_ -> [{DbHeadKey, DbHeadElement}] ++ delete(Key, DbTail)
end;
delete(Key, []) ->
[].

read(Key, [{DbHeadKey, DbHeadElement}|DbTail]) ->
case DbHeadKey of
Key -> {ok, DbHeadElement};
_ -> read(Key, DbTail)
end;
read(Key, []) ->
{error, instance}.

match(Element, [{DbHeadKey, DbHeadElement}|DbTail]) ->
case DbHeadElement of
Element -> [DbHeadKey] ++ match(Element, DbTail);
_ -> match(Element, DbTail)
end;
match(Element, []) ->
[].

[/code]

I will be posting my attempts at the exercises, in case others might find it useful or seasoned Erlang programmers might tell me what I may be doing wrong. I’ll be spacing out my answers to chapter 3 over the week to keep things interesting. Here are the first three exercises from Chapter 3:

[erlang]-module(chapter3).
-export([sum/1, sum/2, even/1, create/1, reverse_create/1]).
-import(erlang).

sum(Num) when Num > 1 ->
Num + sum(Num – 1);
sum(Num) when Num == 1 ->
1.

sum(N,M) when N < M ->
M + sum(N,M-1);
sum(N,M) when N == M ->
N;
sum(N,M) when N > M ->
erlang:throw({‘EXIT’,{bad_argument}}).

reverse_create(N) when N > 1 ->
[N|reverse_create(N-1)];
reverse_create(N) when N == 1 ->
[1].

create(N) when N > 1 ->
create(N-1) ++ [N];
create(N) when N == 1 ->
[1].

even(N) when (N > 0) and (N rem 2 == 0) ->
io:format("Number:~p~n",[N]), even(N-1);
even(N) when (N > 0) and (N rem 2 == 1) ->
even(N-1);
even(N) when N == 0 ->
done.
[/erlang]

http://blog.dubh.org/2007/11/configuring-mac-os-x-terminal.html
http://www.starryhope.com/tech/apple/2006/keyfixer/

Old posts, but very, very helpful. There really should just be a system-wide option, something like “home and end keys operate on line, not document”. Indeed, the primary reason I’m making such a banal post is I hope Apple’s marketing research finds this and maybe does something about making the growing UNIX nerd & programmer user base a lot happier..

I know the people researching gp are really smart, so there’s probably something I’m missing, but I don’t see how genetic programming is supposed to quickly find solutions. Evolution is as slow as molasses. You need to dig through millions of years of dirt to see actual changes. I can only see gp quickly finding solutions if the process is being run continually, with multiple challenges or “resources”. I was glad to see, after having this thought, mention of multi-objective (5.1.3) and coevolution (5.4) in the book. It makes me think I’m on the right track. I also remember a while back reading in the article Discover had about Avida that when there was only one resource, one species would quickly capitalize on that and then the evolution would stagnate, but having multiple resources would create diversity and even better solutions at attacking that one resource. The ability of organisms to repurpose adaptations is important in evolution and without it, most complexity would not have been possible.

This leads me to another point. It seems gp works best when it works the most like evolution in the real world works. The rate of mutation is low and, despite my initial intuitions that a high mutation rate would lead to a good solution more quickly, I found that it was actually harmful to do so. Even though, in this script, there is a bias towards shorter programs (the longer the chromosomes, the more calories it takes to create just one offspring), when I had a higher mutation rate, like, say, 1 out of 5 copies, the length of the genes would get really, really long as a defense against mutations. This could happen because if the last parenthesis of the mini-lisp program is closed prematurely, the rest of the genes are ignored. Junk dna. In my program, at least, junk dna was a defense against mutation since I would get really short programs that have long tails of junk after them, but decreasing the mutation rate shrunk those tails down to almost insignificant. Weird. Please try downloading this and edit it to see for yourself.

While mutations should be rare, it helps to have variety. I did just substitutions at first and it worked, but it took a while. I also added stutters, insertions and deletions. Once I added stutters, it helped a lot! Even before adding stutters, I found that, when the “challenge” was 6 * x, I would get x + x + x + x + x and something like 7 * x competing with each other for a long time (5x or 7x often becomes the leading candidate after a few generations and it takes forever for any 6x to show up). Adding the stutters seemed to get multiplication through addition happening faster, though.

Download yeasties or copy/paste from below (requires ruby and clisp):

How it works: (feel free to ignore italicized parenthetical comments if they confuse or distract you.. they can be safely ignored and are there for anyone wanting to play around with the program)

This is a basic, single-objective instance of digital evolution. Organisms only reproduce asexually. As you can see in the code, the “dna” is just a sequence of lower-case letters (feel free to modify that array for aesthetic purposes, but keep in mind that there should be at least 30 elements or so in the array for this to work right). Each organism has its own sequence of dna. For the first generation, it is generated randomly, for any generation after that, it is a copy, occasionally mutated, of its parent’s. This dna is used to generate the “protein” or mini-program that will be run. The mini-program is in in lisp, rather than ruby (it should be quite easy to change that to be generated ruby code and just use eval() on it, though lisp code is easier to generate and we have the advantage of being able to easily add ‘time’ to the command, and factoring in how computationally intensive it is into the equation. I started to set that up, but found that in this program, it’s almost always a split second and the differences have nothing to do with the code in question… just something to consider for larger programs in the future).

When reproducing, the mini-programs must expend calories to do so, in proportion to the length of the chromosomes. Simpler life is cheaper to create, but a) more susceptible to mutation (assuming longer chromosomes also mean more junk dna) and b) less likely to be the solution in cases where the challenge is complex. The amount of calories that is given to an “organism” to reproduce is proportional to its fitness. See next paragraph for how fitness is evaluated. This dna is then used to generate the “body” or “proteins” of the organism, which is simply a small program in lisp (basically two lines, the first simply being the line to feed the program a value). The generation of the program works like this: there are different modes, such as “operator is okay” or “variable or constant only”. Each gene is evaluated in sequence, starting with the operator mode. Depending on what is selected, the mode will change, so ‘a’ might be 1 in terminal mode or + in operator mode. This ensures that only legal programs are being made. If you understand lisp, this’ll make sense (I don’t really understand lisp, but I can fake it): once the last parenthesis is closed, the generation ends and the rest is essentially junk dna. Junk dna can protect against mutation (since a mutation is statistically less likely to affect working code) but it also means offspring are more expensive to produce without any additional working code..

Each mini-program runs with a parameter being fed to it and is evaluated based on what it spits back out. If it evolves to not have x in it, then it will be ignoring that parameter to its peril (unless we set the challenge to something that also doesn’t have x in it, like a constant number, in which case x is unnecessary noise though, at a 0 to 1 range, minor noise at that). For each generation, the x is set to the percentage of the minute (seconds divided by 60) or to that number times something else. This makes the program good for doing regression within a range since you can just multiply this number by the range and add the minimum point. For example, to do a sine function, do the sin of pi times this number (there’s no way in hell this script is going to generate the formula for sin, though I’d love to be proven wrong.. maybe only a few more lisp operators need be added…) The program doesn’t self-terminate unless all the life goes extinct (which happens sometimes with code bloat.. if the genome sizes get too big, usually through stutter, life forms quickly cease to be able to afford but one child.. this is why I’m considering creating a hard limit on the length of stutter). The program’s fitness is determined by how distant its result is algebraically from the correct answer (I’m just using the absolute value of the difference). You can specify how close it must be to be within the baseline. If it’s not that close, then its fitness is negative and it will die without reproducing. The fitness provides the calories it needs to create the following generation.

After the next generation is created, the organisms are sorted by fitness and the least fit are killed until there’s only WorldSize left, WorldSize being what we decide the population to be at the top. Rinse, lather, repeat. You can start this program and step away if you want to have your computer do something useless for a while. Or, better yet, you can probably program it to do something useful, though this isn’t using the best practices at this point and should be looked at as the simplest you can make gp and it still work. Perhaps this represents life in a primitive pre-dna state and gp will only be useful once its as sophisticated and awesome as dna. We don’t have to start at cosmic ooze and wait. We know how the story ends, so we can fast forward…

Overall, the program is mostly self-explanatory, but feel free to leave any comments or ask any questions about it. It’s a good learning experience and it’s certainly giving me some ideas…

</p> <p>Your browser does not support iframes, so just download the code directly <a href=”/code/yeasties.rb” mce_href=”/code/yeasties.rb”><span><span>here</span></span></a>.</p> <p>

I was frustrated trying to get my flash player to do bandwidth detection, then stumbled on this site.. Apparently, there’s a bug in FLVplayback? Psh.