Slashdot videos: Now with more Slashdot!

View

Discuss

Share

We've improved Slashdot's video section; now you can view our video interviews, product close-ups and site visits with all the usual Slashdot options to comment, share, etc. No more walled garden! It's a work in progress -- we hope you'll check it out (Learn more about the recent updates).

An anonymous reader writes "Those of us who spend our days sitting in front of a screen trying to make computers do our bidding know how difficult programming can be. But from an outside perspective, there's not much to indicate difficulty. Most of us have heard somebody compare our job to digging ditches, or some other manual labor, meant to contrast easy (sitting around and typing) versus hard (muscle-wearying work). Now, Peter Welch has written an amusing essay to help combat that point of view, titled Programming Sucks. He compares bridge building to a big software project. Here's a small part of it:

'You start by meeting Mary, project leader for a bridge in a major metropolitan area. Mary introduces you to Fred, after you get through the fifteen security checks installed by Dave because Dave had his sweater stolen off his desk once and Never Again. Fred only works with wood, so you ask why he's involved because this bridge is supposed to allow rush-hour traffic full of cars full of mortal humans to cross a 200-foot drop over rapids. Don't worry, says Mary, Fred's going to handle the walkways. What walkways? Well Fred made a good case for walkways and they're going to add to the bridge's appeal. Of course, they'll have to be built without railings, because there's a strict no railings rule enforced by Phil, who's not an engineer. ... Would you drive across this bridge? No. If it somehow got built, everybody involved would be executed. Yet some version of this dynamic wrote every single program you have ever used, banking software, websites, and a ubiquitously used program that was supposed to protect information on the internet but didn't.' Welch goes on to gripe about all the ways in which programming is almost awesome, but ends up being annoying."

Bridge building is more like compiling.Bridge designing is more like programming/program designing.

And there's the big difference.

Civil Engineering:Design Phase costs about 10% of Build PhaseBuild Phase involves tons of construction workers and heavy machinery.The blueprints and plastic models are way cheaper to make than the Real Thing.Management often doesn't mind spending a bit extra to get the design better, because the budget only allows for one big Build.

Software Engineering:Design Phase costs more than 1000 times the Build Phase.Build Phase involves the programmer typing "make all" and going to read Slashdot or fetch a coffee.The plastic models cost as much to make as the Real Thing.

Management often sells the blueprints/plastic models as v1.0 because they compile and "kinda run" and the budget only allows for one big Design...... Aaaand the customers often buy it:).

It's not only the Software people that suffer. The guy who built the Golden Gate Bridge got sick over it and was depressed for the rest of his life and died early. I probably would've shot myself half way into the project.

Not a bridge designer myself but I suspect bridge building is well defined for how one is designed. It seems that so long as you define span and weight requirements (plus whatever other details I don't know about) you will have a pretty successful bridge.

Most software requests seem to be more like "I want to drive across the Aleutian islands, make it happen".

It's so nice to have computer programmers tell us what engineering is. I understand now why an entry level coder without a degree and not much high school math considers themselves an engineer - they don't seem to think much about the profession at all.Here is a clue guys - there is feedback in each process. Scheduling tasks is also part of engineering. Solving problems is also part of engineering. Getting that last pour done at 2am as the two halves of the bridge expand and contract enough that they ar

Good point about the hardware: it's not just about the design and building, but also about the materials you get to work with, and the environment. Bridge builders use structural steel elements, bolts, cables, and need to account for environmental factors like the ground they're building on; software designers rely on computer hardware, the OS, the network, and they will also use APIs and libraries to build the software.

The problem with software components is that they are difficult to test completely c

So the trick is to create the components so they do work in a totally isolated manner. If traffic lights v3 had a very specific specification then we could reuse them.

We do this at the moment with some libraries - openssl was used across the world because it was a drop-in library that did what it said it would do. (ok, it had a flaw, but bugs don't really count in this discussion of design). similarly webkit is used for web rendering and it works well, because it does what it says it will and is pretty much

But when you want coding to be implementation similar to construction, you have to understand that the design phase would suddenly become much more like the old Waterfall methods - where the entire system was designed, locked down, fully thought out and specified to the last detail.

That approach works for bridges because an architect will basically take an existing design and will tweak it for the specific customer requirements . Software isn't so mature it has such existing systems to work with (though I '

But when you want coding to be implementation similar to construction, you have to understand that the design phase would suddenly become much more like the old Waterfall methods - where the entire system was designed, locked down, fully thought out and specified to the last detail.

Contrary to common perception, you need a design not only for waterfall, but for agile development too. The API and specs should be done before a single line of code is written, and compared to other APIs and specs to ensure its compatibility. So you should have lots of small designs instead of one big book.The problem is that developers and managers don't want to spend that time up front, and think they can get something for nothing. And then it doesn't matter how good a programmer you are - you're codi

Contrary to common perception, you need a design not only for waterfall, but for agile development too.

And the problem is that the design for Agile is usually something like "This is what we're doing today, do what we say and shut up. Tomorrow we'll do something completely different, do what we say and shut up. No, we're not going to pay for changes, we like Agile because we don't have to do anything, just shut up and code." In my experience, this is the only half of Agile that actually gets implemented; the part where the business has to pay for changes, thus giving them incentive to think things through ahead of time and give adequate specs, is unpopular with the MBAs (as it requires them to do actual work and not drink lattes and play golf all day), so the coders get all of the drawbacks of Agile with none of the benefits.

The API and specs should be done before a single line of code is written, and compared to other APIs and specs to ensure its compatibility. So you should have lots of small designs instead of one big book.

And if you can document ONE case of that actually happening in the real world, go collect your Nobel.

Because there never was a design, and the coder isn't interested in discovering logical faults, just in getting an "approved" and move on.

The programmer frequently has no incentive to discover logical faults. They get punished for "not being a team player" and "asking too many obvious questions." They have incentive to make it someone else's problem through the approval process; however, even then it's the coder's fault even when it isn't the coder's fault.

>Bridge Analogy TimeAnd when you are supplied with help, most of them have never used construction tools but still claim to have years of experience building bridges. You assign them a section to tighten bolts and after a few days check and see that nothing is done because they're all crowded around an incorrectly sized bolt and trying to make it fit. After showing them the correct bolt size, they swing the wrench around wildly trying to turn the bolt by hammering the edge. When you ask what they are doi

The difference between building a bridge and building software is that an engineering company will build a model of the bridge, the client will look at it (and possibly several other models), say "Yes, that's what they want. How long?" The engineering company will say "2 years" and the client will probably say "OK".

In software, you build a model showing the menus, dialogs and screens, present it to the client, who then says "That's right, but it needs just this one more thing." We can have it by next Thursd

Only complete idiots/tools think this way about any profession. Brick laying looks easy, but I wouldn't trust someone who's never picked up a trowel in their life before to put up a brick wall. Anyone 'outside the profession' should only be concerned that the code works, is maintainable, and is to spec, along with passing a security audit.

Well that's not completely true. I'm quite sure an intelligent person could learn how to be a bricklayer if they really wanted to. I'm not quite as sure that an uneducated brick layer could learn to code if they really wanted to.

Disagree. How much do you make an hour? Logically if you make more than a builder, it is better to work overtime and pay the builder.

My father was like that. He could spend his entire weekend fixing something that would take a "pro" an hour or two. He made more in an hour or two than a pro made, so logically it made no sense to give up his weekend. But there was a significant entertainment value to him to going to home depot and figuring out how to fix it.

Many jobs do allow you to forego working for extra vacation days, at a pre-specified rate. So you DO have a specific "value" to your free time, as set by your employer. Even if you may have trouble redeeming it at that rate by someone who is not your employer.

You do however have the opportunity to pick up some consulting jobs, to do side jobs, or perhaps pick up some side projects. But, depending on what you do, YMMV. A lawyer, web designer, or other profession may have no problems picking up a few extr

About 30-35 years ago I remember how people would be playing around in Basic on the weekend for entertainment. It really isn't that far-fetched, and messing around with the tape deck and volume control just to let things load made people realize that programming is a lot like Building in the Real World, where having a PZ screwdriver instead of the PH you really need sort-of-works but makes your life a hell of a lot harder. I don't know what it's really like today, I've been doing it professionally for too

As someone who has spent quite a lot of time in "menial" jobs during my university years to get enough money together to get by, I can inform you that most jobs where you'd say "an idiot can do that" from watching are harder than they look. Mostly because you're usually watching people who have been doing it for years and practice does make perfect.

It will probably take longer to teach someone programming "from scratch" than it would to make him a decent bricklayer, but I wouldn't simply assume that it's easy because it looks that way.

Well it is a craft and requires practice. And programming requires practice as well. But it also requires a higher level of intelligence and problem solving. You can be an idiot and so long as you know how to put in bricks, if I say "Build wall here" you could do what you need. I've seen plenty of "programmers" who just lacked any sort of problem solving skills and ran into a wall (pun intended)

I'm in IT security. This involves amongst other things code reviews. In other words, I get to see a lot of code.

And judging from quite a bit of code I've had to see lately, I can only assume that the level of intelligence and problem solving skill required to enter into programming has been lowered by some kind of leg-up, no-dud-left-behind program...

Actually, your simile with brick laying is what I found fits better with how software projects work. I mean, you build a bridge and be gone. Most software projects start as "we want to build a wall", but then they switch to "we want a wall with a door and greco-roman finishes", and it keeps growing and growing until you have the Pisa tower with a kitchen in the roof top, all made of small bricks and lot of glue.

When the client starts as "we want to build a wall", your first step is to reformulate it as "we want to go from side A to side B of the river". This way, you can notice that the right solution is to buy a ferry boat.

I'm 10yrs from retirement I dropped our of HS in 1976 and have spent the last 26 as a degree qualified developer. Before my degree I spent 15yrs as a labourer, I did a stint as a brickies labourer, spent a year in a remote Aussie sawmill, farm hand, deck hand, concrete formwork, and many more "strong back, weak head" style jobs, I married young and had a wife a two young kids, I'd willing have done pretty much anything people were willing to pay me to do....

1. "code works": Easy to say, hard to check. It might work today in some circumstances but fail tomorrow in other circumstances.2. "is maintainable": That's a subjective criteria which is impossible to enforce.3. "is to spec": Again, easy to check for common pathways, but hard to catch all the nuances (for the same reason that no one has 100% code coverage in their unit tests).4. "passing a security audit": This helps, but as well all know by now it does not guarantee that the code is secure. Code usually d

Wimp working for an excessively-large company with rules that might allow "casual Fridays" with strict dress codes. He's whining about corporate culture, not programming. The "Neo" problem that first gave you the hint that he wasn't an actual hacker, just some script kiddy in a minimum-wage cubicle farm.

The best part is when you find out that the "other guy" who put in the stupid code is you from months or years ago. You start to get incensed and rant about what idiot would write such awful code, check the commit logs, then facepalm as you realize it was you.

I occasionally wonder if that kind of thing would happen less frequently if our profession wasn't so quick to fire the guys whose gems turned black.

The "minimum-wage cubicle farm" culture is the problem. Reading his story, I can pretty much think of someone in my career who filled the shoes of each person mentioned. You know it's funny, if we want to engineer a bridge, or a skyscraper, there is a consistent order and process to putting it together and documenting it. If we want to do that with programming, people just do whatever they want, put some duct tape here and there, and hope it doesn't fall apart. Of course part of that is management gener

Software Development is still a young field. Someone who wants a bridge built can look back in history and see all the horrible consequences of not shutting up and listening to the people who know better than them. There are strict regulations, there are guidelines to follow. Humans have been building stuff since the first ax hit a tree, while the consequences of faulty software has just recently started to manifest itself to the general public. Comparing software engineering to regular engineering is an unfair comparison when regular engineering is built upon hundreds, if not thousands, of years of experience.

I heard a saying once, maybe it was here on/. The reason an older programmer is slower than a younger one is because of the number of answers he has to the question "what could possibly go wrong?". That is true on a larger scale for engineering vs. software engineering.

Most large software projects are run by people who have fuck all clue what it entails to produce good software, people who don't see the value in spending another couple grand on a few more weeks of design, people who have clients they sold vapor to and now need the product yesterday. Software that works is easy to produce, and nobody can see the rickety scaffolding underneath, so it is really hard to argue with a non technical manager that something needs to be changed - after all, the shit works doesn't it?

That was the point though. But software engineering is not treated with respect because 90% of the product is invisible. With regard to the reply you've made below about aerospace engineering, you're right, that is a new field too - but the product is visible, you can see what your money is buying. And even though it's flight, it still builds upon engineering principles accrued over a much longer time span than software engineering does. There no MBAs heading up engineering teams designing and building plan

It's a good article, and all too true. Software is a house of cards at best, with your boss shaking the table, the hackers throwing ping-pong balls at the house, and the NSA coming down the hallway with a baseball bat.

Nah, the NSA is more that asshole that comes sneaking up to your house of cards and keeps wiggling at the cards looking for the one they can pull out without having the whole thing collapse, then laugh with glee when they find one, dance around the house and that's when the whole thing comes down from the vibration they make on the floor.

Compare this to digging a ditch, which is hard labor, but provides almost instant gratification (you can always look at how much of the ditch you've already dug), and you're not likely to fail completely (unless you're trying to dig in solid rock).

Programming is digging a trench in a puddle. You don't see what you're doing, you don't see your progress and due to the water seeming to rise as you dig away more of the ground you're standing on, it seems to get worse and worse with every load you throw out.

Every programmer starts out writing some perfect little snowflake like this. Then they're told on Friday they need to have six hundred snowflakes written by Tuesday, so they cheat a bit here and there and maybe copy a few snowflakes and try to stick them together or they have to ask a coworker to work on one who melts it and then all the programmers' snowflakes get dumped together in some inscrutable shape and somebody leans a Picasso on it because nobody wants to see the cat urine soaking into all your broken snowflakes melting in the light of day.

If you start cutting corners, you're going to end up with a mess. If you're a good programmer, you know how to write solid code even under time constraints [canonical.org]. If you're having trouble with it, then you should probably look into the YAGNI principle, or get better at estimating how long your tasks will take. Because those are the two things that seem to afflict programmers who are chronically behind schedule.

I've worked at places where you just want to scream at the ineptitude of the seniors. They ask how long it will take to code. You tell them 3 months. They say do it in 2. You try and cut all sorts of corners, some dangerous, no room left for contingency then suddenly at week 6 you get told it's now 7 weeks not 8. Code goes to test and not surprisingly, it's crap. They then go nuts over code quality and say you must do better next time and faster again too.
Dear seniors. The reason the code is crap is becau

Changes in plan are part of the reality of programming. Include them in your estimate. Write flexible code, that is part of YAGNI

If you have confidence in your estimates, don't let your manager push you around. Stand by it. Be kind, and tell him you will estimate anything he wants, but it will still not get done any shorter than your original estimate.

And make sure you hit your estimates. Programmers who have trouble with their bosses changing their estimates are usually the types of people who don't hi

That joke actually stems from Soviet times and was making fun of perceived and reported field yield vs. real, but it works just as well for management and projects.

A programmer has to estimate how long he'd take to get something done. He ponders, calculates and finally decides: 3 months.His supervisor isn't happy with this, 3 months, that's probably too long. He notices the programmer has a vacation planned and there are a few holidays that he could work overtime in, he cuts those and corrects the estimate to 2.5 months.The group's superior isn't happy with that. The quarter report is due in about 2 months. But if they think they can do it in 2.5 months, they sure can do it in a week or two less by cutting time somewhere or working overtime, so he puts down 2 months.The department head doesn't like what he hears. The general meeting of the shareholders is in 6 weeks and he sure wants that prestigious project to be mentioned in there. But maybe somehow we can cut 2 weeks somewhere, probably we'll hire a temp or some other way that doesn't cost... anyway, they can do it in 6 weeks, too, I'm confident!The project lead finally gets the estimate and is very happy. 6 weeks! We have almost 3 months time left! Time to push for those features I wanted, they said they'd tack 2 months onto the project, but somewhere they can surely shave off 2 weeks of those and we'll be done in time!

I've experienced this first hand. I gave my estimate for a new feature. Over the course of the remaining meeting, I literally watched my estimate get cut in half by the client and management as they shuffled dates around.

I then chimed back in with my original estimate of how long it would actually take in the real world, and somehow everyone was upset that I had moved the deadline. Unreal.

The author has a great sense of humor, and ripostes some of programmings possible pitfalls into clever and hilarious absurdities. However, I strongly refute that this article is a remotely accurate portrayal of programming, and I hope it is not taken as such by prospective coders on the fence. In my view, programming is possibly one of the few havens of relative sanity available (although with wood-working and pure mathematics probably have it beat). The true insanity is HUMANS TRYING TO COLLABORATE WITH OT

What I struggle with is translating badly worded/badly thought through/incomplete business requirements into program logic. All too often something which seems straight forward to a business person is a can of worms when it comes to implementing it.

Back when I was still programming, i once got a spec sheet written on a post-it. Yes, a post-it. Half of it was a diagram. Ok, granted, that was a VERY special case where everyone involved had a kinda-sorta idea what's going to get programmed and it was by no means very complicated, but it showcases very well the problem.

Later, when I was the one organizing a team of programmers, it was my policy that I get a written and signed spec sheet from the project sponsor. If he can't be assed to write specs, my team can't be assed to write code. And that was when I had the revelation: They don't really know what they want themselves. They only know one thing, they don't want what you will produce. They usually want something akin to a magical box that fulfills their wishes. And sometimes I get the hunch, especially with some of the older stakeholders, that this is pretty much how they view a computer. And programmers are some kind or arcane wizards who make the kettle boil and bubble until the program emerges somehow magically.

They fully expect you to know their needs and usually have a very hard time communicating them because a lot of things that make no sense to you are obvious to them because it's their daily bread and butter. And hence these things will be sorely missing in the specs.

I soon learned that it is a good idea to write the specs together with them if you want a project to succeed. You could tell I wanted your project to fail if I had no time to do that...

Exactly. What is supposed to happen is the business describe a need. A Business Analyst spends some time with them (weeks if needed) discussing it, teasing out what they really want (business people are very good at putting forward a solution disguised as a requirement and often, it's the wrong solution) and liasing with techies to see what can be done. That's your business requirements and rules. The architect then maps that to the systems available and decides at a high level how it all hangs together. T

They fully expect you to know their needs and usually have a very hard time communicating them because a lot of things that make no sense to you are obvious to them because it's their daily bread and butter. And hence these things will be sorely missing in the specs.

That's why requiring a big upfront whole signed specification is useless. Users may not know what they want exactly, but they're very good at knowing it when they see it; they know exactly what problem they want to solve.

I caught part of a documentary one time that was talking about needing to manually give female pigs an orgasm, but they didn't point that out to the workers doing that because it would be too horrifying. I suspect it was after the sows were injected with semen, to facilitate its passage to the right place.

In some sense, these two can be the same thing. For example, I find working as a teacher more difficult than any of the science/programming I've ever done, even though the individual technical challenges may seem much easier. Dealing with troubled kids from day to day can make your life feel difficult in a grander scale.

When people work in a group as a team this inevitably happens and that's all right. Building a perfect software that satisfies everyone is a hard NP problem. What's the point of being perfectionist if that 10% you wish to polish it going to consume 90% of your time and money.

The comparison that has been coming to my head, regardless of whether I was self- or otherwise- employed is: coders are the plumbers of the Internet age. Furthermore, we are the electricians, the elevator drivers, the janitors, the security guards, the dealers, the cops, the architects. All generalized comparisons apply, because the Net is a representation of the world. Slightly skewed, a representation nonetheless.I am proud of the being an Internet plumber and cheers to others who spend their days trying make it work smoothly.

From what I've heard, actual construction engineering is typically not that far removed from the description in the article.

Sure, the designs in construction engineering are way better proven and tested than the designs in software engineering, but the building process is in many ways still a trial and error affair where things can and usually will go wrong. Then the post mortems sometimes come with literal post mortems attached to them. How well do you think those engineers sleep at night?

As someone who had a part-time construction job in college: It's amazing how many people doing that actual building on construction projects who fuck shit up and then hide it long enough that by the time it's discovered the designers have to tweak their near-perfect designs to incorporate workarounds.

Thankfully you don't get that in software development, it'd be like a world in which developers wrote near-flawless code but your average compiler/interpreter played it fast and loose and did shit like randomly

a} Clueless psychopathic suits in management, who make impossible schedule demands, and have no programming background themselves.

b} The use of popular, but garbage programming languages. C++, PHP and Perl are probably the main three culprits here. Dishonourable mention also goes to XML, JavaScript, and the XHTML Document Object Model. I have never encountered a "Web application," yet, which wasn't a disorganised, bloated, CPU hogging abomination.

For the last two months I've been economically forced to use a dual core 1.5 ghz laptop with 2 gb of RAM, and it can only barely keep up with the inefficient, JavaScript-infested obscenity that the Web has become. Virtually none of said JavaScript ever provides truly valuable functionality, either; most of it is just trackers of various kinds.

It's also purely due to Capitalism; all of it. Why have Red Hat had Lennart try and force systemd, GNOME, and the rest of their corporate crapware on Linux users? Their desire for a corporate monopoly, that's why.

What caused the UNIX wars? Corporations wanting to add their own non-standard extensions, to ensure their coveted Unique Selling Positions.

Clueless psychopathic suits in management, who make impossible schedule demands, and have no programming background themselves.

Yeah, I can feel like that too, sometimes. However, I don't agree with the picture you paint - it isn't the case that all management is always useless and harmful and all engineers are always competent and beneficial, but so completely restricted in their options that they can't write good code. Most managers in most IT companies are in fact willing to listen to sensible advice and make concessions that make life easier for their staff; after all, a manager's success is measured by how well his team as a whole does, so a successful manager is likely to be one who is able and willing to communicate with his employees. But it only works if the employees are able and willing to communicate facts to the manager in a language he can understand and use to make sensible decision with; and engineers are notoriously bad at doing that.

The use of popular, but garbage programming languages. C++, PHP and Perl are probably the main three culprits here....

There is an old saying that goes something like: Don't blame the tool for bad craftsmanship. If you are a good programmer, then you can write good code in any language that you know - COBOL, FORTRAN,... Haskell, C, C++,... - even Intercal. The problem with some languages is that they demand much more of the developer - using C++ well requires a much higher level of theoretical understanding of good design than using a simple language like C, so it is much easier to loose your way in obscure and misunderstood constructs in C++.

That was a pretty good rant, but if you want a true description of the mind-melting Lovecraftian horror that is programming (from a Microsoft distributed systems engineer, no less), there is no better read than this article [microsoft.com].

Actually, it is more like solving a huge jigsaw puzzle, but without an actual picture of how it is supposed to look when it is completed, and with a picture that changes while trying to put it together.

Because the code I wrote is not what is being executed, and if it was, we would not have the level of performance we have today. Moreover, the level of complexity of today's computer. Moreover, tolerance are such in the physical world that a construction guy can afford to "cut corners", whereas software is a lot less tolerant to a bad input, remember, it's a dumb automaton.

The article is very funny, and makes a lot of good points, but it's not really addressing the question. It gives reasons software projects are difficult. Not why programming as such is. The engineering part, if you will.

The reason programming is difficult is because it's discrete. Whereas most (all?) other engineering is continuous.

If you try to bend a steel rod, there's going to be a range of strain for which nothing will happen, another where it will flex and recover, another where it will flex permanently, and finally a point where it will fail. This is all contiguous, and you can reduce it to a few numbers that will accurately predict the behavior of identical rods. Depending on the expected load, and the desired behavior, you can then pick the right rod, that will behave the way you need it to, with a good and predictable safety margin, because you know when what will happen.

Software, on the other hand, is discrete. That linked list can behave correctly as you add elements, then remove them, all good, then fail when you remove the last one and it (should) become empty again. There's no hint of that unless you test the very specific condition. There is no failure progression. There is no concept of safety margin.

I once heard a horror story of an embedded software project. They were forced to only use debug builds, as the release builds seemed to trigger a race condition in the start-up code. The 'held together with paper-clips' approach to software engineering...

Software that works very differently in debug builds is common. The 1993 edition of Steve McConnell's "Code Complete" was the first thing I remember reading that talked about reducing debug vs. release variance. IIRC, Microsoft was chewing this problem heavily then because the betas of Windows and their development tools going to developers included debug instrumentation, while the released versions did not.

SPARK falls squarely into silver bullet territory. Taking on that idea goes back to at least Fred

It is....sometimes. The biggest problem with Open Source QA is also one that affects a lot of research, everyone wants to code, nobody wants to be a reviewer/bug fixer.

Look at the HeartBleed bug, there was only one source review before release. There could have been more, but open source suffers from the peer-review paradox: the people with the ability and resources to do thorough reviews are the ones least likely to want to do reviews. Quite simply, there isn't any "glory" in it, and it isn't nearly as much fun as creating new code yourself. Now in big commercial operations, especially web sites, there are large QA departments where everyone has a financial motivation to scrutinize code and find weak spots. Really if companies like Google et. al want to help open source, they shouldn't just contribute code, they should donate their QA team's time and talents to doing really thorough reviews on critical open-source code before it's merged into the main branch.

Where's the paradox, it's the same in science. Everyone wants to make the new discovery, nobody wants to review and verify them.

Verifying is easy. Checking and finding out that it doesn't work, not because you are too stupid to reproduce the experiment, but because it just doesn't work, that's the hard part. Plus you don't make friends doing that, obviously.

This is a real problem. Open source projects have a very varying degree of Quality Assurance.

Look at the name - Quality Assurance. QA can only tell you it's bad, it doesn't make anything better. And what they can look at is usually only the external, visible part, which may seem to be working nicely but built from spit and wire on the inside, ready to fall apart at the next version update of the printer driver. That doesn't mean QA is useless, it's just a final double-check to see that you've built the right thing.
No, writing good quality software is a team effort of everyone involved. As a de