The post ++ is better than the pre ++. Because if it weren't Stroustrup would have called it ++C and not C++, kappa.

I don't care what methodology a software team is using. Failure to plan is still planning to fail.

Grunt developer here. I don't get the need for all this syntactic sugar they are going for in the language. It's like they secretly want C++ to work and be as easy to write as python but still have all the low level "power".

C/C++ is best when its readable, explicit, and concise. All this new syntax does is try to keep up with the cool kids.

I would rather stick my dick in a blender than ever have to write Fortran code again.

Anyone who understands memory management and pointers can write code in Cobol/fortran/C/C++/pascal etc. All the developers are interchangeable given a couple days to get use to the syntax and libraries.

36% is pretty high from my experience.

Be me, accidentally uncover the tax evasion built into the system I worked on which was put in by the previous developers.

End up in meeting with client who over a nice cup of tea tells me how strange it is that all the people around him who cause trouble end up dead., ok yeah, I get the hint.

I don't get the point of this. I use vanilla gnu make in all my projects. I have a solution make file that builds all the other makes files. I compile C/C++, Java, Python, Dot Net projects, run unittests, and build zip packages and auto deploy into my test environments all with gnu make.

And I promise you I could compile any other language that has a command line interface too... gnu make runs on every platform because its written in C.

I think this xmake thing is just a waste of time.

Hi I am going to answer some of your questions, not all because I don't have all the issues you have.

This is how I structure my multi language projects. I build my projects on Windows and on Linux.

Binaries (all my compiled output ends up here. Note for cpp I also create a msc/gnu folder to store os specific binaries)

~/bin/
~/bin/cpp   (all compiled libraries, shared objects, and executables go here, sometimes in their own sub folders)
~/bin/csharp  (all compiled dlls go here)
~/bin/py3   (all eggs ans pyd's go here)
~/bin/jar    (all jars go here)

Build

~/build/makefile    (my solution make file goes here, it builds all my languages.  You could put an ant/maven project here... but I rock it old school :P)

Source Code (all my source code goes here)

~/code/cpp/<projname>/subdirs..     (I always use the projname here so my include paths match my namespaces)
~/code/csharp/... various solutions files
~/code/java/... various java projects/packages
~/code/python3/<eggname>/  ... here I create a folder for each egg that I want to create

Externals (most projects have external dependencies, be it other repository's, external library dependencies, or resources)

~/externs/makefile      (a makefile that links or junctions to external repos or libraries )
~/externs/_template.config.mk   (a template for the config settings)
~/externs/config.mk    (config file local to this environments required external dependencies - this file is not checked into the repo)
~/externs/postgres9   --> /usr/lib/postgres9/include    (this would be a link created by my makefile to point to a dependency)

Generated Code

~/genes/...     (various code generation files go here, the either generate into my ~/code folders or locally in this folder)

Release/Packages (any final complete packages built from the the ~/bin folder most build end up here)

~/releases/<end package>.zip
~/releases/<end package>.debug.zip

Testing (finally all my unit testing ends up here)

~/testing/  ...   (I use the python unittest module to create a common start point that wraps unittests the other languages)
~/testing/cpp
~/testing/csharp
~/testing/java
~/testing/py

The build steps for my project are:

1. Check out repo
2. Configure the config.mk (copy _template.config.mk to config.mk and edit) in the externs folder (only have to do this once)
3. gmake the makefile in the externs folder (only have to do this once)
4. gmake the makefile in the build folder

Finally in regards to your question about building specific modules only.. this is what I do.

I generate a makefile for every component for each language. Then then I generate a makefile that build these sub components as groups.

Basically I have makefiles that build "projects/components" and makefiles that collectively run other makefiles that act like "solutions".

For example, if I want to compile all the java code in my project I simply go to my build folder and type:

~/build> gmake java

You could achieve the same thing with ant files or maven however (which is something I do at my job... because a lot people are afraid of make files for some reason).

Not a free text editor, but Sublime is the last editor you will ever need for any programming language... otherwise Notepad ++ is pretty damn decent free alternative.

I completely agree with this article. I go out of my way to make my code as simple as possible.

Some of my favorite quotes around complexity are:

• "There is nothing as complicated as simplicity itself."
• "Its easy to make something complex, but complex to make something simple."