The idea of a professional degree has crossed my mind. There's enough of a gap in knowledge and ability required to transition from writing static web content to writing high quality (maintainable, operationally sound, scaleable) enterprise backend code that it starts to look like a paralegal/lawyer, LPN vs. RN, etc. distinction. The difference is that the public has little interest in regulating engineers, but it does have an interest in regulating lawyers and nurses.
I'm personally deeply suspicious of degrees. I'm returning to school to get a professional masters in CSCI, but the program explicitly requires work experience as a pre-requisite for entry (which seems like a no-brainer to me). It also has a high price, which is not something I would foist on the community.
I don't think "programming" should ever be tied to professional institutions as such (much less academic computer science). It has strong roots in free, open-source, decentralized, hacker-minded culture, and I don't think we should ever give that up.
So I guess I'm of two minds about the idea of a professional engineering degree. On the one hand it would help raise expectations about professionalism and accountability in software, which seem pitifully low right now, and on the other hand, it seems like a path no one in their right mind would want to go down.
My ideal would be something like the actuarial exams. You start with exams on math, calculus, linear algebra, DEs, probability theory, numerical analysis, and so forth. Eventually it moves on to more industry specific exams. There are quite a few, different levels to pass.
It is highly rigorous, but one very key feature of all this is that you don't have a specifically proscribed academic path. There isn't a situation like law school, where aspiring professions are essentially forced to spend $120k+ on tuition to join the profession. You can major in math, I think that's most common, and graduate degrees are not unusual either, but you can major in a related field or, as far as I understand, just study math really hard on your own. You are free to decide how to prepare.
Looking at these tests, I can't possibly imagine that anyone who can pass hasn't learned very rigorous coursework.
Something like this could work for programming. We could set up a series of exams, similar to the actuarial math exams, but covering the essential CS work (another bonus: we could do this once, and it would be graded consistency and fairly, rather than being subjected to repeated "interviews" where we are randomly quizzed on data structures every time we apply for a new job). As it moves on, it might get to more industry specific things.
CS would be an advantage, sure, but a math major who has taken some CS and plugs the gaps through self-study would be perfectly free to join the profession. This is essential, in my opinion, it's very important not to allow a cartel like the law schools to take over. That would be extremely harmful.
I'm sure I haven't thought it all through, but this seems to be the most promising approach.
Oh, and lastly, it's not engineering! The licensing bodies for professional engineers are honorable organizations that have no domain over software, no more than they do over actuarial work. Software is its own thing, it isn't engineering.
Real engineers can be sued and loose if they signed off on something
In software? Almost every EULA comes with "We assume no responsbility for anything, anywhere, ever"
No degree, but rather a programmer publicly signs off on his code, and gets both credit and blame for it.
Anyone who wants can register for a programmer ID (in practice a public key). There is no test, just an administration fee.
When you write code you sign off on it, perhaps with some accompanying text describing what parts you worked on.
No more anonymous code shipped by a company entity, instead do it like how movies are done: Every single person gets credit (including QA and administration), every tool used gets credit.
Seems like a great way for company bosses to say "nah, we didn't know about this, the rogue programmer there made the decision".
Unless you have some way to also blame the management responsible for deciding such a design should be implemented.
Their name is on it as well, with text describing what they approved.
Company-wide, there was a rigid system in place that captured electronic signatures as change requests were documented, code was modified, and tests were completed.
Anything that was done flowed through at least those three distinct groups (data team lead, maintenance programmer, & QA). We could easily tell how a study's database had been modified in the past (including who had requested the change, who programmed the change, and who tested the change)...there was always an expectation that every i was dotted, t was crossed (or semicolon was in place) before anyone signed off on their work since it would permanently enter the record and couldn't be erased.
Consider an analogous situation: You made a mistake designing a building. Should you be able to shrug it off as "mistakes happen"?
This has actually happened in the real world with buildings, and when it does if you are responsible and work diligently to correct the problem people are understanding.
Do the same here.
I'm yet to see a building collapse around me in my city - I see software fail all the time though - I think we are better at building tall buildings than we are building software.
Not so for software.
Perhaps if you change that software might change.
The liability sits with your employer.
As a full time employee, the liability falls on my employer.
We don't even know what computers or software would look like under such a scenario.