I have been programming for 20 years. Many things changed since I wrote my first BASIC lines. Now we have IDEs, frameworks, debuggers, profilers, versioning tools and many other helpful toys.
So which developments in the past 10 years have made programming easier? And what was necessary to sacrifice for it?
The Internet. It allows us to find information on how to do things a lot easier. It also makes sharing libraries easier (think CPAN for perl).
The internet - makes it a lot easier to find answers to questions.
I'd add open source to the list too, as open source projects have provided lots of great tools that developers can use out of the box for free to do many complex tasks.
I'm going to go with a refinement of the software development process.
Moving from process models such as the waterfall model to newer methods like an agile/iterative approach have made software development much easier.
Probably the biggest sacrifice of these new processes is a harder to determine code complete date.
IntelliSense and autocompletion (making it easier to use more descriptive names for classes / variables ... )
Unit-tests (having some kind of permanent test-suite, making it easier to refactor code)
Static code analysis tools
As noted before; the Internet and the vast resources that can be found on it. (MSDN, blogs, articles on The Code Project, ... )
Unit test frameworks and mocking. In order to effectively benefit from it you have to sacrifice "code-like-hell programming" and invest time and effort in disciplined test writing. I could go back to using VI and separate shells to compile in instead of an IDE, but I wouldn't give up unit testing.
Source control. Sure source control existed for much longer, but the advancement of source control systems with things like SVN, Git, and others have really helped make things a lot easier. Source control was much worse when all we had was CVS and SourceSafe.
Very little has made software development easier. The technology is certainly much better, but the difficulties are still due to communication and social issues. Those haven't changed.
It's certainly a joy to not have to worry about every byte, and who doesn't love dual flat-screen color monitors?
I think the scale of the problems have expanded to the limits allowed by all those technical improvements, so the cutting edge problems still seem hard.
Version control. Without it I wouldn't be able to tele-develop, and the open source community would probably not exist.
I think a big step forward was:
OO. And, largely as a consequence, libraries. We had them before, but now they are far more powerful.
Higher-level languages like Ruby and Python.
To take advantage of them we had to give up our perfectionist control on memory, performance, etc. and accept that higher-level languages cut down on the time it takes to make the damn thing work.
For programmers targeting the Microsoft platform;
.NET has been a HUGE leap in every possible way.
Compare that with VB6 and classic ASP. It's massive!
More powerful languages like C# 3.0, Ruby, and Python with features like closures (inner functions), generators/iterators (the latter being useful to simulate coroutines), delegates (passing bound functions as parameters), Ruby's continuations, and C#'s query language (LINQ). IMO C# and the lesser-known boo are especially exciting because you can get high performance comparable to C++. There had been some languages before that had features like this, but they never enjoyed popularity. In the future, I think more features imported from functional and logic programming languages will make skilled programmers even more productive.
Garbage collection makes a huge difference.
Intellisense.
The Internet.
Programming languages such as Java and C# were designed to remove and/or limit the source of software programming faults found in other programming languages such as C and C++ (think pointers, memory management...). Ada was designed that way earlier but did not have the public success of Java and C#.
These same programming languages also helped because their specifications cover:
And they completely avoided the grey-zones found in the specification of C or C++ where quite a number of aspects of the actual language functionality or behaviors are compiler specific.
Open source libraries. Most of the code you needed to write 20 years ago is now available for free. Today people assemble applications, they don't mainly write new code.
Design patterns, kinda.
While it is foolish to ask "What design patterns can I use to solve problem X" at the beginning of the project (since that mostly leads to overly complicated and ugly solutions) they are invaluable as a short hand when discussing solutions with other developers.
Interestingly enough, I believe the very same answers provided are also true for the question "What has made programming more difficult in the last 10 years".
Are all these wonderful new 'toys' creating a layer of abstraction that spoils us into not really understanding the fundamentals of the underlying technologies, thus causing longer troubleshooting cycles? Especially for the new/younger breed of programmers?
See "Leaky abstractions" (http://www.joelonsoftware.com/articles/LeakyAbstractions.html)
Do you think programming is easier ? I still seem to spend 8-16 hours a day trying to make stuff work...
BLOGS
by great programmers like Guido von Rossum , Bruce Eckel, Jon Skeet ...
Sometimes I think that the Internet/Google has made programming harder rather than easier.
10-20 years ago pretty much every programming language or tool you bought would come with a nice ring-bound manual covering almost everything you need to know about it.
Whilst good hypertext documentation is obviously preferable to a big pile of paper, a lot of projects these days - both open source and commercial - seem to think they can ship with next to no documentation and solve this by giving you a couple of samples to download and installing phpBB and calling it a "Support Forum".
I do long for the days of exhaustive reference manuals rather than some default Javadoc that adds no value at all. (setAutoWidth(boolean autoWidth) turns AutoWidth on and off? Really? I'd never have guessed, but where do I find out what the AutoWidth feature actually freaking does?)
Multi-monitor graphics cards.
Okay, that's whining on a high level but having the web browser open next to my IDE really helps.
Web applications becoming prevalent have made things easier.
Don't have to deal with reproducing issues on individual client machines much. Many of the issues occur on the server and can be fixed and the app can be deployed again very easily.
They do have their problems, such as browser incompatibilities and the challenge of how to perform privileged actions on client machines.
IMO the pros outweigh the cons though.
I'm not a web developer (yet), but for the desktop, tools have gotten a lot prettier and chrome-plated, but I think the most basic advances happened earlier:
Unix: C, diff, scs, ...
C++ and its ilk
At the same time, everything that has supposedly made programmers more productive has (for most of us) allowed us to do the same functionality with lots more code.
Openness.
Today's it's expected of any decent language/stdlib that you'll have all the documentation available for free and searchable on the internet, backed up with public discussion forums.
Programming ‘in the dark’ because the docs were great big dusty books that cost a fortune and/or were only available to partners was a disaster.
Hmm, a little brainstorming. OO with Smalltalk and its IDE, oh, much older. Functional programming with Lisp and Emacs, hmm, by far older. Concurrent programming with Erlang/OTP, hmm, more than 20 years old. And logical programming with Prolog? Don't talk about it. So perhaps ODBMS or RDBMS, no, both older. And dirstibuted computing, hmm, no, RPC and CORBA have been around for a long time, even multi-platform. A good operating system? Unix is already very old. The internet? That too. at least open source software? No, that's also more than 10 years old.
Damned, I've got to admit that there's nothing real new for the last 10 years. So let's do our best to change this. +smile+
mue
CPU speed of course!!!
10 years ago, there were still 286 machines, and the simplest program could take minutes to compile.
None of the others mentioned factors would have succeed if we still had slow machines.
I remember the first time I opened ProjectBuilder or Netbeans. It took forever and eventually I had to restart the machine.
Built-in libraries and frameworks.
Need to interact with the file system? Need to make a web application? Need to talk to a database? Need to use regular expressions? Need to send email? Need to use a hash algorithm like MD5? Etc. All of these things used to be hurdles that would require either tracking down the right 3rd party library then figuring out how to license and use it or spending significant developer effort to create the functionality from scratch. Today all of these things come for free with the most popular languages (C#, Java, Perl, PHP, etc.) as built-in libraries or frameworks.
The internet and the wide-range, immediate availability of information and example code from various support communities.
More and better applications that needed to be created. Our society changed with the PC, as PCs became more integrated into everything, the need for programs. The need for programs meant competition. Programmers honed their skills, made better tools, and by repetition and the need to move forward - programming became easier. Though, I do believe "easier" is in the eye of the beholder. Perhaps in the future those things today will be "easier" when new skills, tools, and competition begin anew.
Abstraction. The more and more code others write for us, the less we have to do to get things working.
Looking over the previous answers, the only concept we didn't have ten years ago is:
Distributed version control systems (I didn't find a reference to them before this millenium).
Everything else has been implementations, earlier ideas becoming more popular, things becoming less expensive, and information becoming more available.
Either the pace of innovation in software development has gone down, or the length of time it gets a new idea to be implemented and into general use is normally greater than ten years.
Automated Refactoring Tools
The most important ones are Rename and Extract Method, but Extract Class, Move Method, Introduce Explaining Variable, and their inverses are pretty important, too.
Tools that get these right 90% of the time is great for labor saving, but then you must have good unit tests, the kind that only come from Test-Driven Development, so that means they're really for a restricted audience.
Tools that get them right 99.9% of the time are useful for everyone, regardless of development practice.
That's why the refactoring list in Visual C# is so small: we wanted to go for the "always right" algorithm, even though it took a lot more time on the schedule; time that could have been used to add more refactorings. (It's also why Rename is so slow.)
The result is that people buy Resharper to get a full catalog of refactorings (which are important), but I worry that they aren't aware of the differences between the builtin and addin refactorings.
Too bad we couldn't build a fuller catalog of refactorings, or made Visual Studio extensible enough that you could build your own high-reliability refactorings. Maybe in VS 10. I'm hoping.
Vim highlights the opening bracket when you type the closing one.
No single answer - many factors.
This implies that virtually anyone who answered this question is wrong.
Short and simple answers (in no particular order):
I've also been in the industry for over twenty years and have use a variety of programming languages. How about PICK? Anyone heard of that one? The years of old (1980's) we had to build our own code snippets, libraries and read these thick and not well written books on programming.
The Internet has empowered the developer. With it, vast resources can be searched in less time than it take to breath! Good solid answers by technical peers are there!
But again, without the Internet I could still do my designing, developing, documenting.
Yes the Internet has made it easier but what I find that has really made a difference is the advances of the IDE. Whether it's .NET, Java or whatever language . Using an effective IDE that supports intelisence and gives you a clean graphical, powerful and intuitive environment to build the applications in, is probably the most important to me.
I'm more productive than ever before, even though the languages keep evolving and I'm bombarded by new frameworks, design patterns, and technologies. I'm still productive because of my IDE.
As you know, languages have really evolved as well. Now there are discussions about all the new features available to the .NET developer. So many enhancements in such a short time but we still want all the power and ease of building these highly graphical interfaces, so we accept the changes - bitch a little - and then use them.
So to sum up before I write a book here, my order of what has made programming easier are:
BTW... Good Question.
Refactoring tools, to automatically (and without the risk of silly mistakes) perform common changes on code: extract method, inline method, extract class etc.
What was sacrificed: Easier programming is accomplished at the cost of higher levels of abstraction - can't bang directly on the silicon like you used to. Means programs run slower and require more memory - but as long as computer speeds double faster than programmers' productivity and memory costs keep dropping, not such a terrible price to pay...
I think that things such C++ std library or even boost or Java with its sets of libraries allowed some significant improvements in life of average programmer.
Another useful thing is of course knowledge exchange networks such as codeproject, codeguru or this site.
I don't think that things such as interactive debugging are truly ground breaking - they are more about convenience. However, ability to consult one's fellow programmers outside of one's direct organization is pretty remarkable thing.
I believe that the increase of the abstraction has made things really easy. Just compare writing a program in C++ with writing a program in C#...
Many of these things have been around in one form or another for a while. For me, if it was just the last couple of years, I would say advances in OS virtualization. I have 7 different VMs on one machine and can take a snapshot of any of them multiple times. If gives me great flexibility on developing against different platforms without having a pile of old boxes under my desk.
I do not believe that anything had to be sacrificed for this, except a bunch of disk space and some RAM, which is much cheaper than several years ago. And you can take more advantage of that multi-core CPU.
Seriously, you need to look at this if you use MSDN! Props to Frank Krueger for pointing this out
Free learning on internet. Most of the people are learning online now, 10 years ago you had to go to some paid courses to get an introduction. You can do the same today in youtube.
The only sacrifice that we made is the time spent learning that people should share stuff on internet and that profit shouldn't be always the engine for everything.
Something I wish was more prevalent in debugging is execution recorders, where some parent process traces the entirety of your program forward and backward, recording variable values, stack locations, etc, so you can rewind your application to find out where something got changed. It'd be perfect for throwing to customers for those hard-to-repro issues.
It'd be a PITA trying to get a sanitized version out of somewhere like Raytheon, but I'd kill to have one. Debugging would get so much easier if you could visualize the lifespan of a memory location over time and not just a snapshot in time.
Frameworks and IOC
When's the last time you sat down and typed out some form of (static) void main()? If you were writing the entry point for the app that you're developing now, what would you put in it?
valgrind ... at least, it sure makes debugging those mysterious crashes easier.
I am surprised that nobody said "open source licensing". It completely changed the life of programmers in the last 10-15 years (when Linux and the open source community began to grow). The availability of open source tools, code, information sharing, allowed large communities to grow and provide google, documentation, ideas, programs, snippets of code.
It gave microsoft competition, it gave OSX its environment, it created the web and the CC licensing that shapes a large part of the web today.
Nothing! Programming is still really hard, even if you are highly skilled. I cannot think of anything that has arrived in the last 2 years that actually makes the hard part - designing and writing effective reusable and functional code.
Most of what's already been mentioned here has been around in some form or another for a lot longer than that.
Decompilers to see how other applications work. And damn those obfuscators!
The following made programming easiest in the last couple of years.