'Work ethic' vs. Relaxation in startups

Posted by ungraspiness Thu, 01 May 2008 06:14:00 GMT

welcome back mr. sun (beltaine is here)

This collection of paragraphs is about * BIG SIGH *

...working in startups however much of it might apply elsewhere. (Like there isn’t enough to read about this over-hyped topic on the web already).

Actually the following is definitely worth reading for the even slightly curious reader. It was definitely worth my time to write it (even though it’s one of my least favorite topics)

Here goes…

The middle class mantra, or what parents often tell their children(and what adults often tell themselves and their piers), what employers try to drill into their employees about ‘getting somewhere’ in life. It usually goes something like this, “Son/Employee/Friend, the only way to get anywhere in life is to work damn hard, hell that’s how I got my gold-plated watch for 25 years of service(or my 0.000001% of the company share pool). I’m proud of the fact that I haven’t slept for more than 4 hours a night in the last 10 years.”.

Strange considering that those who usually are truly ‘successful’ never seem to follow such literally brain-dead reasoning. However it’s often shocking that many startups have some kind of reasoning very similar to what our parents may have told us about ‘work ethic’. Not to say that the 20-somethings who get lucky never worked crazy hours or that they don’t work their asses off for 4 years(these days it can sometimes turn out to be even less than that, the youtube founders are a great example of this and who wouldn’t like to be in their shoes ?). They do but it’s hardly the mantra. As if working longer instead of just working smarter means greater success somehow.

The ‘work ethic’ train of logic pushing us to ‘work harder’ usually stops at the dead-end stations of thought such as ‘we need to work more hours !’, ‘our product needs more features !’ or ‘we need to be done today!’ . This is a slow(even sometimes a very quick) poison for most startups. In other words, good luck buddy !

Now by startups the author is hardly referring only to certain companies that describe what they do as ‘social debt-working’, ‘viral carpeting’, ‘crash-ups’ or whatever other 2006 startup-speak jammed so many starry-eyed founders heads that they didn’t stop to think about their clients and product.

That brings up an interesting detour: clients. Now by giving clients what they need or want I don’t mean doing whatever they ask, the gap between those two things are like the distance from earth to Saturn(pretty damn far apart one might say resulting in large time sinks). Clients/Users might say something like ‘please give us a super-widget that can do X to the power of infinity things, pretty please!, if you code it by tomorrow we’re sure that you would put every other startup out of business because OH MY GOD it can do everything and more than any other web site can !!!’. Yes they may say that type of thing, even get on their knees and beg you for the ONE TRUE ‘DO EVERYTHING’ WIDGET or threaten your web 2.0 being to the core by promising to never visit your site again and to tell all the kids on the playground to do the same. What I’ve noticed is that no matter how much people say this, often they will do the complete opposite if you give them a few features that they really like using. The widget with the few good features is something they will actually get to see because you won’t run out of time AND they will likely use it long before the ‘DO EVERYTHING’ widget that’s half-baked sees the light of day(if ever). Successful startups have this in common, they solve one or two hard problems(sometimes they just need to push further toward a solution) to be successful. The ones that aim to solve all the world’s problems usually never make it. Please email me if you know of one.

This leads into yet another little detour: The startups that realize some level of success often have the least management. They don’t need to meet about having a meeting. In fact there will be little evidence(if any) of having to manage programmers or anyone else. If a startup hires good programmers then why do they need management ? If founders strongly feel they need to manage their programmers then why did they hire those programmers to begin with ? Who the heck has time to manage developers in a startup planning on actual success ? Yes, yes I know, hiring good(never mind great) programmers is very hard. But when you have even one of those kinds of programmers(the good ones also don’t require flattery just simple acknowledgment) you better treat them well, very well, because your company’s success depends on them being happy for a large portion of the time, DUH !

Also, when you have hired one or two of these kinds of programmers you really really really should let them decide on the next batch of programmers to hire. Unless you are as skilled/experienced as they are collectively and you spend most of your time coding in the company then take their advice, you’re paying for it after all !

Ok back to the main track:

An article from CNN dated 2006-03-16 called “Be smarter at work, slack off” had the following nuggets for founders(even though they were probably directed at managers)

“But it’s really, really hard, if not impossible, for the human brain to come up with fresh new ideas when its owner is overworked, overtired, and stressed out.

and..

“The physiological effects of tiredness are well-known. You can turn a smart person into an idiot just by overworking him,” notes Peter Capelli, a professor of management at Wharton.

and my personal favorite…

“Indeed, “the notion that busyness is the essence of business can only do us long-term harm,” writes consultant Tom DeMarco in a book called Slack: Getting Past Burnout, Busywork, and the Myth of Total Efficiency.”

Forget multi-tasking, it’s one of the worst productivity killers. You don’t even need a neuro-scientist to tell you that just go read the excellent ‘Brain Rules’ by John Medina (ok, he is a neuro-scientist but the book is a well-paced read). Considering the strongest point in the US economy is innovation(and will never be mass production) why do managers prefer to manage as if things were an assembly line ? Archimedes, Newton, Einstein, Tesla and a long list of other creative guys always started with relaxation to get the mind into a powerful thinking mode. Another thing that stands out is that the article was written back in 2006 by CNN. If they get it then why don’t many startups ?

David Heinemeier Hansson has posted recently about sleep deprivation : ‘Sleep deprivation is not a badge of honor’. Word.

Let’s wrap this up on a positive note with some basic advice :

Get enough sleep, drink enough water and don’t forget exercise is incredibly worth it not just for your body but also for your mind(not to mention that it leads to the previous two). Increased oxygen flow to the brain cannot be underestimated.

Good luck !

Posted in Software, Programming | Tags startups, Work

Firefox 3.0 BETA 2 on FreeBSD 6

Posted by ungraspiness Sun, 06 Jan 2008 00:05:00 GMT

UPDATE (2008-01-06) : Here’s a 64-bit build for amd :

firefox-3.0b2-en-US.freebsd62-x86_64-static.tar.bz2
(md5 21bfa5c75d9b3df11f939a07a9bb94bc)

If anyone wants to test Firefox 3.0 BETA 2 on FreeBSD then then here’s a static build. (I’ve only tried it on 6.2 let me know if you have a different version)

firefox-3.0b2-en-US.freebsd62-i386-static.tar.gz
(md5 0a8035908790bfb2d0b1e14eeb8407c0)

I couldn’t find a 3.0b2 build for FreeBSD on the Mozilla site. Pretty normal though I’m guessing most FreeBSD folks just wait for newer versions to show up in Ports.

If you want to compile a build yourself then take a look here .

Posted in Software, BSD, Programming | Tags Browsers, web | no comments | no trackbacks

Dude, your quad-cores have been smoking way too much Haskell !

Posted by ungraspiness Fri, 30 Nov 2007 05:26:00 GMT

Some Haskell fans seem impressed with better performance for a fibonacci function compared with similar implementations in Ruby and Python. They should be.

Read this and this before going on.

Impressive. Yea I thought so too until I implemented a fib function of my own in Lisp and ran it on SBCL.

Here it is…

(defun printfib-trec (start end)
  (format t "n=~D => ~D~%" start (fib-trec start))
  (if (< start end)
      (printfib-trec (+ start 1) end)))

(defun fib-trec (n)
  "Tail-recursive Fibonacci number function"
  (labels ((calc-fib (n a b)
         (if (= n 0)
         a
         (calc-fib (- n 1) b (+ a b)))))
    (calc-fib n 0 1)))

* (time (printfib-trec 0 45))

...
n=43 => 433494437
n=44 => 701408733
n=45 => 1134903170
Evaluation took:
  0.001 seconds of real time
  8.66e-4 seconds of user run time
  4.4e-5 seconds of system run time

My machine is a core2 duo macbook. i.e. it’s similar to a dual core machine.

Now it gets even better here are the results for N=4500

* (time (printfib-trec 0 4500))

...
n=4498 => 4752485956810555875004869018963973043700525724009578868769474882879459154152204647915407885135917631883990751157075912405221725368578720671564885897475897464613262304334914241607212435329497497641975738086751054186028251736658640131563596639794912789288873499340565150498450487979214802149192686689502839297300024458433225040572133069627134796358948692382679582705607173927112950805086075483639678885680596072818462793625622001172877975597935926640708898109961081915885811381688288593609679366923395036172748038315089504487795839374129751161426896402825970560364499274889268094208129756388749789034972452896098894495061580172690522720566378084685514727191994472473978536748311552532810887686013014142033821544140905176979343962968937988421450684068500158256897979615387686994353406906126123537769868642652059566362453067042981495901311000274164675176218086106464588110191710522184013092019809003619950257701727043382807151105254869074540999
n=4499 => 7689683809176044218107840158125230568446917722620919869236097185282672128990041547590451591499923310831823312141560648669244546575977267500013883217226532696996235625233074842634247978888031960169238969830083697466087304886911697471293091037341927771010057257419268694905456568117577378610866026860700484139627056952202998275203723635146181775748103435107099441981319375329968495793847287994466423823519958759013902933218530884486180862708252747927806488609582304095221977753080257381254319632253228943480013647285929110384030236906149951249019234788386174626368178393351733619384777746723301965464502113374050814595527544612527282323355098641401340340217066221028727128338402433420088106126843822136543545984881453537808419762831343814403375221726100769180787258588643276099557741697382968654545681825708651265429233690200167736105425793517509595122050585308615226674843578205297740460920468000168395676735878604229024852582106840990153001
n=4500 => 12442169765986600093112709177089203612147443446630498738005572068162131283142246195505859476635840942715814063298636561074466271944555988171578769114702430161609497929567989084241460414217529457811214707916834751652115556623570337602856687677136840560298930756759833845403907056096792180760058713550203323436927081410636223315775856704773316572107052127489779024686926549257081446598933363478106102709200554831832365726844152885659058838306188674568515386719543386011107789134768545974863998999176623979652761685601018614871826076280279702410446131191212145186732677668241001713592907503112051754499474566270149709090589124785217805043921476726086855067409060693502705665086713985952898993812856836278577367529022358714787763725800281802824825905794600927437685238204030963093911148603509092192315550468360710831791686757243149232006736793791674270298268671415079814785035288727481753552940277003788345934437605647611832003687361710064694000
Evaluation took:
  8.698 seconds of real time
  4.731282 seconds of user run time
  0.361252 seconds of system run time

Yes it only took under 9 seconds running in slime/emacs. Would probably be closer to 8 seconds on the command line.

As for the argument of Haskell being the easiest platform to benefit from multiple cores due to it’s parallel and concurrent libraries. The evidence contradicts that. No changes were required to the Lisp code above to have sbcl use all cores on my system. What would be easier ?

Also the readability of the Lisp code is far simpler.

Oops. Sorry Haskell…

BTW – Haskell is not faster than a C implementation either(at least one that imitates Lisp) but Haskell would be far more readable beyond a trivial C implementation like this—>

#include <stdio.h> 

unsigned long fib_trec(unsigned long n, unsigned long a, unsigned long b) {
  if (n==0) return 0;
  if (n==1) return a;
  if (n==2) return b;
  return fib_trec(n-1, b , a+b);
}

int main() {
  int i;
  for (i=0; i <= 45; i++) {
    printf("n=%d => %d\n", i, fib_trec(i, 1, 1));
  }
  return 0;
}

$ time bin/fib-c

...
n=43 => 433494437
n=44 => 701408733
n=45 => 1134903170

real    0m0.004s
user    0m0.001s
sys    0m0.003s

UPDATE : Thanks Don and the other guys for giving me a hard time for using an O(n) algorithm !

Maybe I’ve accepted the following quote for too long now ;-)

“The key to performance is elegance, not battalions of special cases.” - Jon Bentley and Doug McIlroy

Posted in Lisp, Programming | Tags Haskell

Reverse superclass envy and bad mental pointers

Posted by ungraspiness Fri, 31 Aug 2007 05:06:00 GMT

I’ve ranted previously about Python and made promises of future posts about why Ruby is so much cooler. It really is and the topic of this article covers one of the common idioms used by most Ruby folks who may have taken a shot at their own domain specific language in Ruby. The following is one of the really useful idioms but apparently not a very well understood or well explained one for Ruby coders.

class << self; self; end;

This is used a lot in the Rails framework. You shouldn’t have to look very deep into the Rails source code to find it. As an example I’ll guess that most Ruby coders are familiar with Why’s example for Dwemthy’s Array that explains the idiom.

class Creature
  def self.metaclass; class << self; self; end; end

  ... more code for meta-programming goes here ...

  traits :life, :strength, :charisma, :weapon
end

This then allows the definition of other classes derived from the Creature class such as these for our example:

class GreenMonster < Creature
  traits :greenness, :scariness
  life 90
  strength 45
  charisma 23
  weapon 80
  greenness 10
  scariness 12
end

class RedMonster < Creature
  traits :redness, :loudness
  life 75
  strength 50
  charisma 90
  weapon 65
  redness 20
  loudness 33
end

It seems that when it comes to understanding how this idiom works most of the confusion has to do with misnaming the key feature used in the Creature class, specifically the ‘metaclass’ in the code above. It’s usually called a meta-class(as in our example), shadow-class or class-object-instance-singleton , yikes!. (Adding in the additional popular belief that Ruby classes behave like objects can make this even more difficult to grasp. They do behave like objects but they technically are not like most objects in Ruby). Technically the ‘metaclass’ is a singleton for each derived class we have but this is not as important (and probably best ignored for now) as defining what the ‘metaclass’ really is in terms of object-oriented meaning.

Here I offer my attempt at another simple explanation:

The idiomatic line of code is merely a hack to obtain access to the sub/derived/child class (correct OO nomenclature). In Ruby, classes have access to their parent class via the ‘superclass’ method. The equivalent method to go the other direction i.e. ‘subclass’ would be very useful but because there is no such method the following hack is required. The scope that is accessible to the code between the class << self … end block has access to the derived class scope and so ‘self’ is returned from the block which is then returned from the parent class method ‘self.metaclass’. ‘self’ is the sub-class derived from Creature. In our example it’s either the GreenMonster or RedMonster class.

There is no magic in this idiom when this little expletive is made clear but the way it’s usually explained and the popular naming seem to be the main source of confusion. Once you look at this for what it is, there’s nothing magic except for the popular names applied to it. Maybe we should start using the more informative/explicit sub/child class naming and leave out the explanation of classes behaving as objects when explaining this useful idiom ?

or maybe that’s just me in the corner, in the spotlight…

Posted in Programming | Tags OO, Ruby

flecked

Posted by ungraspiness Thu, 26 Jul 2007 06:59:00 GMT

Flektor is really cool. It’s amazing(and really fun) what you can do with 40 minutes and some images:

‘Video game development approach to web app development

Flektor was acquired by Fox Interactive primarily for the great product that they built for personal media sharing. Unlike the more en vogue approach to Web 2.0 development of releasing early (and often times buggy), Flektor took an approach that is more common in the video game development business. Flektor invested time and focus up-front on building a platform (or toolkit) that would enable rapid iteration of the service in the future. ‘

These are the guys that founded Naughty Dog software afterall. They produced such titles as Crash Bandicoot as well as Jak and Daxter using their own platform called GOAL (Game Oriented Assembly Lisp). There’s no real surprise that they could get 20M+ for Flektor in just under a year.

Awesome guys !

Naughty Dog Software and Lisp

Flektor Case Study

Posted in Lisp, Music, Programming, Video | Tags Internet, web | no comments

Recursive reduction

Posted by ungraspiness Mon, 23 Jul 2007 03:39:00 GMT

The previous post was pretty grumpy about Python/Django and I was going to write a follow-up about why Ruby is a better language (unfortunately not the platform’s performance just yet but that is soon to change with YARV).

For this post to appear more fair about Ruby/Python than the last let’s look at one reason where these don’t come close to Lisp. This is something mentioned less often(but still important) when comparing Lisp with other languages which usually focus on macros and s-exprs.

Here’s a python snippet that was shared with me not so long ago:

def myreduce(f, t, list):
  size = len(list)
  if size == 1:
    return f(list[0], t)
  else:
    return myreduce(f, f(list[0], t), list[1:size])

It’s a reduce function^[1] that I’m not sure the author knows is buggy. It takes a function as the first parameter, an initializer value and the list to reduce.

import random
func = lambda x,y: x + y
>>> myreduce(f, 100, [1,2,3,4,5,6])
121

A first attempt at improving on this in Ruby:

def myreduce(l, t, &f)
  return yield(t, l[0]) if l[0] and l.size == 1
  myreduce( l[1..(l.size-1)], yield(t, l[0]), &f )
end

myreduce( [1,2,3,4,5,6], 100 ) { |x,y| x + y }   # returns 121

Much simpler (and terse) also using a block. Seemed to work just fine but what happens when we have a longer list to reduce, a million integers ?

myreduce( [*1..1000000], 100 ) { |x,y| x + y }

>SystemStackError: stack level too deep
>        from (irb):2:in `myreduce'
>        from (irb):3:in `myreduce'
>        from (irb):19
>        from :0

Oops, we run out of stack space ! The same problem exists in the Python version.

random_list = [random.randrange(1,1000000) for i in range(1,1000000)]
myreduce(func, 100, random_list)

> File "<stdin>", line 4, in myreduce
> RuntimeError: maximum recursion depth exceeded

We could increase the stack size but this is a hack and we would never have a large enough stack size for any practical purposes if we were to modify this code for real world use.

To have a more robust version we need to drop the recursive call and just use a loop. So the new Ruby version would look like this

def myreduce_loop(l, t, &f)
  tot = t
  for it in l
    tot = yield(tot, it)
  end
  tot
end

myreduce_loop( [*1..1000000], 100 ) { |x,y| x + y }
=> 500000500100

The Python version would be very similar. It’s obvious that the Lisp way of using recursion isn’t practical with Python or Ruby. Yes, there are ways to hack stack frames in Python and possibly in Ruby too.

In Lisp we can use tail recursion because this allows the compiler to optimize recursive calls so that the stack doesn’t blow up and performance is improved(hopefully).

(defun range(s e) 
  (let ((l nil))
    (do ((n s (+ n 1)))
    ((> n e) (reverse l))
      (setf l (cons n l)))))

(defun myreduce(f l &optional (i 0))
  (if (null l)
      i
      (progn 
          (if (null (cdr l)) 
              (funcall f i (car l))
              (myreduce f (cdr l) (funcall f i (car l) ))))))

(format t "~D ~%" (myreduce #'+ (range 1 1000000) 100))
500000500100

Ok so we’ll get back to why Ruby is still the next best language in the following post.

[1] Python’s built in functions include ‘reduce’. Search the page after clicking on the link.

Posted in Programming | Tags Lisp, Looping, Python, Recursion, Reduce, Ruby

Red vs. Blue (or don't be so blue man)

Posted by ungraspiness Thu, 12 Jul 2007 22:05:00 GMT

Pointing out the cons of a language like Java can be risky. The responses sometimes are that such attempts are based on highly subjective opinions. Let’s take byte code manipulation for example. Many Java coders find this invaluable for doing anything remotely interesting in Java. After all it’s heavily used in servlet containers and object-relational mapping tools such as JDO implementations. How is this not an invaluable feature ? Well, a Lisp hacker knows Java byte code manipulation to be a con because they can’t help but compare it with Lisp’s macros. Byte code manipulation is still a con for Java programmers too, it’s just that many of them may not be aware of why this is so. It’s really not a case of subjectivity but of awareness(or lack thereof) on the part of those that make the statement against anyone that’s able to see the cons of Java byte code manipulation (or any of Java’s other cons). Seems obvious enough and probably one of the reasons that Sun has so happily backed the current JRuby project.

This entry started after reading a somewhat biased comparison of Ruby and Python which still made some good points (or at least it made me write this !).

First off, Ruby’s meta-programming is superior to Python’s in terms of simplicity and power. Nothing new here .

Now that we have that stuff out of the way here’s another biased article with my points of view. Let’s look at some issues with Python/Django…

Snake Bites

  result = {
    'a': lambda x: x * 5,
    'b': lambda x: x + 7,
    'c': lambda x: x - 2
  }[value](x)

  class Example:
    def method(self, x):
      print "method was passed ", x

class thing:
  count = 0
  def __init__(self, value):
    self.value = value
    thing.count += 1
  def getval(self):
    return self.value
  def getcount(cls):
    return thing.count
  counter = classmethod(getcount)

There are so many examples that could follow but let’s leave it at these and figure out why we have…

Too much gas

• White space: (there I said it) Python’s significant white-space is part of the reason for Django’s crappy and almost unusable template syntax.
• Design: Unrelated (but still annoying) is Django’s broken MVC design. Django calls a controller a view, there’s an unnecessary model layer for form handling (manipulators and now forms which are really just new manipulators) and views are templates that support a funky object-oriented hierarchy similar to ASP.Net (but easier to grasp).
• Badly used meta-programming: Decorators are used in Django to change parameter types and not in the way that you may find useful like for form handling, where converting strings to integers would be useful.
• ORM: The Object Relational mapping features require a degree in HtHdtW(How the hell does this Work!). e.g. Entry.objects.exclude(pub_date__gt=datetime.date(2005, 1, 3)).exclude(headline=’Hello’) Why all the double underscores ? Tried multi-table queries recently ? or how about database transactions (they need to be defined in a view?!). SQLalchemy is supposed to transmute this lead into gold in the near future and it honestly does look like a big improvement.
• Debugging: Trying to debug a Django application more complex than “hello world” can be really difficult. Django has no logging facility so some pretty cool folks have taken this upon themselves
• Community: Has anyone had any success in submitting bug fixes for these ? (I don’t know anyone that has) Any sizable project I’m aware of has had to do a fork of the framework.
• Why is Django’s version number so close to 1.0 at this point ?

This provides some valid reasons as to how language can play a role in the frameworks built using them. Language effects how programmers think about problems (more so than they realize sometimes) and this can effect what and how certain things are built with a language.

Now, to the person who first responded to the comparison article: Are most of Python’s(and as an extension Django’s) cons just highly subjective ? It seems more like we all love to call them just “preferences” and repeat the mantra of peaceful language/framework co-existence in spite of what we remain unaware of in other languages (or worse, remain in denial of).

Co-exist ?

Negativa

So Python/Django are pretty cool but Ruby/Rails are much better and Lispy frameworks are best(but just not as widely accessible… ...yet). Hopefully Ruby/Rails heads even further in the direction of Lisp. It does seem very likely with cool projects like RLisp starting to take shape.

the end

Posted in Philosophy, Programming | Tags Django, Lisp, Python, Rails, Ruby

Making class methods re-usable from modules (in Ruby)

Posted by ungraspiness Mon, 25 Jun 2007 21:56:00 GMT

module TestMod
end

def TestMod.append_features(klass)
  def klass.method
    puts "#{self}: in method" 
  end
end

class Class1
  include TestMod
end

class Class2
  include TestMod
end

Class1.method()
Class2.method()

This should work even without the authors code available.

Posted in Programming | Tags Ruby | no comments

RIA/D

Posted by ungraspiness Thu, 24 May 2007 21:10:00 GMT

Thanks John for bringing this one up.

The Regressive Imagery Dictionary (RID) is a coding scheme for text analysis that is designed to measure ‘primordial’ and conceptual content. Primordial thought is the kind of free-form, associative thinking involved in fantasy and dreams. Like Freud’s id, I guess. Conceptual (or secondary) thought is logical, reality-based and focused on problem solving.

RID contains about 3,000 words grouped into categories that are themselves classified as primary, secondary, and emotional. A piece of text is classified by what percentage of its words fall into each category.

In other words in general terms the text analysis apparently maps out how much left vs. right brain activity was occuring in the author/s minds when they wrote/spoke the content.

John also provides a Python tool and Matt Hower did a Ruby version

Posted in Philosophy, Programming | Tags RIA, RID | no comments

The Future of Computing is Dynamic...

Posted by ungraspiness Mon, 18 Dec 2006 01:08:00 GMT

The codist keeps putting out the good stuff:

The future of computing is going to go belong to the nimble mammels that are dynamic, interpreted, virtual machine-based instead of the dinosaurs that are compiled, linked and mostly static.

Posted in Programming | Tags Computing | no comments