[ Posted by Urban Hafner ]
It might not be news to everyone, but sometimes I’m slow at taking up new things ;) There’s now Nature’s Podcast a Podcast from the science magazine Nature. They talk about interesting papers in the latest editions of the magazine and a bit about the News in science.
The quality is acceptable, though sometimes the telephone interviews aren’t all that great. But that’s not so much of a problem I guess as there’s also a transcript of every podcast.
[ Posted by Urban Hafner ]
by Chad Fowler
As the title might suggest this book is about offshoring of IT jobs. Though the offshoring is just the linchpin to tell you that your job is not as save as it used to be and that you actually have to do something to keep it.
It’s divided into 6 parts (the text in italics are my additions):
Each part is further subdivided resulting in 52 chapters. Each chapter is two or three pages long and talks about a specific topic. When applicable the chapters end with a small section about what you can do about this specific issue.
This style makes the book remarkably like the Pragmatic Programmer, which is not so surprising when you think about that the authors of the Pragmatic Programmers are the publishers of this book. Just like it the book gives you little snippets of knowledge that you can work on separately and that put together can have a huge impact. Also like the Pragmatic Programmer you have to revisit many of the chapters more than once to actually achieve what’s described therein.
So if your are ambitious about your job and want to keep it, get this book and start investing in your career. Or one day someone else might come around who has done it.
[ Posted by Urban Hafner ]
A while ago I found a link to a Science article on the sequencing of part of the mammoth genome on Stephen Rudd’s blog . The article itself is quite technical and therefore not the most interesting read ever, but it’s interesting to know how far you can get with sequencing the genome of an extinct species. After all they managed to sequence 3,000,000bp.
Also, you get to read the words metagenomics and paleogenomics. Which might either make you run away screaming or inspire you to create new ones (anyone for meta-paleo-metabolomics? Submission of better (i.e. longer and less comprehensible) ones now open)). ;-)
[ Posted by Urban Hafner ]
This is mostly a reminder to myself so that I know where to find it next time.
Today my iPod (G4) started skipping the last 20 seconds (or so) of each song it was playing. Being a computer guy I assumed that rebooting the iPod would probably fix this. Googling for “ipod reboot” I found this weblog entry.
Just in case here’s what to do:
[ Posted by Urban Hafner ]
Just found a link to Where’s the Real Bottleneck in Scientific Computing? on the BioWeka Blog. It’s basically about scientists writing software without knowing much about it. As the title of this entry suggests, when asked if they use version control you might well get the answer “What’s version control?”.
Thinking of bioinformatics, I have the feeling that we’re getting there slowly. As more people get in there that have studied bioinformatics (like me :)), and more computer scientists too, we might see them influence their biology colleagues to apply more “common” tools to their programming.
[ Posted by Urban Hafner ]
Dataflow behaviour in a concurrent setting. Consider the function {Filter In F}, which returns the elements of In for which the boolean function F returns true. Here is a possible definition of Filter:
fun {Filter In F}
case In
of X|In2 then
if {F X} then X|{Filter In2 F}
else {Filter In2 F} end
else
nil
end
endExecuting the following:
{Show {Filter [5 1 2 4 0] fun {$ X} X>2 end}}displays
[5 4](We use the procedure Show, which displays the instantaneous value of its argument in Mozart’s emulator window. Unlike Browse, this output is not updated if the argument is subsequently bound.) So Filter works as expected in the case of a sequential execution when all the input values are available. Let us now explore the dataflow behaviour of Filter.
a) What happens when we execute the following?:
declare A
{Show {Filter [5 1 A 4 0] fun {$ X} X>2 end}}A that is not yet bound to a value. Remember that the case and if statements will suspend the thread in which they execute, until they can decide which alternative path to take.
b) What happens when we execute the following?:
declare Out A
thread Out={Filter [5 1 A 4 0] fun {$ X} X>2 end} end
{Show Out}Show displays its argument as it exists at the instant of the call. Several possible results can be displayed. Which and why? Is the Filter function deterministic? Why or why not?
c) What happens when we execute the following?:
declare Out A
thread Out={Filter [5 1 A 4 0] fun {$ X} X>2 end} end
{Delay 1000}
{Show Out}{Delay N} suspends its thread for at least N ms. During this time, other ready threads can be executed.
d) What happens when we execute the following?:
declare Out A
thread Out={Filter [5 1 A 4 0] fun {$ X} X>2 end} end
thread A=6 end
{Delay 1000}
{Show Out}a) Nothing is displayed because Filter is suspended waiting on A to become bound.
b) What gets displayed on my box is Out<optimized>. But when I use the Browser I see 5|_. Another possible value would _ if Show is executed before Filter. But even though there can be different values shown doesn’t mean that Filter itself is not deterministic. What’s not deterministic is the way threads are executed and Show is probably not part of the declarative model.
c) This displays 5|_<optimized>. So it seems that the calls to Show in b) that I got were all before the call to Filter.
d) This of course displays [5 6 4]. Filter can finish because A gets bound, and we are waiting long enough before calling Show.
[ Posted by Urban Hafner ]
Programmed triggers using higher-order programming. Programmed triggers can be implemented by using higher-order programming instead of concurrency and dataflow variables. The producer passes a zero-argument function F to the consumer. Whenever the consumer needs an element, it calls the function. This returns a pair X#F2 where X is the next stream element and F2 is a function that has the same behavior as F. Modify the example of section 4.3.3 to use this technique.
declare HGenerate HSum
fun {HGenerate N}
N#fun {$} {HGenerate N+1} end
end
fun {HSum Limit F A}
if Limit>0 then
X#F2={F}
in
{HSum Limit-1 F2 A+X}
else A end
end
local X F in
X#F={HGenerate ~1} % Yes, the ~1 is correct!
{Browse {HSum 150000 F 0}}
end[ Posted by Urban Hafner ]
Thread scheduling. Section 4.8.3.2 shows how to skip over already-calculated elements of a stream. If we use this technique to sum the elements of the integer stream in section 4.3.1, the result is much smaller than 11249925000, which is the sum of the integers in the stream. Why is it so much smaller? Explain this result in terms of thread scheduling.
What probably happens is that generating another element in the production thread is so fast that more than one ca be generated in one time slice. When the consumer thread restarts in the next slice it only takes the last element computed, so it loses some (or many) elements.
[ Posted by Urban Hafner ]
Pom Pom Pom Pom ist ein deutschsprachiger Podcast über Macs. Gemacht wird er hauptsächlich von StuFF mc einem Spanier der in Belgien aufgewachsen ist und deshalb Französisch spricht, aber jetzt in Deutschland lebt … oder so :) Natürlich spricht er mit dem tollen französischen Akzent den wir alle so lieben.
Das schöne an diesem Podcast ist, dass sich StuFF mc mit seinen Gästen einfach über alle Sachen die gerade in der Mac-Szene aktuell sind unterhält und sich nicht an normale Interviewstrukturen hält. Wie er so schön sagt: “Wie wenn wir zusammen am Lagerfeuer sitzen würden.”
Also auf geht’s zu Pom Pom Pom Pom
Some advertising for a german Mac podcast.
[ Posted by Urban Hafner ]
The Wait operation. Explain why the {Wait X} operation could be defined as:
proc {Wait X}
if X==unit then skip else skip end
endUse your understanding of the dataflow behavior of the if statement and == operation.
The idea of Wait is to wait until its argument become bound. The == (i.e. the entailment check) is used to make the procedure wait. The if statement is needed, because == returns a value but Wait doesn’t. To get rid of this value you simply wrap the call to == in an if statement and let the if return nothing.
