writing computer programs in plain text files is ridiculously old fashioned.
are documents created in plain text? no. there are WYSIWYG
editors and rich document formats. are images created in plain text?
no. there are great painting tools where you can visualize and manipulate
them in 2D. are three dimensional models created in plain text? again, no.
there are tools that visualize and manipulate them in the 3D domain. so are computer
programs the 1D stream of characters which plain text files efficiently
represent? NO! so why are they created and represented in such a restrictive,
incapable format? hardware has advanced so much faster than software
because of this insistence of expressing software in plain text.

better tools are needed to create and manipulate the abstractions of computer
programs, but these tools are very difficult to create when they must
operate on plain old text files. the source for programs needs to be authored,
viewed, stored, and manipulated by tools in a much more advanced representation.

a simple example is renaming a variable. what you want to do is... rename a
variable. but what you have to do currently is find and replace all sequences
of some set of characters with some new set of characters but only certain
instances of that set of characters that correspond to some abstract concept
that is represented implicitly somewhere or throughout the full set of characters.
wtf. no wonder programming tools are taking so long to advance!

programmers are too complacent. they naively going about editing text files, finding
and replacing strings of characters, copying and pasting plain text, typing the
same things over and over, and typing the same things in multiple places. they do all
these activities that bear little to no resemblance to the actual actions they
are performing on abstractions that all that text feebly attempts to represent.

here are some random things i want for c++ and devstudio:

• regular expressions built into the c++ syntax. not some library implementation
  of regular expressions like boost or the regex in c#, but easy syntax like in
  perl or ruby.
• source code styles sheets. instead of putting a line of //===... above every
  function, just add that as a rule to your style sheet and all code you view gets
  that automatically. if you like class members prefixed with m_ or _ or suffixed with _
  or whatever just set that as a style sheet rule. like wise with k/r braces vs ms braces.
• compile to xml. the compiler should be able to dump the syntax tree out to a simple xml file.
  this way you can write all sorts of great code manipulation tools without having to write a
  whole parser for c++. you could just use ruby or xslt or whatever you like to manipulate the xml.
• eliminate the need for forward declarations from c++. it's the year 2005, why do functions
  still have to be forward declared? we have the technology!
• the stl implementation with devstudio needs an option for range checking on vectors.
  and it shouldn't throw an exception, it should assert.
• the crt needs a real assert. one with a cool ui and options to generate a crash
  report and email it to the developer.
• compiler error messages are still really stupid. if you miss a semicolon it doesn't
  say "hey dude, you forgot a semicolon." instead you mostly get something totally random.
  it only takes a second to notice the missing semicolon, but come on... it's 2005.
• region support like c#. not only the #region #endregion but also the ability to collapse
  all functions to their prototypes and collapse class declarations and implementations.
• compiler intrinsics for vectors and matrices. it should be able to map operations
  with them to simd instructions.