The Programming Behind Obamacare

.
The Story Behind The Disaster of “Healthcare.gov”

Obamacare computer code riddled with typos, Latin filler text, desperate programmer comments and disastrous architecture 

 

Thursday, October 10, 2013
by Mike Adams, the Health Ranger

(NaturalNews) If I had told you one month ago that ten days into the launch of Obamacare not a single person could be confirmed to have successfully enrolled, you would have called me a lunatic. And yet, here we are, tens days into the launch, and guess what? The White House cannot produce a single person who has successfully enrolled through the federally-run exchange Healthcare.gov.

Not one.

The real story on the catastrophic IT disaster known as Healthcare.gov is only now beginning to be recognized by the nation. As a person with a strong IT background running large R&D projects, I was among the very first to claim that Healthcare.gov is not just broken, it’s DOA  because of critical design failures.

It’s not merely a “glitch.” It’s way beyond a SNAFU. This is the defining failure moment of the delusional thinking of democrats and their fantasyland government-centralized economy.

Even ABC(sic)  News is now calling Healthcare.gov, “nothing short of disastrous,” adding, “Media outlets have struggled to find anyone who has been successful.”

My analysis of the Javascript running Healthcare.gov 

 
I have personally looked at the Javascript code running part of the Healthcare.gov website. If you are curious how I got the code, I simply typed the URL of the Javascript code into the browser address field. The browser then pulls up the entire code block, because Javascript is client-side code (not server-side).

What I am seeing in this code is nothing short of jaw-dropping. As people are now saying, this code is “CRAAAAAZY!” You almost can’t even call it Javascript code. If you sat down 100 monkeys in front of 100 typewriters and told them to start banging away, I’m confident at least one of them would come up with something far better than the Healthcare.gov Javascript code.

In fact, I am practically ROFLMAO just looking at this code. Any competent programmer in the world, upon seeing this, would just burst their britches in knowing the U.S. government spent $600+ million dollars on this project. Inside the code, the Javascript programmer comments are just off-the-charts hilarious. Comments found in the code include (yes, these are actual text comments from the script):

“TODO: add functionality to show alert text after too many tries at log in”

“make sure we don’t try to do this before the saml has been posted if (window.registrationInitialSessionCallsComplete)”

“Attention: This file is generated once and can be modified by hand”

“Fill In this with actual content. Lorem Ipsum”

“TODO: maybe modify the below to use a similar method instead”

 

Riddled with typos and errors in the error messages 

 

The code is also full of juvenile typos such as “‘Misssing Password” and “This is not a valid organazation ID.” Seriously, was this written by eighth graders?

Even error messages contains their own errors, such as “‘Exception in [sic] retreiving REInsurance Plan by criteria.”

It also contains brain-dead user instructions such as:

“You need to send the Marketplace proof that you are not enrolled in Medicaid or the Childrens Health Insurance Program (CHIP). Examples of documents you can send include Letter from Medicaid or CHIP.” (Yeah, right. Can you imagine calling Medicaid and asking for a letter stating that you are NOT enrolled in Medicaid?)

“Verify [FN]’s SSN and date of death, if applicable”

“Check all attestations before submitting your application.”

“Send the Marketplace proof that [FN] isnt incarcerated (detained or jailed) by [Date].”

 

Do you speak Gujarati? 

 
Although this Healthcare.gov computer code fails to function it does however support the language known as “Gujarati.” According to an online encyclopedia, “Gujarati is an Indo-Aryan language, native to Gujarat, Daman and Diu and Dadra and Nagar Haveli in India. It is part of the greater Indo-European language family. Gujarati is derived from Old Gujarati (1100–1500 AD) which is the ancestor language of the modern Gujarati and Rajasthani languages, and is the chief language in the state of Gujarat.”

I am absolutely thrilled to know that my tax dollars may someday pay for the health insurance coverage of an ancestor of the Gujarati and Rajasthani languages, from the state of Gujarat. So while our “greatest generation” World War II veterans are being barricaded out of national monuments, the Obama administration is prioritizing providing subsidized health insurance coverage to descendants of the state of Gujarat.

 

Latin filler text 

 
Laughably, the application code is also riddled with Latin used as filler text. For example, one line of code actually says:

resources[‘ffe.ee.myAccount.home.specialEnrollment.description2’] = ‘Lorem ipsum dolor sit amet, consectetur adipiscing elit.’

Latin is used by programmers as filler / placeholder text for unfinished applications. The fact that this Latin is found in the code is yet more proof that the entire system never even entered Alpha testing, much less Beta testing or an official release. This is pre-alpha code requiring possible YEARS of development for final release.

 

Bizarre error messages also found in Obamacare code 

 
Error messages written into the code leave no doubt that the people who wrote the code are masters of chaos and confusion. Here are just a few of the error message I found by casually scrolling through the Javascript publicly posted on the Healthcare.gov website:

“Exception in inconsistency adjudication process”

“Notices are official messages that lorem ipsum.”

“Exception in triggering the Inconsistency Clock Service” (By the way, this error message confirms I was right in my public prediction about the system suffering from time clock synchronization errors.)

“Not Acceptable – Queried enrollment group plan is empty OR Selected plan doesnt existException in calling RetrieveNonFaPlanReviewConfirmDetails service”

“Please wait a few minutes and try again.” (Uh, 10 million people tried that already…)

And here’s our favorite, which claims that your application can’t be processed because somehow gremlins behind the curtain are going to “make sure you get the lowest cost…”

We cant finish your application now — its going to take us a little longer to make sure we get you the lowest possible costs. We will contact you again soon with more information. If you have questions, please call us at 1-800-318-2596 (TTY: 1-855-889-4325).

 

Truly disastrous architecture calls over 1,000 resources just to load one page

Even though I have only seen the public Javascript code and not the server-side processing code, the Javascript itself is truly disastrous — on an epic scale.

For example, the Javascript file loaded for each user transfers all error messages, form field messages and front-end error messages from the server to the user’s browser repeatedly for each cultural language supported by the system.

In other words, the entire set of error messages is hard-coded into the Javascript for English, then again for German, then again for French, Spanish, and so on, all the way through Gujarati and who knows how many other unheard-of languages.

I don’t even know how to begin to tell you how disastrously idiotic such a design is. It practically guarantees a critical server crash under any kind of real user load. No programmer with an IQ above 100 would design js code in such a manner. This code was designed and written by utterly incompetent people who have built into the system exactly the kind of architecture that will make it fail if anyone tries to use it.

When HHS Secretary Kathleen Sebelius says this code is “functioning,” she’s actually painting a giant “dunce” sign on her forehead. This code is so far from functioning that all the government programmers in the world couldn’t make it work smoothly by January 1.

 

Was Healthcare.gov designed to fail? 

 
It’s almost as if the entire system has been designed to fail. There is no rational justification for writing code like this. It’s like someone held a contest to find out “who can write the most inefficient, wasteful computer code” and Healthcare.gov won the top prize!

And yet, at the same time, this project perfectly reflects the foundational philosophy of the Obama administration: sell the dream to get elected, then screw everybody when it comes to implementation.

It also forces you to ask the question: To what lengths will Obama go to try to cover-up this disastrous mess by causing some other crisis as a distraction?

I assure you this system has zero chance of smoothly functioning by January 1, 2014. And that means a massive public backlash is on the way. As the truth comes out on this, the Obama administration is going to be embarrassed like nothing else we’ve ever seen in the history of government. This failure is so monumental, so critical, and so disastrous that it discredits not just Obama but the entire socialist fantasy of government-run, centrally-planned economies. Healthcare.gov is the ultimate argument for a free market run without government interference. It epitomizes the incompetence of Washington D.C. like nothing else in history.

 

No need to delay Obamacare; it will collapse on its own 

 
Ultimately, this also means we don’t have to worry about trying to delay Obamacare. Obamacare is going to destroy itself!  Sooner or later, the entire country will realize the absurdity of being fined by the IRS for not buying a mandatory insurance policy that cannot be purchased because the government-run exchange site is utterly non-functional.

Obamacare will go down in history as the greatest IT failure in the history of the world. I can already see this outcome reflected in the code. As usual, Natural News is days, weeks or months ahead of the curve on this, so don’t expect the mainstream media — largely staffed by fantasyland Obama worshippers who know nothing about computer code — to grasp the seriousness of the critical failures that will bring this system down.

By the way, guess how much you and I paid to build this failed, disastrous system? $634 million. It’s a bargain!

~ ~ oOo ~ ~ 

 

There are two available responses I find to this information. While diametrically opposed, both are equally valid. One, Laugh like a braying jackass. Two, Weep like you lost your BFF.

The apparent total lack of coordination among all segments of the ACA framework and environment doomed it from the beginning. The question does remain in my mind, how the state run signups are going to meld and merge with the centralized “healthcare dot gov” when it is, itself, completely inoperable and will not be operational for a period of years, if ever? Didn’t the company or companies doing the programming ever hear of “Flow Charts”???

 

My Daddy always said, “Don’t start vast projects with half-vast ideas~!”  He’d flat go into ballistic orbit with this. And he was not computer literate – He was a systems mechanic on C-124 AIRCRAFT~!

This is a companion piece to Garnet’s most excellent post, “The Obamacare Scareware System

~ ~ Grouchy ~ ~

Tagged , , , , , , . Bookmark the permalink.

15 Responses to The Programming Behind Obamacare

  1. Hardnox says:

    Reading this I am left to conclude that it was never meant to succeed. Either that or this is the result of public education these days with proof of the typos.

  2. Garnet92 says:

    Guys, I was a programmer, a systems analyst, a systems designer, a project manager and finally, ran (along with two partners) a software company. We developed our own products as well as performed facilities management for several large firms. I know something about development and implementation of software systems and I believe this fiasco to be inadvertent rather than intentional. Obama’s brain trust (guffaw!) may indeed have wanted the rollout to fail, but the evidence I’ve seen doesn’t support that theory – what I’ve seen (including this piece) convince me that it was overall incompetence – from the selection of the subs, to the project management, to the designers and finally the coders. My company, given three years and an unlimited budget could have produced a better product – and that’s no BS.

  3. I believe it, Garnet – I KNOW you could have done a better job. But this whole thing is just all the rest of his residency – Gross incompetence, and unadmitted, and unacknowledged, at that.

  4. Hardnox says:

    Garnet, I don’t doubt you and your partners would have produced a better product. With $634 million and counting I imagine they could have used a WordPress platform with a shopping cart add-on. This is beyond incompetent. It is stunning. Then again, everything this administration has done has turned to crap, so what’s new?

  5. Mrs AL says:

    Proof positive that government ought NOT be in the business of producing a “product.” The mere fact that obamadoesn’tcare is even perceived as a “product” should produce its demise. Since when does any government produce anything? They are to govern, not produce.

    Thanx for bringing this to us, Grouchy. And indeed, it is a companion to Garnet’s post. What I still don’t understand is how this could be so messed up. To my non-computer programming brain, it sounds like the U.N. with all the different languages being spoken and no interpretation.

  6. Clyde says:

    Having 2 daughters with Masters in computer sciences, they tell me this whole program looks like it was an exercise for a beginning computer class.

  7. Kathy says:

    This is definitely a project that should have been contracted out to professionals and makes me wonder why O’s commie friend Bill Gates didn’t get the job.

    This would be laughable if that weren’t our $634 million. Personally, if I’d spent that much of the peoples’ money, I sure wouldn’t tell them how much I spent until I made sure the stupid thing worked right.

    • Bill may be Socialist,,, or whatever,,, but he had / has a degree of COMPETENCE, which concept is anathema to this administration. This is one more way to denigrate, degrade and destroy the American Ethics.

  8. Saltwater says:

    The author wrote about the apparent lack of testing before rollout of this system. Of that, I have no doubt. Although not a trained programmer, I have done some coding in my prior lives as a Navy technician and as a defense contractor.
    [Full disclosure (and at risk of dating myself): this was back in the dark ages when FORTRAN ruled. I have very limited exposure to JavaScript other than as a user.]
    The FIRST thing I learned was that my programs would work just fine – as long as I was the one using them. However, let someone who did not know how the program was designed at the keyboard, and all kinds of logic hell could break loose. Something as simple as an incorrect value input as a response would quickly bring my “masterpiece” to its digital knees.
    A true life example was where the program needed a numerical value, and sent the straight forward inquiry, “How Many?” The technician made an easy typing error and input “Q” instead of “1” – the system froze. I had not considered a need for handling such an error. After that fiasco, I went to great lengths to insure my code was “sailor proof” before integration.
    My concept of proper testing protocols dictate that testing not be designed to see if a system works; but rather what does it take to break it?

    • I had been out the service over 12 years when I took a course in FORTRAN and looked at COBOL, and a few other Languages now consigned to the dustbin of history.
      You are SO right – What does it take to break it? AND, what will send it into an endless loop?
      Like you now, I leave the programming to others. BUT, I’m glad for the exposure~! It has a lot to say about LIFE, itself.
      Thank You for your most welcome input.

  9. vonmesser says:

    Does anyone here read Latin?
    The mentioned line can be translated as
    THIS IS A PLACE TO PUT A COMMENT or
    HERE IS A PLACE TO POST A COMMENT.