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 is the best managed code environment outside of the JVM, and arguably better in many respects. Are you saying that Linux should not support any form of VM? Maybe you'll write us an alternative. Yeah, right.
Technically, Mono is great. Unfortunately, Miguel completely failed to establish it as a Linux standard by antagonizing much of the Linux community and failing to assuage licensing and patent concerns. Frankly, as an early Mono adopter and supporter, I feel let down by him. Let him be happy with his Mac; I won't miss him.
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:
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.
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?
In modern processors, lookups from memory are far too slow. This is especially true if you are doing lots of random lookups that might go outside the cache.
Performance-wise, you are much better doing several calculations than a single lookup.
The BBC is *very* independent in the UK. The government basically has no practical influence over what it presents. Plus, there would be enormous political backlash if the government did try to interfere - us Brits are very sensitive about that kind of thing.
In fact, I'd go as far to say that the BBC is more objective and impartial than any of the commercial media sources in the UK.
I can also pretty much guarantee that open source software start-ups will keep appearing for as long as the likes of Oracle keep buying them out with large wads of cash.....
If you check your basic economics textbooks, you will find that capitalism (or to be more precise, a free market system) is unlikely to allocate resources efficiently if any of the following is true: a) Markets are not competitive (e.g. OPEC, various pipeline arrangements) b) There are negative externalities (e.g. environmental pollution, global warming) c) There is a lack of clearly defined and enforced property rights (e.g. Russia, Iraq?)
Oil is a source of many instructive examples of how free markets *do not* allocate resources efficiently (or equitably - but that's a separate issue).
Surely someone can figure out a way to ensure that the funds get distributed in a way that encourages people to do something genuinely useful?
Here's a starter for ten - how about distributing the money on the basis of project popularity? It's generally pretty easy to keep track of number of downloads, number of registered users etc. Allow anyone who wants to develop a piece of open source software to apply for the grant, then pay out on the basis of observed success in the "marketplace".
As long as the formula for funding is predicatable, you would even expect VC firms to fund promising open source projects in the hope that the project is a success and they get a big reward in terms of government bounty. The guys who invest in the next Firefox would walk away with a tidy profit.... and since they would only get the money *after* their product had been proved useful you would ensure that government money is never wasted on something that nobody actually uses.
Almost certainly a long term P/E would be more than one. Think about it, would you sell a company for £100 that was steadily earning £100 *per year*?!?
In general, the price will reflect the net present value of expected future cash flows. Depending on tax rates, investor preferences and interest rates etc. this will probably put the PE ration in the 10-20 range for a company in "steady state". Which is about what you would expect see in today's markets for safe, stable companies with no particular growth prospects.
Spot on. I'm an economist by training, and it annoys me intensely whenever people make the argument that so-and-so isn't a monopoly because they don't have a 100% market share.
Part of this is due to the fact that market share is completely dependant on how you define the market (is it "Pentium 4s", "Intel compatible CPUs", "CPUs", "Electronic Components" or "Things you can buy"?)
The other part is that the market share is irrelevant to whether you have "monopoly power", which is what really matters in economic terms. Roughly that equates to the ability to raise prices without losing customers to competitors, which clearly applies to Intel as they have been able to charge a price premium over equally powerful AMD chips for quite a long time.
Personally, I think that Linux could very easily "kill" Windows in the sense that windows becomes a marginal product with little relevence other than historical curiosity (Think OS/2, for example).
If Linux acheives critical mass (i.e. significant size that *consumer* applicatrions are commonly produced for Linux as well as Windows) and Microsoft hasn't found another way by then to hold on to its monopoly power (e.g. by locking out competitors via patents or evolving the OS into a DRM protected managed service) then I predict that Windows will die pretty quickly.
It boils down to the simple economic fact that Open Source is self-sustaining even if it is available for free (as in beer), proprietary software is not. Given a level playing field, free software is always going to win.
And more importantly than that, you wouldn't be using a lame old general purpose processor. You'd have rolled your own vector processing chip with a custom instruction set specifically optimised for web browsing.
Slashdot Mirror
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.
Technically, Mono is great. Unfortunately, Miguel completely failed to establish it as a Linux standard by antagonizing much of the Linux community and failing to assuage licensing and patent concerns. Frankly, as an early Mono adopter and supporter, I feel let down by him. Let him be happy with his Mac; I won't miss him.
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:
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?
This is exactly the reason that I think the peer-to-patent project does more harm than good.
It is effectively strengthening and legitimising the (extremely bad) current legislation.
A far better use of the volunteer effort would be in political campaigning to scrap the whole concept of patents for software.
A properly functioning capitalist society would have a free market where independents aren't locked out of the key distribution channels.....
In modern processors, lookups from memory are far too slow. This is especially true if you are doing lots of random lookups that might go outside the cache.
Performance-wise, you are much better doing several calculations than a single lookup.
The BBC is *very* independent in the UK. The government basically has no practical influence over what it presents. Plus, there would be enormous political backlash if the government did try to interfere - us Brits are very sensitive about that kind of thing.
In fact, I'd go as far to say that the BBC is more objective and impartial than any of the commercial media sources in the UK.
Good idea, though it would probably be much more lucrative just to auction the domain names.
Auctions can be pretty efficient to run and tend to be revenue-maximising for items where a large number of bidders have different valuations.
I can also pretty much guarantee that open source software start-ups will keep appearing for as long as the likes of Oracle keep buying them out with large wads of cash.....
If you check your basic economics textbooks, you will find that capitalism (or to be more precise, a free market system) is unlikely to allocate resources efficiently if any of the following is true:
a) Markets are not competitive (e.g. OPEC, various pipeline arrangements)
b) There are negative externalities (e.g. environmental pollution, global warming)
c) There is a lack of clearly defined and enforced property rights (e.g. Russia, Iraq?)
Oil is a source of many instructive examples of how free markets *do not* allocate resources efficiently (or equitably - but that's a separate issue).
Surely someone can figure out a way to ensure that the funds get distributed in a way that encourages people to do something genuinely useful?
Here's a starter for ten - how about distributing the money on the basis of project popularity? It's generally pretty easy to keep track of number of downloads, number of registered users etc. Allow anyone who wants to develop a piece of open source software to apply for the grant, then pay out on the basis of observed success in the "marketplace".
As long as the formula for funding is predicatable, you would even expect VC firms to fund promising open source projects in the hope that the project is a success and they get a big reward in terms of government bounty. The guys who invest in the next Firefox would walk away with a tidy profit.... and since they would only get the money *after* their product had been proved useful you would ensure that government money is never wasted on something that nobody actually uses.
Why on earth would a long term P/E be 1.0?
Almost certainly a long term P/E would be more than one. Think about it, would you sell a company for £100 that was steadily earning £100 *per year*?!?
In general, the price will reflect the net present value of expected future cash flows. Depending on tax rates, investor preferences and interest rates etc. this will probably put the PE ration in the 10-20 range for a company in "steady state". Which is about what you would expect see in today's markets for safe, stable companies with no particular growth prospects.
Spot on. I'm an economist by training, and it annoys me intensely whenever people make the argument that so-and-so isn't a monopoly because they don't have a 100% market share.
Part of this is due to the fact that market share is completely dependant on how you define the market (is it "Pentium 4s", "Intel compatible CPUs", "CPUs", "Electronic Components" or "Things you can buy"?)
The other part is that the market share is irrelevant to whether you have "monopoly power", which is what really matters in economic terms. Roughly that equates to the ability to raise prices without losing customers to competitors, which clearly applies to Intel as they have been able to charge a price premium over equally powerful AMD chips for quite a long time.
Personally, I think that Linux could very easily "kill" Windows in the sense that windows becomes a marginal product with little relevence other than historical curiosity (Think OS/2, for example).
If Linux acheives critical mass (i.e. significant size that *consumer* applicatrions are commonly produced for Linux as well as Windows) and Microsoft hasn't found another way by then to hold on to its monopoly power (e.g. by locking out competitors via patents or evolving the OS into a DRM protected managed service) then I predict that Windows will die pretty quickly.
It boils down to the simple economic fact that Open Source is self-sustaining even if it is available for free (as in beer), proprietary software is not. Given a level playing field, free software is always going to win.
The EU could stop Microsoft selling in Europe if it doesn't meen common market requirements.
Or without going that far, it could do quite a lot to make Linux the OS of choice in Europe.
Both of those are pretty big sticks to wave around.
Interesting approach - thanks for the reference!
And more importantly than that, you wouldn't be using a lame old general purpose processor. You'd have rolled your own vector processing chip with a custom instruction set specifically optimised for web browsing.