Just another WordPress.com site

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.

Symptoms

  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.

Symptoms

  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.

Symptoms

  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

Symptoms

  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.

Symptoms

  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

Symptoms

  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.

Symptoms

  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.

Symptoms

  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

Symptoms

  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.

Symptoms

  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

Symptoms

  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.

Symptoms

  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.

Symptoms

  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.”

Symptoms

  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.

Symptoms

  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.

Symptoms

  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.

Symptoms

  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

Credits

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

加国无忧 51.CA 2010年11月5日

这两天读《长生殿》,第二出男主角唐明皇上场便云:“且喜塞外风清万里,民间粟贱三钱”。不仅有所感触。感触何来?前日六块钱买了五头蒜,犹记前年此时四块钱买了两“辫子”(编好的蒜,一辫子约两斤重),不仅生出物是价非、通胀似虎之慨。

查“资治通鉴”可知,开元十三年,“是岁,东都斗米十五钱,青齐五钱,粟三钱”。可见唐明皇深知物价关乎民生,物价涨落是判断是否为盛世的标志之一。当年国民党败退大陆之际,物价一天就翻好几个跟斗,百性苦不堪言。何为盛世?唐明皇的上场诗说的明白:“韶华入禁闱,宫树发春晖。天喜时相合,人和事不违。九歌扬政要,六舞散朝衣。别赏阳台乐,前旬暮雨飞”。

这样的盛世是如何得来的呢,还是用唐明皇自己的诗来说吧。在“赐诸州刺史以题座右”诗中,唐明皇告诫即将赴任的地方官员应该这样做:“贤能既俟进,黎献实伫康。视人当如子,爱人亦如伤。讲学试通论,阡陌劝耕桑。虚誉不可饰,清知不可忘。求名迹易见,安贞德自彰。讼狱必以情,教民贵有常。恤惸且存老,抚弱复绥强。勉哉各祗命,知予眷万方”。

观古思今,今天的世道是这样的吗?仅以物价论,萝卜青菜辣青椒,一年来的涨幅何止百分之百,汽油柴油食用油历来是涨多跌少,更不用说水电气总是虎视眈眈,伺机而涨了。俯瞰神州大地,涨声一片。

唐明皇在游玩之后还不忘降低国内中等收入人家的税收:“薄暮赏余回步辇,还念中人罢百金”(全唐诗卷三李隆基《春台望》)。两相对照,盛世不再,不言自明。央视“新闻联播”每天都理直气壮地告诉我……

通胀来袭

与食品价格为代表的物价指数相比,更让人担心的是资产价格泡沫。

天刚蒙蒙亮的时候,一辆从山东开来的卡车,缓缓地停在了毛勇习的商铺门口。不一会,刚才还是空荡荡的仓库,立即堆满了三十多吨大葱,顿时,一股特殊的混合气味,在11月的清晨里弥漫开来。

这里是新发地农产品中心,北京最大的农产品批发市场,距南四环还有两里多地。毛勇习在这里卖了快十年大葱。再过一会儿,城里来的菜贩子们,就会流水般地涌到她的铺子里。最近半个月,她每天都能卖出30多吨大葱。

大葱还是像往年叶绿杆白,两根加起来就差不多有一市斤,不过今年的批发价已经涨到了两元钱,比去年贵了一半还多。毛勇习几乎每天都要不厌其烦地告诉菜贩子,又涨价了。

“万物飞涨”

在新发地,几乎所有农副产品的价格都在飞涨。

“大白菜去年最便宜才两毛钱一斤,现在这里的批发价是五毛八。”一位前来上菜的河南菜贩子说,早市上他的顾客都是拖着小折叠车来买白菜,一买都是十几棵。

随着收获期的到来,11月大白菜将集中上市,但新发地的批发商预计,即便大白菜价格随后会小幅回落,但总体高过去年已成定局。

在新发地粮油交易区,某品牌的东北大米,去年58公斤装每袋卖90多元,到了今年,包装改为30公斤,价格却涨到了每袋100元左右。

此外,一些知名品牌的大豆食用油的价格,在最近的一个月里也普遍上调了一成多。在过去的三个月里,进口大豆的价格上涨五分之一。9月份,花生价格已经上涨了十个百分点,预计未来花生油的价格也会上调。

海通证券11月1日发布的报告称,过去半年来,全球小麦和玉米价格已经涨了57%,大米涨了45%,糖涨了55%,大豆价格涨到了过去16个月以来的最高值。

冰糖葫芦和糖炒栗子,这些冬季街头热卖的零食,也要涨价了。早在10月底,新发地里的山楂和油栗批发价格,都比去年翻了一番。北京怀柔产的油栗,每市斤批发价已经卖到六元多。由于今年西南大旱,甘蔗减产,年均产糖量占全国六成以上的广西,产量下降了一成,推高了糖价。

吃水果似乎也成了一种奢侈爱好。在新发地,山东产的富士苹果,每市斤的批发价已经涨到三元多,而目前超市的零售价普遍在六元以上,一个中等偏大的苹果折算下来差不多值五块钱。按照北京市民政局去年核定的410元低保标准计算,每个低保户的月收入可能还不够买100个大苹果。

《中国新闻周刊》记者从新发地农产品交易网上看到,仅10月30日当天,从大白菜、萝卜、莲藕等日常蔬菜,到苹果、脐橙等应季水果,乃至日常必需的大米、面粉、食用油,价格信息表上均显示“涨”。

食品涨价,殃及民众,“吃不消,吃不起”一时成为网络流行语。金融界网站在10月底进行一项调查显示,85%的网民认为,“物价全面上涨唯独工资不动,活不起了。”

温和的CPI

与菜市场里的“涨势逼人”相比,统计数据显得温和得多。

国家统计局公布的今年9月份的消费者物价指数(CPI)同比上涨3.6%,尽管涨幅创23个月以来的新高,但与民众对现实物价的感知仍存在一定落差。

不过,无论是政府还是商业机构,均认为未来中国物价水平仍将持续上涨。

国家发改委价格司有关负责人近日表示,从长远来看,农产品价格包括粮、油、肉、蛋、菜还有一定的上涨空间。央行在新近公布的三季度宏观经济分析报告中也写到,“粮价明年仍可能继续上涨。”

近日,多家券商及投行机构近日发布的报告,对下半年物价涨幅均不乐观。高盛中国经济学家乔虹近日在媒体见面会上表示,目前通胀的压力正在加大。平安证券发布的宏观经济月报称,预计10月份消费者物价指数同比增长将跳升至4.3%。

此前,中国经济在2004年和2008年,也曾经历过类似的物价上涨局面,消费者物价指数涨幅分别达到3.9%和5.9%,均高于当前的统计数据。自上世纪80年代,中国政府放开一般商品的价格管制以来,在物价上涨最为猛烈的1994年,当年物价同比上涨了近四分之一,家庭突击囤积米面油盐酱醋茶,成为一代中国人的集体记忆。

眼下,类似的一幕又要上演了吗?不过,一些政府官员和经济学家普遍认为,当前的通胀仍处于温和范围内。

“这几天常去的几个超市豆油价都涨起来了。”在超市购物的沈阳市沈河区市民王桂香向记者反映,“那以后还会不会继续涨下去呢?用不用现在多买点油备起来啊?”

昨日记者在走访市场时发现,沈阳大部分超市零售的食用油价格已经开始上涨,涨价幅度大都在10%左右。

到底是什么原因导致食用油价格上涨呢?油价会不会一直涨下去?带着以上疑问,记者对此次食用油涨价问题进行了调查。

原因:成本上涨+游资炒作

那么到底是什么原因导致了食用油价格的上涨呢?

中国社科院金融研究所研究员易宪容昨日在接受记者采访时表示,在大豆的收获季节,食用油阶段性价格是不应上涨的,因为这不符合农产品的季节性规律,也不符合市场规律,这种价格上涨是反常的。其主要原因可能在于以下两点:物价上涨原因导致食用油生产和流通成本增加,再加上最近国家提高了小麦最低收购价,因此受到比价关系影响,国内其他农产品价格上涨预期也可能会进一步加强,与国际通胀预期形成联动进而拉高了价格。此外,国内各行业人力成本的普遍上涨也是成本上涨的重要原因。总之产品成本的上涨和通胀因素应该为油价上涨的主因。

而期货分析师李晟则表示,目前国内大豆产量与整个市场供应量相比很小,大豆的供应主要来自国外,因此国产大豆小幅的增产对原材料的供应情况影响也很小,受国际市场影响较大。消息面上来看,美国农业部10月报告将大幅调降2010年大豆产量预估,另外拉尼娜气候对南美大豆生产的潜在威胁也加大了市场的担忧。再加上海关总署统计数据显示我国进口大豆均价自7月份起已连续上涨,短短3个月每吨上涨600多元,已高于进口大豆产地价格。所以市场分析认为,此种情况可能推动后期大豆价格持续走高,极有可能吸引游资或者大资金加入对通胀预期的炒作。

涨价应该只是短期现象

那么这轮食用油价格上涨行情会持续多久呢?今后价格还会继续上涨吗?

对此期货分析师李晟表示,根据海关统计,大豆进口价格虽然自7月份以来连续3个月环比上涨,但自5月份以来同比仍是连续下降态势,进口均价在每吨430美元至470美元之间窄幅波动,9月份进口均价为每吨460.5美元,同比下降4.4%,考虑到从大豆的采购到完成豆油销售周期一般在半年左右。预计进入食用油销售最旺的春节前后时,实际生产成本不会高于去年同期,因此不必太担忧价格会持续上涨。同时,尽管美国农业部下调本国大豆产量和库存量,但全球食用油供求基本面并没有发生大的变化,供应仍较充裕,加之今年以来我国食用油产量仍呈增势,所以从市场规律来看此轮价格上涨只不过是短期现象,不必担心会长期大涨。

但是李晟表示,虽然从规律来看,食用油涨价只是短期现象,不会持续上涨也不会大幅上涨,但是在当前通胀预期压力不断加大的情况下,游资的介入可能会导致市场的反常变化。

Hello world!

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

If this error happens to your Dreamweaver regardless what version:

An unhandled win32 exception has occurred in
Dreamweaver.exe[xxxx]

Most likely because the newly saved file size is 8kb (8,192 bytes) , or 16kb(16,384 bytes) etc. Open the file in notepad and make some changes. 

Good luck!

揭秘不知道的手机隐藏功能和使用禁忌

 

1、隐形的备用电池

你的手机电量不足了,为了让它能够继续使用,按*3370#键,手机会重新启动,启动完毕后,你就会发现电量增加了50%。这部分隐藏的备用电量用
完了你就必须得充电了,再次充电的时候,隐形的备用电池也同时充电,下次电量低的时候又可以用这个方法。知道这个在紧急情况下如果手机电量不足非常管用。

 2、紧急情况 

全世界的手机都可以拨打的共同紧急救援号码是112,假如你发现自己所在的地区无手机信号覆盖,同时你又遇到了紧急状况,用你的手机拨打112准没
错,因为这时候你的手机会自动搜索所有可用的网络并建立起紧急呼叫。特别有趣的是,即使你的手机是在键盘锁定的状态,你同样可以拨打112。试试吧! 

3、手机被偷了? 

有个办法让小偷也用不了,嘿嘿!查看手机的序列号,只需键入* # 0 6 #,
15位序列号会出现在手机屏幕上,全世界的每一台手机都有一个独一无二的序列号,把这个序列号记录下来并保存好。有一天如果你的手机不幸被偷了,打电话给
手机提供商,并提供你的手机序列号,他们会帮你把手机屏蔽,这样即使小偷换了SIM卡,仍然无法使用,你的手机对小偷来说变得一无是处。如果全世界每个手
机持有者都这么做,那么偷手机就没有意义了。在澳洲,警方甚至建立了一个被盗手机数据库,如果你的手机被找到了,就可以归还给你了。

 日常维护必用: 

1、手机电池不要等到没电才充电。

一般我们都会有一种想法就是手机的电池电力要全部放完再充电比较好基本上是没错的,因为我们在以前使用的充电电池大部分是镍氢(NiH)电池,而镍
氢电池有所谓的记忆效应若不放完电再充的话会导致电池寿命急速减少。因此我们才会用到最后一滴电才开始充电。但现在的手机及一般IA产品大部分都用锂
(Li)电池,而锂电池的话就没有记忆效应的问题。若大家还是等到全部用完电后再充的话反而会使得锂电池内部的化学物质无法反应而寿命减少。最好的方法就
是没事就充电让它随时随地保持最佳满格状态,这样你的电池就可用的又长又久喔。这是从厂商那得到的讯息,并经过本身测试而得。

 2、当手机正在充电时,请勿接电话!!

 原因是手机在充电时,来电接听的话会有潜在的危险。印度有一个31岁在保险公司任职业务经理的年轻人,十几天前在手机还接着充电器的时候接听电
话,过了几秒大量的电流经过手机,这个年轻人被摔落到地面,家人发现时,手指烧伤,心跳微弱,并且已经失去意识。经紧急送到医院后,医生宣布到院死亡。行
动电话是目前大家最常使用的现代发明。然而,我们也必须要警觉到仪器致死的危险。 

3、手机剩一格时不要使用 

收讯满格与只剩一格时相比,发射强度竟然相差1000倍以上.所以……常讲手机的人……要注意哦……"0"、昨天从一位手机商那儿获得一项很重要的
讯息,那就是当你发现手机的收讯强度只剩下一格的时候,宁可挂断不谈或者是改用公用电话.千万不要再滔滔不绝、口沫横飞、浓情蜜意、欲罢不能、没完没了…
为什幺呢?大家都知道手机的电磁波一直是让人担心的问题.而手机的设计为了在收讯较差的地区仍能保有相当的通话质量,会加强手机的电磁波发射强度.当收讯
满格与只剩一格时相比,发射强度竟然相差1000倍以上.电磁波强度高达0.6W(瓦特).0.6W究竟有多强呢?我无法具体描述它对你的脑袋会有什幺不
良影响,但可以换成两个例子来比较:

1)把喇叭直径约4公分左右的小型收音机音量开到最大然后贴在耳朵上,那样的噪音能量一般为0.25W,不到0.5W。

2)把手指头放在输出强度0.1W的雷射光前面(相当于光纤网络的?D干线能量)几秒钟内你会有灼痛的感觉,你能长时间忍受上述这两种状况吗?

那你又如何确认0.6W的电磁波紧贴在你的耳朵上会没事呢? 

1.站长下载: http://down.chinaz.com/

2.CSDN下载:http://download.csdn.net

3.站长源码:http://down.cnzz.cn/

4.51源码:http://www.51aspx.com/

5.源码之家:http://www.mycodes.com/

6.源码网:http://www.codepub.com/

7.多多源码:http://www.morecode.net/

8.洪越源代码:http://www.softhy.net/

9.锋网源码:http://www.fwvv.net/

10.代码爱好者:http://www.codefans.net/

11.中国源码下载站:http://www.downcode.com/

12.源码开发网:http://www.bncms.com/

13.源码天空:http://www.codesky.net/

14.ASP300:http://www.asp300.com/

15:中国源码中心:http://www.cncode.com/

16:源码天下:http://www.pccode.net/

17.酷源码:http://www.kyuanma.com/

18.天新网:http://codes.21tx.com/

19.无忧源码:http://www.5uym.com/

20.资源吧:http://www.ziyuan8.com/

21.源码仓库:http://www.muchool.com

22.酷源码:http://www.kyuanma.com/

23. http://www.codesoso.com

24. http://www.codeproject.com

Tag Cloud