You may or may not like Java, but the JVM is an awesome platform.

IMHO the best strategy right now for people with Java legacy code is to adopt one of the new JVM languages: Scala, Clojure, JRuby, Groovy being the most prominent choices. You can use a great modern language, but keep all the advantages of the JVM (excellent garbage collection, excellent JIT compiler, huge open source library ecosystem, portability etc.)

C/C++ is cool for systems programming or for stuff where you have genuine realtime requirements: but it's a backward step for general purpose application development (i.e. 95%+ of development work). Proper garbage collection, managed runtime safety, JIT compilation, strong concurrency support, portability of compiled bytecode etc. are far more valuable in modern application development than the ability to write optimised low level native code.

Mono was also a *massive* strategic blunder: it would have been far more sensible if Miguel had built an open source clone of the JVM instead for his Linux GUI efforts:

• The JVM/Java ecosystem is exactly what Linux needed to have a chance on the desktop. It's a huge ecosystem of ready made libraries and tools, most of which are open source. Why reinvent the wheel?
• The JVM was and still is the best way to ensure *binaries* work across platforms. And incompatible binaries is what makes Linux a nightmare on the desktop, since most regular users lack the interest or ability to compile/configure their own binaries. .Net, by contrast, is full of Microsoft lock-in features.
• It would have required much less convincing to persuade people to adopt it. Java was already a massive ecosystem and a safe bet.
• It would have given Linux a real chance on the enterprise desktop, since enterprises like the idea of Java and have lots of Java developers to write apps
• It would have avoided all the arguments / fighting / FUD about "getting into bed with Microsoft" in the open source community
• It would have avoided giving Microsoft a huge PR win.
• It might have persuaded Sun to open source Java earlier, which would have been a massive win (the cloning effort would have served its purpose if this happened, future work could be merged into the OpenJDK)

My observation at the time was that Miguel seemed to be over-excited by the (nice but superficial) language features he saw in C#, and completely forgot that the real value is in the *platform*.

Vendors *do* regard their locked-in customers as property. Very valuable property in fact.

You can observe the value reflected in the share price whenever enterprise software companies or products get bought and sold for their "installed base".

Clojure performance isn't bad at all - in fact it's one of the fastest dynamic languages around.

Examples from alioth benchmarks (x64 Ubuntu : Intel® Q6600® quad-core, 8th May 2012, median performance relative to fastest benchmark program, 1.0=fastest):

1.00 Fortran Intel
1.21 C GNU gcc
1.89 Java -7 server
2.73 Scala
2.80 Haskell GHC
2.85 Go
4.10 Clojure
6.86 Racket (Scheme)
10.71 Erlang HiPE
53.06 Python 3
57.62 Ruby 1.9
103.29 Perl

As you can see, Clojure is pretty well positioned in the overall performance charts. It's pretty close to Haskell, Go and Scala, and way ahead of most of the other popular dynamic langauges.

On the practicality point, it's also worth noting that since both Scala and Clojure can use Java libraries directly, they have much better library availability than Erlang, Go or Haskell.

Clojure has the following features, which together make it pretty cutting edge:

- Native access to all the Java library ecosystem - so you start with a huge available set of libraries, more so than most other langauges. This makes Clojure very practical for actually getting stuff done......
- Probably the most novel implementation of Software Transactional Memory in any language - see http://www.infoq.com/presentations/Value-Identity-State-Rich-Hickey
- All the benefits of running on the JVM (cutting edge garbage collection and JIT compilation in particular)
- It's a homoiconic langauge - "code is data". This makes it extremely powerful for metaprogramming, DSLs and code generation. see also: http://www.paulgraham.com/avg.html
- It's one of the fastest dynamic langauges around (about 10-20x faster than Ruby, Python, PHP, Perl, within a 2-5x factor of the fastest compiled languages according to Alioth benchmarks)
- It has an interactive REPL-based development environment, great for live coding and prototyping - see e.g. http://vimeo.com/22798433
- It is much more of a functional programming language than most Lisps (you can see quite a lot of inspiration from Haskell)
- It has modernised the traditional Lisp syntax - for example {} is used for maps, [] for vectors as well as the traditional () for lists

Clojure is certainly one of the most interesting languages around at the moment - I'd strongly recommend it to anyone looking to broaden their horizons!

The future of Lisp is with languages like Clojure that avoid the monolithic approach and happily embrace and extend the Java ecosystem.

This is why Clojure (and and other Lisp that takes a similar approach) will have a huge advantage - you get the power of Lisp *and* a great library ecosystem.

Visual Studio with C# isn't very useful great for cross-platform development (which was one of the requirements of the OP)

Also I personally find that "visual" editors, while good for producing something quickly, aren't much use for more advanced GUI development where you need to do much more meta-programming, develop custom components and have detailed control over layouts and behaviour etc.

Even when I was using Visual Studio a lot (which I'm glad to have left behind), I tended to code all the GUI stuff by hand.

1. Processing (http://http://processing.org/) is great for visualizations, worth a look. It's used a lot for interactive visualisation tools

2. Clojure is a great option for general purpose prototyping. It has the advantage of being able to use all the Java libraries and tools, but on top of that is an excellent modern dynamic programming language with great code-generation capabilities. It's great for creating DSLs, for example there is a Clojure GUI library called seesaw that defines UIs like this:

(frame :title "Hello", :content "Hello, Seesaw", :on-close :exit)

Any form of licensing for standards is incompatible with open source software. When you distribute open source you need to distribute it will all the rights otherwise the burden on the recipient (often an individual rather than a company) to acquire such licenses is excessive and unreasonable. How many people would use Open Office for example if they had to separately go and buy a set of complex FRAND licenses with every download?

Making distributors of open source responsible for acquiring the licenses won't work either, because they can't control downstream copies (the very nature of open source) and you place a major hurdle in the way of individuals or small companies becoming distributors themselves (which is the spirit of open source).

Basically, FRAND is a nightmare for open source. Of course traditional software companies love it because it means that they get to benefit from reduced competition, but you can kiss goodbye to most of your innovation and the end result will be customers paying more for worse software.

In my view the only acceptable open standard is one that is unencumbered by *any* licensing requirements. Standards organisations either need to get with the 21st century on this one or be (rightfully) ignored.

... to the same extent as saying that White people only get the Vote.

Well 10 questions is clearly a lower bound since 9 or less yes/no properties would only be able to distinguish up to 512 combinations which would not be enough for the 10-999 range.

So one easy (and minimal) answer would be 10 questions that just ask whether each of the first 10 binary bits are set..... this would cover 0-1023

More interesting would be whether you could do it with "mathematically interesting" questions such as "is it prime", "is it a square" number etc. Probably depends on what you define as mathematically interesting - I think you would have to invent some increasingly bizarre properties to distinguish between different large primes for example.

I think you could do this algorithmically:
- Create a long list of mathematically interesting properties and tests for each
- Apply the test to each number in the range 10-999 to create a "fingerprint" for each property
- Keep adding properties until you have a set that can discriminate between all the numbers 10-999 in some way (i.e. for any two given numbers, the tests for at least one property are different)
- Then it's just(!?) a case of pruning down the properties to the ones that you really need.

One approach for the last step might be to iteratively select properties with the highest discriminatory power (i.e. those that minimise the maximum size of a set of numbers that are categorised the same) until you have chosen a set that discriminates completely between all the numbers 10-999.

Probably not optimal though - anyone have an algorithm that guarantees to find the optimal answer (i.e. minimum number of properties) within a reasonable timescale?