Just another WordPress.com site

Archive for the ‘Uncategorized’ Category

Signs that you’re a good programmer

The most frequently viewed page on this site is Signs you’re a bad programmer, which has also now been published on dead trees by Hacker Monthly, and I think that behoves me to write its antithesis. “Bad programmer” is also considered inflammatory by some who think I’m speaking down to them. Not so; it was personal catharsis from an author who exhibited many of those problems himself. And what I think made the article popular was the “remedies”–I didn’t want someone to get depressed when they recognized themselves, I wanted to be constructive.

Therefore if you think you’re missing any of the qualities below, don’t be offended. I didn’t pick these up for a while, either, and many of them came from watching other programmers or reading their code.

1. The instinct to experiment first

The compiler and runtime can often answer a question faster than a human can. Rather than seek out a senior programmer and ask them “will it work if I do this?”, a good programmer will just try it and see if it works before bringing their problem to someone else.


  1. Side projects
  2. Dabbling in other programming languages, especially ones from a different “family” (procedural, stack-based, concurrent, etc.)
  3. Knows what you’re talking about when you mention “Arduino”
  4. Old, uncommitted code that duplicates other code’s functionality but isn’t referenced elsewhere in the project
  5. A tendency to suggest wacky and unrealistic solutions in meetings
  6. A cubicle or desk populated with toys that came from ThinkGeek

How to acquire this trait

Are you excessively cautious? Are you only comfortable when you have permission? Has anyone ever said that you were passive aggressive? You might consider inviting some friends to visit the local Six Flags or some other roller-coaster park. If you want baptism by fire, then make your first ride the scariest (for me, it was the “Drop Zone” at King’s Dominion, with some reinforcement a few years later on the Kingda Ka at Six Flags). If you consider yourself ready to get off the kiddie rides you might try your hand at hang gliding and windsurfing, which have the benefit of teaching you what you can and cannot control.
Much of what makes people timid to experiment is chemical–your brain has a small number of adrenergic receptors, so a little bit of adrenaline excites your fight-or-flight reflexes too much. But consider why people grow tolerant to coffee: the caffeine’s byproducts force their brain to grow more adenosine receptors. So if you force your brain to grow more adrenaline receptors then the same amount of “fear juice” will trigger a lower percentage of them. Find some experience that scares the shit out of you, do it a few times, and you will lose your fear of venture on a physical level.
Note: A programmer who “suggests wacky and unrealistic solutions” is not always a bad programmer. It can be a sign of creative thinking from someone who assumes confirmation or correction will come from somewhere else down the line. 

2. Emotional detachment from code and design

Code is like kleenex: you use it when it’s useful and throw it away when it no longer serves. We all like to think that code-reuse is important, and while it is, it’s not meant to be about raising a child. Code doesn’t feel. Code doesn’t care. Code will turn on you like a Frankenstein monster. Code is just bytes. Code is a liability.


  1. Almost no committed code that is commented out
  2. Willingly throws away weeks or months of work in order to adopt another programmer’s superior code
  3. Puts finger to lips, furrows brow and says “hmm” when faults in their work are pointed out, while looking at the code and not the critic
  4. Indifferent to the way the IDE wants to auto-format code, uninterested in “tabs-vs-spaces” arguments
  5. Refers to it as “the code” rather than “my code”, unless accepting blame
  6. Has abandoned a design of theirs that was previously used in a successful product
  7. Doesn’t become defensive when the boss mentions that they’re looking for an off-the-shelf alternative to what they’ve been writing for the past few years

How to acquire this trait

Konrad Lorenz, the author of On Aggression, suggested that a scientist should begin each day by throwing out one of his pet theories in order to remain sharp. Consider throwing out one of your pet algorithms or design patterns or exquisite one-line Sodoku solvers every morning to remind yourself that it’s you who controls the idea, not the idea that controls you.
Find the code that you’re the most proud of and delete it, now re-write it from scratch in a different way. Use a “design pattern” that confuses you, or that you hate (e.g.: the Singleton) and figure out how to make it work. If necessary, delete that after you’ve got it working and try again with a new pattern or language. Not only will you learn that there’s More Than One Way To Do It, but you’ll learn that your code is transitory. Code, by its nature, is not just inextricably glued to its language, platform, and the APIs it consumes, but written in the form of ephemeral static charges, orientations of magnetic particles, subject to the whims of the market, Moore’s Law, and your employer.
Other techniques to break the abusive relationship:
  1. Maintain somebody else’s code
  2. Experience, either by accident or bloody intention, what it’s like to lose a week’s work to a failed backup or a botched commit and have to re-write it all over again
  3. Work for start-ups where you’ll get laid-off when the second or third round of financing doesn’t come through
  4. Be stupid enough to post your best code on Reddit
  5. Read the bit about “Destructive pursuit of perfection” further down in this article

3. Eager to fix what isn’t broken

Programs are infrastructure: they’re built to serve a specific need, but needs always change. Good programmers realize that hard-coded values buried in code are bad, that a destoryBaghdad() function is immoral, and that it’s a priority to eliminate “code smells”. Not for pride. Not for backslapping attaboys from your peers or the authors of methodology books. But because you will itch until it is fixed.


  1. Doesn’t take the spec by its word and tries to find out who wrote it and what they were thinking
  2. Hunts down and talks to the people who will use the program each day
  3. Owns a book written by a guy called Martin Fowler
  4. Tends to express extreme like or dislike for popular technologies such as XML, ORM and REST, and has also switched positions on one or more of these in the past
  5. Likes to use abstraction layers, but doesn’t like to add more than one layer on top of what’s already in the language or platform
  6. Talks about “low cohesion”
  7. At least 10% or more of their commits reduce the line-count of the project without adding new functionality
  8. Before adding a new feature, checks to see if an existing one can be re-designed to perform both tasks or replaced entirely with a better method

How to acquire this trait

The first attempt to solve a program in code will always bear the artifacts of discovery: discovering the true nature of the problem, discovering the features of the platform, and discovering the best way to solve it. The second attempt will be more stable, but might inherit too much cautionary baggage and become a nightmare to extend. And so many programs today are like the Firth of Forth Bridge: disgustingly over-engineered. Sometimes it’s the developer’s first crack at the problem and looks like a lawn mowed by a dog, sometimes it’s their second attempt and looks like the dog installed grass-cutting laser turrets every 2 feet. It can take a third try before the designer understands the problem completely and knows how much, or how little they need to do.
Code lets you learn in stages where you don’t need to re-write everything from scratch. You re-write pieces after you understand what they need to do and what they’ll never need to do, make them simpler, shorter and beautiful.
Go through your home and repair all the annoying things you’ve been putting off; fix the crooked picture on the wall, unclog the slow draining sink, repair that gutter drainpipe so your basement doesn’t flood, buy a UPS and backup drive for your computer and configure them to shut-down/back-up automatically, replace all the incandescents with efficient bulbs, replace that ethernet cable draped down the hallway with WiFi or some proper wall-jacks and conduit, get a real food-dish for your cat instead of that old cheese-dip container.
Next you should go to your last project and read through the code. Think about what each piece does. There’s a loop here, some sorting there, a bit of number crunching, screen updates, HTML generation, database CRUD, that sort of thing.
Now replace the hard-coded HTML with a templating system, get the database CRUD out of your business objects and re-write it to use proper parameterized queries instead of string concatenation, replace all the “writelns” and “MessageBoxes” in your error handlers with a logging framework, refactor code that’s trying to borrow methods from other classes, use locale-aware string formatting, stop guessing how big an array should be and use a dynamic collection, delete orphaned code.
Aim for these, in increasing order of importance:
  1. Code that does the same thing, but is shorter or more efficient
  2. Code that does the same thing, but uses an appropriate “wheel” built-into the platform instead of reinventing its own
  3. Code that does the same thing, but is easier to modify for similar needs
  4. Code that does the same thing, but is easier to read and understand
  5. Code that doesn’t exist
Hit #5 and you can call yourself a Zen Apprentice. Do it for a decade until you do it instinctively and you can call yourself a Zen Master.

4. Fascinated by the incomprehensible

I am only just beginning to understand what a Fourier Transform does, but I’ve been studying them because I have the damn persistent feeling that I could be using them somehow. I don’t know what I would use them for yet, but maybe I will someday. What I do know is that what I don’t know will cost me in useless labor


  1. Visits Lambda The Ultimate on a regular basis
  2. Knows what ATP synthase is. Has extracted DNA from a banana in their kitchen
  3. Owns a book with a dragon on the cover, especially if they don’t write compilers
  4. Giggles when someone says the phrase “This is recorded on sticky-tape and rust”
  5. Shoves through a crowd at a party to get near someone who just used the word “Bayesian”
  6. Buys drinks for people who work in other industries and seem willing to talk shop when drunk
  7. Has a habit of boring people to tears explaining something tangentially related to the news, such as the cockpit layout of the Airbus 330
  8. Has foreign-language versions of popular songs on their iPod
  9. Envies but doesn’t resent people with degrees in something they don’t know

How to acquire this trait

This tends to start in childhood but can be cultivated in adulthood if you can commit to exploring your horizons. Friends are a major gateway: seek social occasions where you’ll bump into people you don’t know under circumstances where they’ll be unhurried and at ease. This may involve alcohol. Don’t try to impress them, don’t compete with them, but display your ignorance willingly to see if they lean forward to correct and enlighten you. Then shut your fool trap and listen.
When you hear or read something you don’t recognize then Google it or hit Wikipedia. For a programmer an equally superior resource is Ward Cunningham’s Wiki, which deserves weeks of your life.
Computer programming has annexed all of the sciences and the feedback loop is so wide it stuns gods. From biology we took Genetic Algorithms. From climatology we took chaos theory. Biologists now use our work to fold proteins. Climatologists now use our simulations to predict armageddon. Everything informs us, and we inform everything. Either probe the unfathomable or retire on a “blub” programmer’s salary. 

5. Compelled to teach

I once knew someone who thought it was good advice to “never teach everything you know” because they once lost a job after bringing a co-worker up to speed with all their skills. I stared at them with genuine incomprehension. A good manager would never get rid of someone who’s not only capable of all their tasks but also demonstrates ability to train new workers. It would be like shooting the goose that lays golden eggs. If you get fired, it’s probably for some other reason.


  1. Blogs about their work
  2. Has an active Wikipedia account
  3. Unhesitant to pick up a marker and approach a whiteboard
  4. Commits changes to the repository that consist only of comments
  5. Lets new hires borrow books that cost them $100 to buy
  6. Pauses “The Andromeda Strain” at the part about the sliver of paper getting between the bell and the ringer and grins like a madman

How to acquire this trait

I can only do this when I’m inspired or “in the mood”, and I think that this mood is a product of circumstance, one that’s made up of confidence, space, opportunity and provocation. When you’re in school your teacher has the space and opportunity already supplied for them and their confidence is hopefully given by their training, but the inspiration is tricky; it’s the difference between a good lesson that both the teacher and the student enjoys and a laborious exercise in rote memorization.
Novices in computer programming aren’t usually novices in general, because they have lives and friends and family and hobbies and interests that have been going on for even longer. Maybe you do need to bore someone to tears by explaining something that’s cool to you, even if it has nothing to do with programming. Maybe you have a younger sibling you can teach the guitar, or your favorite recipe, or how to balance on a pogo stick. Maybe you have a coworker who doesn’t know how to ski. It doesn’t matter the subject, just that you get a taste of what it’s like to program someone else’s brain in a positive way.
If you’ve never taught anything before you will discover, to an embarrassing degree, just how many times you can say “um” and “er” per minute, how badly you’re prepared, and how easily you can forget that the student doesn’t know details you haven’t explained yet.
One of the tricks that worked for me was to volunteer for an opportunity to teach a complex subject (microbiology) to laymen. The first time I tried it I used a Post-It easel and a bunch of markers and tried to draw everything. I was all over the place. It was humiliating. But the audience, fortunately, was friendly.
The next year I tried again, but this time I had an iPad and used Keynote to put together a presentation, which was a lot of fun in itself, but this time the lesson went overwhelmingly more smoothly. I used lots of pictures, very little text, almost no bullet points, a handful of jokes, and just relied on my memory to talk about slides I had designed to provoke my memory more than illustrate anything to the audience.
The experience of doing an awful job the first time informed my next attempt, and now that I’ve done it three or four more times I find I’m getting slightly better. Not only that, I now know ten times more about the subject because I studied like crazy to help temper my fear of being asked a difficult question. Teaching teaches the teacher.

Signs that you’re a fantastic programmer

I only wish I had these traits and I can only write about them because I’ve observed them in others. Every now and then I have a moment where I think I’m living one of these, but those moments are rare and cherished. They are also debilitating and brush up against the stereotypes of autistic savants, trading one kind of virtue for another: if you want greatness you have to be prepared to pay.

1. Incorruptible patience


  1. Fire alarms provoke annoyance more than panic
  2. Cannot name any song that just played on the radio or through their headphones
  3. Is oblivious to how many times their cubicle-mate has gone for coffee, the bathroom, or the hospital
  4. Unbothered by office politics
  5. Can predict a bug before the code is ever run

How to acquire this trait

Distractions are a product of imagination. The day I wrote this I found myself horribly distracted and annoyed by someone at my gym singing songs in French while I sat in the sauna. The singing moved around outside the sauna and pissed me off. I wished he’d stop because I couldn’t concentrate. I pictured a man without concern of others, a douchebag, someone who’d wear a pink shirt and order people around. Then I came out of the sauna and saw it was an old man, chocolate in complexion and as threatening as a worn teddy bear with button eyes. He’d started singing La Vie en rose, which is a song I that I not only loved but that made me wonder, just then, if it was me who’d long since turned into an insufferable asshole.
I don’t know how to shut out distractions, but if I had to try I’d guess it’d involve a little bit of deference and so much fascination that it directs your imagination instead of being dictated by it. When I want to be like this I want to take life without taking it personally.

2. A destructive pursuit of perfection

The worst optimizations favor profit over beauty, and between the two it’s beauty that lasts longer. Perfection isn’t the same as obsession, but they’re damn close.


  1. Preference for dismissal over compromise
  2. Contempt for delivery dates
  3. Substantial refactoring on the eve of a deadline
  4. Unwilling to accept bonuses, promotion, or stock options for expediency
  5. Fondness for films directed by Stanley Kubrick

How to acquire this trait

As Tyler Durden says you must know–not fearknow that someday you will die. Your nice condo with Ikea furniture is a side effect, not a reward. If you are not a unique, beautiful snowflake then what you create has to be
It’s also known as pride in one’s work. Remember that emotional detachment from code is a virtue, but this doesn’t mean emotional detachment from your work is, too. In fact, another way to become emotionally detached from code is to put your interest into the outcome instead. The outcome you should be thinking of is a lady who’s going to get fired if she doesn’t deliver the output of your program at 4:59pm sharp.
There’s a legend about a marketing type who worked for Sam Walton at Wal-Mart and came up with a brilliant campaign to advertise a widget. Sam took a look at the proposal and said something to the effect of “this is great, now take the cost of the campaign and use it to lower the price of the widget instead.” According to legend, the widget sold better and made more profit that way than if the campaign had been carried out. 
Let the spirit of the story roll around in your head for a while and think about how it’d map to what you do at work. You boss probably isn’t like Sam Walton, but perhaps there’s a little bit of Sam in you. Is it better to compromise the way others want, or to make the product just a little bit better?
This could be hazardous to your income, it’s risky to your stock options, but when you do a job right, when you do things properly, when you complete a project the way it ought to be, then sometimes time absolves all indulgences. Sometimes the boss calls you back to the carpet to apologize to you.

3. Encyclopedic grasp of the platform

Most programmers realize the short lifespan of their tools and don’t waste much of their lives memorizing what’s doomed to be obsolete. But neither do most programmers appreciate how everything in this industry is a derivative of some earlier thing, sharing syntax and constraints that will live well past our own personal expiration dates. The best programmers have done what Oxford used to insist on: if you learn latin and mathematics then you can fuck all of that other modern nonsense, because you’ll have the tools you need to understand anything.


  1. Can recite from memory all of the includables in the C Standard Library
  2. Raises a knowing eyebrow when you mention the “500 mile email”
  3. Has a copy of the OpenDoc Programmer’s Guide gathering dust on their shelf
  4. Can complete any sequence of dialogue from Lord of the Rings, Star Wars, Red Dwarf or Monty Python
  5. Rapidly identifies a synchronization bug caused by TCP’s Sliding Window algorithm
  6. Recognizes a bug that’s caused by a microcode error on the CPU you’re testing on
  7. Has a framed personal check for $2.56 from Donald Knuth

How to acquire this trait

Encyclopedic knowledge takes decades to acquire, but every Guru in the world got there by doing roughly the same three things each day:
  1. Struggling to solve problems they find to be difficult
  2. Writing about how they solved difficult problems
  3. Reflecting on how they solved difficult problems
Once upon a time a novice programmer was stumped by a bug that he couldn’t figure out. The crash report was full of strange numbers he didn’t recognize, like -32,760. Where the hell is that coming from? He hits Ctrl-F and searches all of his code files for “-32760” but it doesn’t appear anywhere. Nothing makes any sense. A week goes past during which he goes back to his old college computer-science textbooks, the compiler’s manual, everything, and on the last day his glazed eyes rest on a table of numbers. Through the fog of his tired mind he suddenly recognizes one of them: -32,768. He thinks about how remarkable it is that it’s so similar to his problem number, and then he notices that this table of numbers is showing the ranges for various integer types and how there can be signed and unsigned versions of both. When the light comes on it’s blinding.
Thrilled with his belated insight he writes a blog post about it which disappears into the global ether unread by all but a handful of buddies. That night he lies awake, thinking about that bug and about integer types and the pros and cons of compiler-checked types and so-on.
Ten years later our friend is the lead programmer at the firm, and one day he glances over the shoulder of a junior programmer who’s showing evident frustration. Tucked down in the stdout window is a bunch of debugging traces and the number -32,762. The now-guru programmer taps the newbie on the shoulder and says “are you passing an unsigned int16 to code that’s expecting a signed int16?”
If you’re not encountering problems that are difficult for you to solve then you need a change of job or hobby or scenery or something. Look for opportunities to work with something new at your job or school, try hacking your Roomba, pick a bug in an open-source project that nobody has touched for months and fix it, try answering tumbleweed questions on StackOverflow that force you to look up something you didn’t know.
If you could look inside the brain of a guru with a magic magnifying glass you might see clusters of neurons packed around the visual cortex that, like the infamous “Grandmother cells“, lie dormant for months but light up when something significant comes into view such as a power of two, or a suspiciously precise delay that points to a DNS timeout, or the signature of the FDIV bug. Those “grandmother cells” can only be made the hard way.

4. Thinks In Code


  1. In casual conversation their readiest metaphors come from programming constructs
  2. Spends the majority of their time “goofing off”, but commits more bug-free code each day than their colleagues
  3. Glances over your shoulder and points at a bug in your code with their finger
  4. Correctly diagnoses bugs over the phone while drunk or in bed
  5. Comes up with their best code while taking a shower*
  6. When confronted with an obstinate bug, their instinct is to get up and go for a walk
  7. They suddenly pause and stare into space in the middle of a conversation, then abandon you to hurry back to their terminal with no explanation (AKA “A Columbo Moment” or “Gregory House behavior”)

How to acquire this trait

Them darn kids and their cell phones, how does a 12 year-old teenage girl tap text messages on a numeric keypad so fast anyway? It can’t be genetic, since all those damn brats can do it, no matter their gender or parentage. It can’t be upbringing, cuz kids in every social class can do it. So you rule out this and that and what you’re left with is an ancient truth: people think in the language they learned to speak. A teenager’s thumbs already know where to go and they think in texting. When writing, typos feel wrong. People who learn multiple spoken languages and use them regularly tend to think in multiple languages, too, after they’ve practiced for so long that they no longer have to do a translation in their heads first. Rather than read a phrase in Russian and translate it to English in their minds before understanding it, they just understand it in Russian. 
You cannot think “Fire rearward missile” and then translate it to Russian, you must think in Russian.
If you’ve heard about Sapir-Whorf or read Nineteen Eighty Four and all that jazz then you might already appreciate the implications: words convey ideas, language is thought. Whether that’s a syntactic language or a visual or auditory language in your head doesn’t matter, it’s the way your brain deals with symbols and their rules for manipulation that matter.
The best book you can read (and perform the exercises of) to acquire this trait is Structure and Interpretation of Computer Programs by Abelson, Sussman and Sussman. It uses Scheme to present its lessons, and even if that’s not the language you write programs in it’s still one of the best languages to program your brain with. Remember: learn math and latin and you can understand anything.
Whether you have this book or not the key is to practice with coding until you can read and reason with it like your native tongue. You can’t acquire this trick in 30 days, it may be more like 30 months. You’ll know if you’ve got it when you begin to see in code as well. 
* – Shaddap Bob, and you too, Sat.

5. When In Rome, Does As Romans Do

I don’t think I live up to this because I like to use MonoTouch to write iOS apps. I do know Objective-C and can write apps in it, but my heart belongs to LINQ. If I were to suppose an exception to this rule, it would be: “but when in the Roman accounting department, does as accountants do.” It is not always wrong to pick a language that fits the domain, even if there’s a performance or feature disadvantage from running in an interpreter or other layer. Yet great programmers will never insulate themselves from the hardware and will learn the native language anyway. Every abstraction leaks.


  1. No automatic interest in cross-platform frameworks
  2. Contemptuous of “language wars”
  3. Doesn’t see a strategic disadvantage in maintaining the same program in multiple languages
  4. Assumes their own code is the source of a bug before blaming the compiler, library or operating system
  5. Displays a plush Tux penguin or Android in their cubicle soon after being assigned to a project targeting that platform
  6. Switches brand of cell phone or tablet in the same circumstance
  7. Hits a stack of technical manuals before assuming a data-type like double or decimal will do what they think on a new device

How to acquire this trait

These guys are as comfortable with platform diversity as they are with having multiple vegetables on the same dinner plate. I said “thinking in code” and “emotional detachment” were virtues, and this is the bonus that comes for free. While these programmers appreciate abstraction they don’t automatically appreciate generalization. If there was no advantage to be had in a new platform, then why was it ever created?
There’s a thousand computer languages because there’s a thousand classes of problems we can solve with software. In the 1980s, after the Macintosh debut, a hundred DOS products were ported to the new mouse-driven platform by clubbing the Alto-inspired UI over the head and brute-forcing the keyboard-driven paradigms of PCs into the Mac’s visual atmosphere. Most of these were rejected by Apple or the market, and if they came back for a second try they came back because somebody flipped open the spiral-bound HIG and read it sincerely. 
Maybe Excel needed to emulate Lotus 1-2-3’s slash-driven menus. Maybe AutoCAD still needs to host a command line. But the designers of both never neglected the new world and that’s why they’re still famous today. Objective-C has Categories, C# has Extensions, but they’re not quite alike and they’re not quite the same. What’s a Key-Value Observer to one might be like an Event to the other, which is as informative as saying an opportunity is the same as permission.
To acquire this trait you have to begin by learning a new platform through both its unique instructions and the way the user interacts with it. Much of what’s out there is made to be very similar to what you already know so you can start using it quickly (radically different platforms “ahead of their time” tend to fail), but be attentive to what’s different. Android phones tend to include more hardware buttons than iPhones. Maybe that’s good, maybe that’s not, but their users expect programs to use them. Don’t disappoint them: neurons are harder to program than transistors.
New platforms either debut a new language or new conventions that are unique, and at whatever level that is you need to learn a new vocabulary. Even if it looks like they took an existing platform and “tweaked” it, the tweak in question must have significance. They say a Big Mac’s Special Sauce is just Thousand Island dressing with more sweet pickle.
To manage a single product written to multiple platforms you need to abstract your product, not the platform its delivered to. You do that through elimination, by stripping platform-specific code out of your product’s soul. If you can master “Eager to fix what isn’t broken” then go bonkers on your code until there’s only a few chunks left on the coroner’s table; that’s the part that stays. 
The simpler it is, the easier to modularize. The easier to modularize, the easier to separate concerns. The easier to separate concerns, the less has to change to fix bugs and add features. The less has to change, the easier to translate those changes to another system. Don’t rely on automatic methods–it’s like relying on a cat to tie your shoelaces.

6. Creates their own tools


  1. Has set up an automated build server
  2. Has written their own benchmark or specialized profiler
  3. Maintains an open-source project on GitHub
  4. Has re-invented LISP at least once
  5. Knows what a Domain Specific Language is, and has designed and written an interpreter for one
  6. Extends their IDE/Editor with custom macros
  7. There’s a Radio Shack project enclosure on their desk with a bunch of 7-segment displays showing the number of issues assigned to them in the bug tracker

Signs that you’re destined for more

These are not always the traits of “good” programmers, they’re the traits of people who go beyond programming and change industries, some of them are even detrimental to what an employer would consider “good”. If any of the following fits you then you should start your own company. I can’t say if it’ll benefit you to squander a few years in the bowels of a corporate beast to “learn the ropes”, because if you exhibit these traits then I doubt it will be worth it. You are Steve Jobs or Bill Gates or their successors, and there’s no way to learn these traits either because if you don’t have them, then you ain’t ever gonna.

1. Indifferent to Hierarchy

Richard Feynman once pointed out that “it doesn’t matter who your dad knows”, if something is wrong then it’s wrong no matter who says its right. Don’t fear the consequences to your career, you”ll find another job. Society never wastes real talent.


  1. Getting into arguments with the CEO
  2. Quitting on principle
  3. Organizing teams without permission
  4. Creating new products after-hours while hiding from the Rent-a-Cops
  5. Re-organizing the workspace “Peopleware” style, against company policy
  6. Helps themselves to the boss’s private stash of bottled water

2. Excited by failure

Most of us learn from failure, but most of us also fear it. Even fewer of us have so much faith in their innate ability to cope and adapt that failure is actually seductive to them, and they must tempt more. They don’t deliberately try to fail, they just feel instinctively that failure can be as beneficial to them as it was to Spencer Silver.


  1. Can tell you, step-by-step, what happened on United 232, Air France 447, March 28th 1979, or April 26 1986, and what changed as a result
  2. Snapped up an HP Touchpad when they went on sale for $100
  3. Took broken appliances apart as a kid, did not necessarily fix them
  4. Has tried every pick-up line there is and has the slap-marks on his cheeks to prove it
  5. Owns schwag from Dr. Koop, Enron, Pets.Com, excite, RIM and Yahoo!
  6. Founded a second start-up with the essence of their first start-up’s failure

3. Indifferent to circumstances

“The mind is its own place, and in itself can make a heaven of hell, a hell of heaven.”


  1. Has transitioned from rags to riches to rags and shows no sign of regret to the latter
  2. Little or no loyalty to physical location or local traditions
  3. Disinterested by the outcome of elections
  4. Stock options and bonuses are ineffective retainment techniques
  5. Makes the best damn PB&J you’ve ever tasted, can prepare ramen sous-vide style with a ziplock bag and a space heater
  6. Cashes-in their 401k to fund their next venture

4. Unswayed by obligations

Obligations are a social construct, and some see them as props for the lazy. While that’s a dishonest oversimplification, some make it a point to break free and do something different. We’d still be bashing rocks together if they didn’t.


  1. Routinely applies for an extension to file taxes
  2. Antagonistic when asked to maintain code for “backwards-compatability”
  3. Contemptuous of Girl Scout Cookie order forms left out in the break room
  4. Dropped out of high-school, university, law or medical school because they didn’t see the point anymore
  5. Has deeply religious parents but doesn’t attend church
  6. Uses the free return-address envelope stickers given out by a cancer charity, frowns when you ask how much they gave

5. Substitutes impulse for commitment

Companies are formed to 1: reduce the cost of a transaction, and 2: provide customer support. Our stereotypical “free spirit” isn’t very good at the last one, but that’s why they sell their stock to The Suits and fly away to build another nest.


  1. Forgets Mother’s Day/Valentine’s Day/Anniversary but swamps the beloved with overcompensatory gifts shortly afterward
  2. Tends to give gifts that came from the SkyMall catalog
  3. Dedicates books/product launches/office buildings to close persons who didn’t show-up for the ceremony
  4. Recruits a steadier person to run day-to-day operations

6. Driven by experiences

The biggest programming challenges are still unknown; they’re not quite the same as solving P=NP and more like figuring out how to get your customer laid. So somebody reacts boric acid and silicon oil, and that’s nice, but it took a toy shop owner to turn it into Silly Putty.


  1. Shows you a birds-eye photo of a woodland creek. When you shrug, they explain that it was taken on the return bounce
  2. Has opinions on the best parts of the Adirondack Trail
  3. Shows up at work with welts all over their arms, says it had something to do with a company called “Airsoft”
  4. Has eaten Ikizukuri or Fugu
  5. Laughs knowingly at the “strawberry cough” scene in Children of Men
N.B.: While the toy-shop owner figured out that Silly Putty could be a toy, it took someone who was already $12K in debt to survive the silicone shortages of the Korean War before becoming rich. Not even the most inspired programmers, inventors, or entrepreneurs live in a vacuum. Someone invents it, another figures out what to do with it, and somebody else figures how to turn it into a business. Just look at the gadget you’re using to read this article.

Further Reading


Thanks to Mark Martino for reading an early draft of this article and providing ideas.

Give a man a fish…

“Give a man a fish and you feed him for a day. Teach a man to fish and you feed him for a lifetime.” — Lao Tzu

“God helps those who help themselves.” — Benjamin Franklin

Hello world!

Welcome to WordPress.com. This is your first post. Edit or delete it and start blogging!

多伦多华人宣传西藏真相维护祖国统一和平集会活动于3月29日下午1点在市中心DUNDAS 广场(Yonge/Dundas)举行


儿子缠着妈妈陪他去溜冰。妈妈说很久不溜冰了怕跌倒。儿子已经学过几次溜冰课,想说“我可以扶着你呀”(I can hold you),  想了想,说:我可以拿着你呀!!!

九中相册 (for Hong)


Does anyone know how to download the photos from above Flash?





Bayview SS
Pierre Elliott Trudeau
Unionville HS
Aurora HS
Langstaff SS
Markville SS
Richmond Hill HS
Markham DHS
Newmarket HS
9. Thornhill SS
10. Milliken Mills HS
11. Westmount CI

Aurora HS
Pierre Elliott Trudeau HS
Sir William Mulock SS
Markville SS
Richmond Hill HS
Unionville HS
Westmount CI
Langstaff SS
Markham DHS
10. Newmarket HS

数学成绩是按照全省统考学术成绩达到3-4级的百分比排名。语文成绩是按照全省统考合格比例排名。 仅供参考。

参照这个排名, 逐一介绍下前几个学校和小区的房地产市场简况。Pierre Elliott Trudeau高中,位于万锦市的肯尼迪路和Bur Oak街交界处,是一所以加拿大已故总理特鲁多命名的中学,成立于2002年,虽然年轻,但是已经在短短数年内赢得了很好的声誉。特鲁多中学是一所双语中学,普通中学的学区南起16街, 北到Elgin Mills, 西起Woodbine, 东到麦考文路, 法语部分则涵盖了整个万锦市。学区内有两个高尔夫球场,以这两个球场为界, 球场以西有著名的Country EstatesCathet两个百万豪宅区,每栋房子的占地都在1英亩以上, 是多伦多地区其他同一价位的房子无法比的。在沃顿大道的西边,住宅占地虽然小了些, 但是房子本身并不小,通常都有3000平方英尺以上。而且,建筑年份也新一些。 在高尔夫球场的东面,则是新起的一片住宅区,房龄大约在5年左右,而且房屋的类型也和西面不同,西面大多是大型独立屋,东面则由镇屋, 半独立屋和独立屋组成, 选择多出很多。有意思的是, 肯尼迪路以西,中国人较少,以东却以中国人为主。这一区的镇屋, 半独立屋在27万到34万不等,独立屋从40万到70多万都有交易。值得一提的市区内新建的两个超大型人工公园,其规模在多伦多并不多见。 区内的社区中心,Angus Glen, 也是新建成不久,有两个室内滑冰场,一个室内游泳池,花样滑冰和游泳课程在这里举行,是一个很不错的社区中心。 Markville高中位于麦考文路和7号公路交界的东北角,成立于1990年,学校附设托儿中心,校区北起16街,南到407高速公路,东西都是以Rouge River为界,7号公路以南则到沃顿大道, 这样就包括了南边0-5年新的南渔人村小区,肯尼迪路左右, 著名建筑商建造的“Bridle Trail” 小区,以及Raymerville小区,和7号公路夹麦考文路东南角Roy H. Crosby 小学学区。南渔人村小区,位于407高速公路和肯尼迪路交界的东北角,56年前这里还是空地一片, 靠近7号公路附近原来有一片意大利人建造的3000平方尺左右的房子,靠近麦考文路的树林中,还有一些平房,有的占地还很大,后来在新旺角广场的南边,就建起了奔驰,宝马和本田车行,对面又建起了一片片的镇屋,半独立屋, 还有一些2500平方尺左右的房子。现在这一片新区的无管理费镇屋价格在33万到38万,半独立屋在35万到42万。独立屋则由43万到130万。由于房子新,特别是镇屋不要管理费,又有旺角广场,以及广场南边,西边两个医疗中心,生活很方便,所以吸引了很多中国人来此置业。麦考文和7号公路的东南角,是Crosby小学所在的学区,房龄虽然老,但是胜在占地较大,由于多白人业主,每家的前后园艺比较讲究,漂亮。大树参天,自然环境好,特别是紧挨着这一小区的南面,是一个自然保护区,有湖有树林, 是孩子们夏令营的好去处。不介意房子老的朋友可以留意这个小区。这个小区的房价在33-67万,以独立屋为主。7号公路和麦考文路的东北角,便是Raymerville小区。不知何时,在客人之间以讹传讹,说这一区居民已印巴人为主,其实不然。还是以白人和香港移民为主, 小学和居住环境和麦考文路西的小区不相上下,但是价格却差一个档次,现在房价在31-59万,以独立屋为主。 这个区值得一提的是Loblaws超市北面一片无管理费的镇屋。结构合理, 宽敞明亮,比其他区的镇屋结构上显得宽敞,大约在1600-1700平方尺。而且离社区中心,购物中心和轻铁车站很近。价格在31万左右。 麦考文的西面, Markville购物中心的北面,有一片31-35万左右的连屋, 就是相邻两个房子的地下室公用一面墙,地上部分却是像独立屋一样。 地理位置好,价格便宜,有不小的前后院子, 不太理想的是主人房大多不是套间。在肯尼迪路的两侧, 则是著名的Bridle Trail小区,另文已有介绍, 不再赘复。总之, 这个学区,从居民构成,房子本身的条件,房源类型, 自然环境,生活配套设施,以及未来的发展趋势等多方面来看,在多伦多地区,都是安家置业不容忽视的选择。 渔人村高中位于沃顿大道和7号公路交界的西北角,成立于1985年,约克区在该校特设艺术类教室。 有艺术特长的学生可以在该校接受4年的教育。校区北起16街,南到407高速公路,西起404高速公路,东以Rouge River为界,7号公路以南则到沃顿大道。 这个区,由于有著名的Toogood池塘,渔人村主街,一直以来享有盛誉,社区成熟,配套设施完备,中西兼顾,自然环境保护良好,天然资源得天独厚,是多伦多近郊唯一一处有自然湖景的小区。 而且,该区的人口构成,也是大陆移民可以接受的。这一区的西边是404高速公路,南边是407高速公路,卫星导航新型公交Viva贯穿其间,交通方便,西有华人的万锦广场, 和老外的购物中心,内有很多有名的商场,中间有万锦市政府,万锦剧院和万锦市广场,内有菜市场和餐厅。东边旺角商场也不远,生活,购物极为方便。对于华人来讲,7号公路这一带,中餐厅的密集程度,是多伦多其他地方不能比的。 除了吃用,采购方便外,这一区的自然环境特别值得推崇,把生活小区和自然结合在一起, 这里是个典范。这一区原来从没有高楼,只是最近才在外围兴建3栋高楼,原来的建筑以独立屋为主,在保留自然的河谷,树林以及池塘的基础上,周边兴建房屋,这样,居民在享受宽敞舒适的住宅的同时,还可以在湖边,林间散步, 这里的树林绵延相连,是举家郊游的好去处。这一区的房子本身的结构,条件,装修符合大多数人的审美观,越来越受到大家的青睐。 房价由30多万到1百多万不等。其中以40万到60万的房子为主,因为其优越的自然,人文环境(图书馆,美术馆, 冰壶馆, 滑冰场,爵士音乐节,著名的咖啡馆和餐厅), 以及著名的中小学(William Berczy小学,Buttonville小学,UPS, Coledale小学),使其成为老牌的购房热点之一。在渔人村中学的对面,有一片共管物业型的镇屋, 以及正在兴建的高级公寓,不久的将来,在沃顿大道的东面,会有很多高楼拔地而起,这一区的房价,因为人气的兴旺,应该还会上一个台阶。 



1. Bayview Glen (/女校) 年级:K1-12 电话:416-443-1030 地址:275 Duncan Mill Rd, Toronto
日校$12,800起,960人, 入大学率:100%,建校年份:1962

半独立屋:28-38万, 独立屋:40-140万 。
2. Bishop Strachan (女校) 年级: K1-12电话:416-483-4325 地址:298 Lonsdale Rd., Toronto日校$17,720;寄宿$35,000起,800人,, 入大学率:100%,建校年份:1867
3. Branksome Hall (女校) 年级: K1-12电话:416-920-9741地址:10 Elm Ave., Toronto

4. Crescent School (男校) 年级:3-12 电话:416-449-2556地址: 2365 Bayview Ave., Toronto

独立屋:48-1500万 。
5. De La Salle College (/女校) 年级: 5-12电话:416-969-8771地址: 131 Farnham Ave., Toronto日校$7,750起,600人,入大学率:100% 建校年份:1913
6. Havergal College (女校) 年级: JK-12电话:416-482-4724地址1451 Avenue Rd., Toronto
日校$13,545起,730人,入大学率:100% 建校年份:1894

7. Holy Trinity School (/女校) 年级: K1-12电话:905-737-1114地址11300 Bayview Ave., Richmond Hill,日校$11,500,730人,入大学率:100% 建校年份:1981年。
独立屋:251百80万 。8Peoples Christian Academy (/女校) 年级: K1-12电话:416-222-3341地址374 Sheppard Ave. E., Toronto,日校本地$6,645外地$10,595800人,入大学率:100% 建校年份:1971年。
独立屋:411百70万 。
9. Royal St. George’s College (男校) 年级: 3-12电话:416-533-6724地址 120 Howland Ave., Toronto 日校$18,100430人,入大学率:100% 建校年份:1964
10. St. Clement’s School (女校) 年级: 3-12电话:416-483-4835 地址 21 St. Clements Ave.,Toronto 日校$15,750430人,入大学率:100% 建校年份:1901
独立屋,半独立屋:27万-1百15万。另外还有Upper Canada College, Toronto FrenchUniversity of Toronto Schools.


如有垂询, 请电:地产经纪:李丁Li Ding
Cell No. 416-648 3678

Tag Cloud