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.

165 accepted

Any IDE with auto-completion :-)


Garbage collection.


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.






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.


High-Level programming languages

  • LINQ ~ 2007
  • F# ~ 2005
  • C# ~ 2001
  • Python 2.0 ~ 2000 (I say 2.0 because the language began to gain ground here)
  • CSS ~ 1996
  • Ruby ~ 1995

  • 33

    Color screens :)


    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!


    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.


    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.


    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.

    • Stepping/Breaking into code
    • IntelliSense
    • Improved GUI Interface
    • .NET Framework
    • Internet (HTML/ASP.NET/PHP etc)

    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.


    I think a big step forward was:

    • syntax highlighting
    • code completion
    • educational tools like ReSharper
    • Internet
      • online examples
      • online documentations
      • newsgroups
      • download of libraries
      • etc.
    • powerful IDEs
    • powerful debuggers
    • frameworks and access to them (see Internet)
    • 10 more years of experience in software-development


    by great programmers like Guido von Rossum , Bruce Eckel, Jon Skeet ...

    1. OOP
    2. .NET framework
    3. IntelliSense



    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.


    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?)


    Eclipse IDE.

    Had to sacrifice: Vim keyboard commands.


    Debugging environments that support edit & continue.


    Programming is easier??? Damn I knew I should stop using C++.


    Red Bull - it gives you wings.


    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.


    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

    ORM tools and DI containers

    As noted before; the Internet and the vast resources that can be found on it. (MSDN, blogs, articles on The Code Project, ... )


    Greater acceptance/use of continuous integration.




    Loband MSDN!

    Seriously, you need to look at this if you use MSDN! Props to Frank Krueger for pointing this out


    Do you think programming is easier ? I still seem to spend 8-16 hours a day trying to make stuff work...


    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.


    Moore's Law


    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:

    • Compile time behavior
    • Run-time behavior
    • Debug and run-time inspection of data-structures
    • Extensive standard libraries

    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.


    Edit And Continue.


    Google (well, the internet in general, but mostly Google)


    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.


    The Internet.


    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)


    Short and simple answers (in no particular order):

    1. Model-View-thinking
    2. Agile methods
    3. Better hardware
    4. Internet
    5. Other

    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.



    It singlehandledly (IMHO) made Javascript usable.


    OO. And, largely as a consequence, libraries. We had them before, but now they are far more powerful.


    Vim highlights the opening bracket when you type the closing one.


    Refactoring tools, to automatically (and without the risk of silly mistakes) perform common changes on code: extract method, inline method, extract class etc.


    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.


    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.


    Version control. Without it I wouldn't be able to tele-develop, and the open source community would probably not exist.


    punch cards! :)

    oh, wait. maybe not.


    Hardware getting really fast and cheap.


    Multi-monitor graphics cards.

    Okay, that's whining on a high level but having the web browser open next to my IDE really helps.


    IDE's and frameworks which highly reduced the time of development - called RAD.


    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.



    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.


    The internet and the wide-range, immediate availability of information and example code from various support communities.


    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.


    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:

    1. A graphical IDE
    2. The language (C#/VB.NET/Java) evolving
    3. New frameworks and technologies (WSE, ...)
    4. The Internet - because we need an open unbiased, unfiltered source of information

    BTW... Good Question.


    IMO Generics


    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.


    Monad transformers, of course.




    Source Control


    Experience and knowledge gained over these years.


    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 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).


    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.


    Add-ons like Visual Assist and SharpDevelop.


    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.


    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+



    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.


    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#...


  • Richer set of available programming languages to choose for solving your problem. From high level, object oriented, to dynamic, to functional, to low level languages.
  • Better tools for writing codes.
  • Tools to help write quality code. Think TDD and available unit testing frameworks.
  • Better ways of sharing and finding information. Books, magazines, the internet, the search engines, blogs, forum, QnA websites (StackOverflow.com :)), etc.

  • 0

    Abstractness in the programming, High Level Programming Lanugages, IDE( auto complete, refactoring, code-to-build, Beaten problems Best Practices, on-demand coding, internet code browsing repositotires


    ReSharper. Had to sacrifice about $100 to gain a ton of productivity.


    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 find having a larger screen helps me visualise more code at once.


    syntax highlighting


    The following made programming easiest in the last couple of years.

    1. IDEs.
    2. Design Patterns
    3. Software Development Life cycle (SDLC)
    4. Version Control System.
    5. Web Tutorials and Forums.
    6. GUI and Frameworks.

    The increasing use of computers in midle bussness and home stuff. more investemts do more easy tecnology


    No single answer - many factors.

    This implies that virtually anyone who answered this question is wrong.




    Jon Skeet ;)