It is awkward to both the teacher and the student, because teaching with a camera up so close to one's face is so, and just because Salman Khan (Khan Academy) did so, doesn't mean every Udacity, edx, and Coursera should. Remember that in the beginning, Salman Khan intended those videos for his cousins.
Just look at SEE, to see how effective a traditional class room style teaching can be. SICP, SEE and CS50 are hands down the best lectures I ever had the pleasure to learn from.
Prof Malan is one of the best lecturers I have had the pleasure to learn from, knowing how to keep an audience interested in just about anything. Malan and his army of TAs have also done a fantastic job of creating a community around CS50, and have provided a plethora of resources for their students. Their assignments and problem sets were also perfect. They were challenging and interesting without being inaccessible; teaching both programming skills and being relevant to important CS concepts. We also got a special lecture from Brian Kernighan at the end, which was a real treat.
I'm extremely appreciative for the skills and knowledge CS50 has given me, and would highly recommend it to anyone willing to take on the challenge. It's the reason why I have my current interest in and basic understanding of CS.
I'm really excited for what online education can offer if many other classes can be brought up to the high standard Prof Malan and his team has set. With 5 years of community college (8th-12th grade) and a semester at a top liberal arts college, all taken in-person, CS50 remains one of my favorite classes (in terms of interest, challenge, fun, etc).
I should also mention I took CS75 with Malan as well, and while it wasn't quite as enjoyable for a number of reasons, it was also an excellent course.
Did you find that the lectures provided enough basis to complete the problem sets? A number of students I talked to struggled to actually piece together code after the presentation of mostly concepts in lecture.
For some of the more beastly problem sets in data structures and memory management, where Googling the error message just didn't cut it, I had to watch through all that week's available content (both lectures, both recitations, the walkthrough and the shorts) before gaining enough momentum to grind by. That's where it really hurt to not have another student sitting in the next seat to bounce ideas off of. They've put together a well monitored forum but it's not the same as walking someone through your code. I got it done, but some gray hairs could have been avoided.
One of the major areas of improvement for all online ed is how to bring back that frictionless asking of questions. It's a comparative advantage for both people -- you may save me two hours of frustration with ten minutes of your time on a particular memory error and I may save you two hours of frustration in a similar fashion by better understanding pointers.
Compare it to MIT's course on the same page - they spend lots of time to explain you whys and hows, so later you nave no questions when faced with crap like PHP.
They not just taught you coding in Python, they explain how it works and why - they teach you environments - how all those classes are implemented, so, when you see Ruby, your educated guesses (note language usage) will be correct.)
So, Berkeley's CS61A by Brian Harvey is where to start. After this course you need data-structures and algorithms (MIT has good ones).
Then it doesn't really which crap you have to face in industry - PHP, Java, something from MS or SAP - you will be able to pick up in on the go, because you have learned those fundamental hows and whys first.
Both Harvard's CS50 and MIT's 6.00 are intended to introduce people with little or no experience to programming. However, the former has far more students with humanities and arts backgrounds. This requires a different approach to teaching. Neither course is 'better' than the other, and the student evaluations bear this out. The feedback I hear from contacts at edX is that both courses are being very well received.
The assumption you seem to be making is that the majority of people taking CS50 care about working in the industry, whereas they just want to find out more about programming. And that's not a bad thing.
This is because I just know, that to understand, say, SQL (and NoSQL) there is excellent Database course from Stanford and it worth taking because it will pay back later. To understand programming you need CS61A (because it teach you whys) and then Data Structures and Algorithms. Then you can pick up everything you need from books.
So, let's say that this is an Introduction To Coding (without deep understanding).
I feel like cs50x explains the "hows" and "whys" in much more detail, mainly because we're dealing with a lower level language.
For example, I know exactly what's happening on the stack now and what role the heap plays and how to balance my data between the 2 to tweak the performance and make trade offs. You don't learn this stuff on MIT's course.
Also MIT's course spent half the semester running simulations and dealing with statistics using pylab. This to me seems very specific to what you want to do. If you want to do statistical analysis that's great, but a lot of people do not.
But the other half of the course, which explains you how classes and methods were implemented (as frames of environment) is important. It comes from early (and much better, in my opinion) courses, based on Scheme.
The main point, I think, is that they teach you that there is no magic in OOP, and if people remain sane (not stuffing 70 methods to a List class) everything is simple and straightforward.
Another realization should be that OOP is not necessary, unless you're doing some very specific kind of programming - simulations. It is not just an opinion, they show you that it is nothing but a bunch of conventions. It doesn't really matter how I glue procedures and data together and how I call them - via this arrangement of pointers or that.
Much more interesting things happen when I have a general way to do it - list structure, first-class citizens and macros, so code is data, but they don't teach Lisp anymore.
They used to teach fundamental concepts and the canonical ways to implement them. Then you can add (or avoid) any complexity you wish.)
At least, after this course you probably could realize that there is much better way to do OOP than Java, and it is already a big deal.
They do a tremendous job at explaining everything and have loads of video / text with really fun and interesting problem sets.
I wish I could erase the knowledge of taking the course just so I can re-take the course again to experience its sheer amazingness.
CS51 looks great, the problem is of course they won't open it up. Harvard has every CS51 lecture, help session, etc. recorded, with all assignments online. The class even makes use of CS50's VM. Harvard Distance education students can access this full material if enrolled. It's a shame it just goes to waste after every semester.
Anyone know the CS51 professor? Maybe they can be convinced to make a CS50-style permanent online offering with a small amount of effort.
On campus, CS50 has a cult-like reputation. You'll regularly see CS50 t-shirts worn on campus; upperclassman insist that CS50 is one of those classes "you just have to take"; Malan is practically a celebrity. (I'll admit I was excited to spot him in CVS one day.)
There was a study done a while back about why programming is so hard to learn. Wish I could find it. The researchers discovered something like a third of people picked up programming with little effort, a third could grok it with hard work, and the last third never had a chance. I think CS50 is great for the first two-thirds, but completely lacking for the last third. There's just too much material in too little time.
Based on your reaction to edX, I think there's significant potential here. A one-size-fits-all class works much better online since you can move at your own pace. I'm excited to see where this goes. First place might be an option to pay for human grading. It's awfully hard to learn from automated grading.
Also, David Malan and his TFs have literally dedicated their lives to this class. I went to a talk by Tommy MacWilliam (one of the head TFs and lead developers of the CS50 edX platform), and they've been working tirelessly for months to develop the UX at scale. They scrapped the standard edX format to truly optimize the experience for this class, and I'm glad it worked.  (Some of the apps were used on-campus first and had a few years in the wild.) Most of Malan's recent research has been on large-scale pedagogy. Interesting stuff.  
PS. The appliance really is complete crap, isn't it? (For those unfamiliar, Malan puts together a VMWare Fusion image with a heavily stripped-down version of Fedora. It's got a command-line auto-submission tool and some other CS50-specific stuff as well.) Do yourself a favor and use a vanilla install of your favorite linux distro. It's a necessary effort to normalize hundreds of thousands of development environments, but god they managed to cripple Fedora.
There is actually a course for the last third, it's CS1. I used to Head TF it: like CS50 it counts for Gen Ed credit, but it is designed primarily for that last third you talk about that may find CS50 too fast paced. It uses Java rather than C. No plans to take it to edX though (with both MIT and Harvard's Intro CS classes the space is crowded enough!).
CS1 was originally designed pre-Malan when CS50 was basically only taken by those majoring in CS, and it is somewhat less popular now as many students want to take CS50 for the 'experience'. The massive success of CS50 at Harvard (now one of the top three most popular classes across the entire undergraduate catalog) is both a blessing and a curse: it's great that more students are interested in learning to program, but it's also meant the department is having to rethink what it offers post-CS50.
Sounds like it could be a shame if the CS51 material hasn't changed. As of now there's a big emphasis on functional programming and ML—was that added after CS50's shift?
 "Should I skip CS50 if I took AP Computer Science?
Probably not. You will likely find yourself at a disadvantage if you skip ahead to, e.g., CS51 or CS61, if only because many courses in computer science at Harvard assume familiarity not only with C but also with other concepts introduced in CS50. The differences between CS50 (which focuses on C) and AP Computer Science (which focuses on Java) do extend beyond the courses’ choice of languages. If you cannot complete past quizzes quickly and correctly, you should not skip CS50."
I wish CS1 would rebrand itself - maybe focus on web programming with a framework (like Hartl's Rails Tutorial) or computational thinking with Python.
As is, Java has nearly as much syntactic overhead as C (at least no pointers, thank god), which makes it hard to get into useful & exciting things.
This is not true at all. There were maybe 4–5 who skipped CS50 in just my entryway freshman year (and took more advanced CS courses), though to be sure most of those ended up concentrating in physics, math, economics, etc. rather than CS.
Admittedly this was ~8 years ago, but I’d guess the number who skip CS50 is at least several dozen each year.
I entirely agree with you though that CS50 is inappropriate to meet the needs of all or even most incoming students, and in particular throws too much unnecessary stuff at programming novices who lack sufficient other technical background (at least, it was inappropriate for the 6 or 8 students I tried to help with it over the years). But then, I think C is a terrible first programming language for nearly any student.