There are different terms that describe the job of someone who creates software, and some such terms carry a type of stigma along with them. Here's my attempt to rant about what I think the difference is between two very popular terms: Software Engineer and Programmer.
A software engineer generally attempts to apply patterns, staying within rules, using discipline, and following formal processes and best practices to create "software". On the other hand a programmer arrogantly (and I use that term in a positive way) thinks that all that is kind of useless.
I guess a simple way to put it, a software engineer is a programmer while a programmer is not necessarily an engineer. What??? Well, engineers focus their efforts on building software components that interoperate together to solve the overarching problem they were asked to solve. Programmers solve problems too, but at the lower level. They must think up an algorithm and make it come to life in code, but do they care about how this algorithm fits into the bigger system? Of course they do; because you may write an inefficient algorithm that works just fine if it's executed on a small dataset while will fail on a system that deals with large amounts of data. That's where the problem definition comes into play. The problem defines the scope, it presents the ecosystem of the algorithm and the solution to be a good solution must account for all the requirements.
When a programmer thinks of solutions they take requirements and create beautiful efficient code that solves this problem basically to spec. A software engineer (a good one) will take a step back and ask the question of why am I solving this problem, how will it evolve in the future, where else can I apply the solution, how I can reuse. Then the put their programmer hat on and switch into the new role.
Maybe another way to put it is: a software engineer is a (potentially) licensed, professional engineer who is schooled and skilled in the application of engineering discipline to the creation of software. While a programmer creates the code that make a program run, a software engineer creates the designs the programmer implements. By U.S. law no person may use the title "engineer" unless the person holds a professional engineering license from a state licensing board and are in good standing. This definition does not yet apply to software engineers, however. Though, software engineers are held accountable to a specific code of ethics. In all other forms of engineers most states require an exam to be taken which officially licenses one as a Professional Engineer (PE). While these exams too exist in many states for software engineers, they aren't take seriously .. yet.
The two terms really identify two phases of software development, one doesn't exist without the other, which is why often the two terms and responsibilities overlap in the real world. It's not common to be just a programmer and it's often impossible to be a software engineer without being a programmer.
In recent years the term Architect has been popping up all over the industry. Even today it's still very vague in terms of what an architect is and how one is different from a software engineer. One way to put it, an architect is a software engineer who is NOT a programmer. They aren't doing the coding, they only build the abstract notion of the system and hand it over to the engineers to realize it into existence. In a way, this sort of frees the architect from consuming their time with details, and allows the delegation of such insights to the much lower level.
What about the stigma?
That's where the problem comes in; many people imagine that someone who's title is Software Engineer is somewhat more prestigious than a dummy programmer. That couldn't be further from the truth; it's the separation of concerns in software development. One does not exist without the other. You could reason about this from a different perspective. There are armies of programmers that can be hired (outsourced) to do the job of wiring code, who wouldn't be trusted in build the entire system, not for any reason other than the fact that they lack the skills necessary to complete such projects.
In my opinion, these terms define a career progression of someone in the software industry. Someone who graduates college, regardless of talent, they are they start off in the professional world as a programmer. As they gain real world experience they evolve into a Software Engineer. It takes years to perfect the craft but the final transformation is an Architect.
I understand this is subjective and maybe total non-sense, but I'll stick to this definition for now.