There is a vestigial article on embedded software on Wikipedia: http://en.wikipedia.org/wiki/Embedded_software.
A key aspect is that embedded systems and software are "reactive" in that they receive information (data, signals, etc.) from devices external to the computer system, process it, and usually (but not necessarily) send data out to devices external to the computing system. A real-time embedded system (not all are) has time constraints for completing all three of those steps.
A case can be made that programming an embedded (often real-time) system is harder than programming a non-embedded -- called a "transformational" (for obvious reasons) system. The increased difficulty is due to the programmer typically having to deal with the exogenous devices at a very low level, requiring detailed understanding of the devices' hardware. Embedded software programmers usually have some degree of electrical and/or mechanical and/or .... knowledge (but currently based on experience more than formal education). Real-time embedded software and systems must consider meeting completion time constraints for these reactive interactions a correctness (perhaps even a human safety) criterion, not a performance criterion -- adding exponentially greater difficulty as the size and functional and non-functional (e.g., fault management) and complexity increases. Embedded programming deals with more than software abstractions.
A counter-argument can be made that programming an embedded system is at least often easier than programming a non-embedded one. That argument is based on several considerations. Embedded software is usually smaller size (e.g., lines of code) than most non-embedded software -- but in number of application domains (such as certain parts of telecommunications and military systems) the embedded software is 10's of millions of source lines of code. Another consideration is that the embedded system application software development systems and operating systems are almost always simpler than those of non-embedded systems. Whether that indeed makes embedded programming easier-- more difficult -- is specific to the systems, and also a matter of opinion.
So can just anyone be a programmer? Here I ask "Can just anyone be an embedded systems programmer -- good enough to be successful?" I assert that fewer people can be successful embedded -- especially real-time -- programmers.
I provide one piece of anecdotal support for my assertion.
In one of my former lives, I was on the faculty of both the Computer Science Department, and the Electrical and Computer Engineering Department, of Carnegie Mellon University. I created and led one of the largest research projects -- it was for embedded real-time systems -- moreover, distributed ones, thus adding a whole new dimension of complexity. We implemented our distributed real-time OS kernel directly on the bare hardware of multiprocessor nodes which we created by modifying Sun boards (a donation from Bill Joy), and then interconnected those with an Ethernet. (Yes, you can create a real-time Ethernet, or even a real-time system using standard Ethernet--a non-trivial topic out of scope here.) At that time, the standard practice for academic OS research was to implement on top of a *NIX. I was the thesis advisor to five CS Ph.D. students and five ECE Ph.D. students, all of whom did their thesis work in the context of my research project. In addition, I taught cross-listed courses attended by both CS Ph.D. students (a Ph.D. was the only CS degree CMU offered at that time) and ECE M.S. and Ph.D. students.
My experience, which was the consensus of a small group of other faculty I consorted with, was the anecdotal support I referred to: we agreed that in general our experience (note the two qualifiers) was that it was easier to educate an ECE student to be a good embedded programmer, than it was to educate a CS student (having a non-engineering -- usually math, physics, or CS bachelors or masters degree) to be a good embedded programmer. To grossly over-simplify it: the software-minded students were trained to think in terms of system and software abstractions, and lacked the fundamental mindset of an engineer that even a few EE courses (e.g., control theory) would have imbued; and most lacked even rudimentary knowledge of and experience with device hardware. The ECE students also thought in terms of abstractions -- system and hardware, and software to a lesser depth than (most of) the CS students; and their perspective was that of an engineer. They needed additional education in relevant CS principles (e.g., theory of algorithms, formal methods, software engineering).