CoreCLR is now open source
blogs.msdn.com
blogs.msdn.com
I'm thrilled. The MS tooling is really, really good and the only thing stopping me from committing to the stack fully has been it's lack of open sourceness (vendor lock in is still feasible but getting less of an issue).
Edit: Pardon the fanboyism but I've tried a set of feasible Non-MS language options for my particular domain and F# in Visual Studio beats for me, my particular use case and coding style Scala, Clojure, Ruby, Python, Haskell, "browser technologies"...
Kind of ironic, what with Ballmer's "Developers developers developers..." spiel.
"Developers,developers,developer" = Fuck developers,need more profits next quarter.
"We brought peace and democracy to country <X>" = We seriously fucked it up for years to come, and installed a brutal puppet dictator.
"We are not evil like those other mean companies. We will do good in the world" = The main products are the users, who's information it sells it its real users. Have colaborated and been in bed with corrupt governments all across the world.
The list goes on. It is a rather fun heuristic. And once you know about, you'll start seeing it more often.
If someone has a very strong opinion about something and tries to "convert" everyone to it (say, vegetarianism, meditation, emacs, or whatever), it is usually because someone is very insecure about him/herself this trait, and made it part of their identity. It usually has no point discussing this with a person like that.
New mothers, people giving up smoking, people changing diet, people trying to hide things about themselves.
"The lady doth protest too much"
http://en.wikipedia.org/wiki/The_lady_doth_protest_too_much,...
This works very well for advertisements.
e.g. "Our flights are very comfortable" -> Long haul flights are, in general, cramped and gruelling.
"Our broadband is fast" -> Broadband isn't fast enough.
The selling point of the product addresses a perceived deficiency in the product category. It's safe to assume that the product is, at best, slightly less bad at it than the competitors.
Now as you say, would that have made the difference? It is hard to say...
He laid the foundation before he and Gates started selling their stock. The new Microsoft is beholden to Wall Street. It can't do an Xbox360 or Windows Phone or buy a Nokia. Ten years of Open Source projects at Microsoft are why analysts aren't calling for scalps. Ballmer made the next guys job easier.
The biggest difference now is all the stuff they give out for free.
No, it doesn't actually matter, it's not a financial issue. Open sourcing their libs is good because it gives developers access to the sources of libraries which they use daily. This in turn will make debugging much easier and will also help with understanding what is actually happening when you call some function.
I left MS-land a decade ago, but when I worked with MS tools I'd have gladly paid serious money for access to the source code (that was in C++, I hear debugging is easier in C#), but that wasn't an option. Now they offer access to the source code, which is the important part, and for free, which is kind of nice but very important.
So I can return to my code, which I've completely forgotten how it works, see that it compiles, read it through, and continue working. Noticeably: I do not need to care about the tooling because it just works. I don't get a shiteload of weird exceptions when I run my code (looking at you, Clojure - yes, I'm a noob) and since the Pythonic and mutable nature of F# allows me to write code in the way I enjoy the most it feels like a glove. There are a few oddities occasionally and some bits are a bit more verbose than in other languages (Clojures collections spoil any other language) but the overall experience is that I can focus only on my code. For me, it's a pain free computational substrate, and free as in beer now that Visual Studio community edition is out.
My progress is really slow but always worthwhile.
If you are interested I found Jon Harrops "Visual F# 2010 for Technical Computing" really good practical introduction, Don Syme et. alls "Expert F#" a good reference book on writing general stuff in the .Net ecosystem with F#, Petricek's "Real-World Functional Programming" a very good introduction to various application patterns and Sestoft's "Programming Language Concepts" a great book and online reference on writing interpreters and compilers (http://www.itu.dk/people/sestoft/plc/).
*At work I use C++ on MS stack.
Table of contents and sample chapters here - http://manning.com/petricek2/
Unfortunately I have to love Clojure from afar. Partly because I only touch it for Riemann so I'm always rusty, and partly because the JVM. I'm really hoping that all this open source .NET business will bring more attention to ClojureCLR though. ClojureScript is a wonderful thing and I know there are some F# and CIL->JS transpilers but LightTable->ClojureScript->Chrome is a wonderful thing. A similar story, complete with insta-repl, with F# would be crazy cool.
That said, I'm glad MSFT is now competing in the open source/x-platform desktop app space. The Java team can use the extra competition.
It's not like Linux because there isn't a team of experienced volunteers already working on the code base and the Windows code base contains a lot functionality for business reasons that Torvalds has been in a position to not just say "no" but to add "and go fuck yourself."
But this is strictly imaginary because I doubt that 20 million lines of code are all under the unilateral control of Microsoft.
That model fit my needs and interests for many years. Less so now because my needs and interests have changed to where the tradeoffs Linux and Open Source impose are outweighed by their advantages. But other people have other needs and there are already enough first world problem zealots in the world.
Everything you can do with closed source software you can also do with open, and there are things you can't do with closed source.
This is just not true. Show me a completely open source smart phone... thing is you can't, the baseband and radio will always for sure be closed source. There are markets where having knowledge that your competition doesn't is vital to success, that is why some things will always be closed source.
StackOverflow is an example of why the choice is beneficial. The source code being proprietary is irrelevant because the content is Creative Commons.
You can use it, or you can not.
The beauty of open source model is it gives the desperately motivated the means to fix their problems in a way that benefits everyone.
[Ed: as for 20mloc -- the opened parts of .net is already at 5mloc...
Also, love seeing stuff like this from tfa:
git clone https://...corefxlab
cd ...corefxlab\...HelloWorld
nuget restore
msbuild
.\bin\Debug\HelloWorld.exe
]Opening .Net up, I feel is for a couple reasons. First, keeping developer mindshare. Second, Keeping Azure as a first-class platform for deploying .Net code. Third, reducing costs within Azure division that are tied to Windows' licensing. The fact that it's probably the right thing to do, is probably farther down the list.
Point being, the most common reason companies give for not releasing source for a project is that they have code from contractors that they aren't able to release. That shouldn't be the case with Windows.
There are probably some parts that won't make it like Pinball [old new thing] but it shouldn't be significant at all.
>> Hey everybody asking that the source code be released: The source code was licensed from another company. If you want the source code, you have to go ask them.
[old new thing] blogs.msdn.com/b/oldnewthing/archive/2012/12/18/10378851.aspx
I seriously doubt piracy of Windows is a huge concern in most markets; MS will still be making a lot of money from Dell, HP, Lenovo, et al selling their stuff.
You can see this by looking at their Office 365 strategy (iOS, Android release, online version push). Making Windows 10 free to 8 users, removing licensing fees for windows phones, making Visual Studio available for free. Making the ASP.NET vNext to run on Linux.
Instead, MS sees the growth in Azure. Whether they use Linux or Windows servers, MS can make money off of the enterprise/startup segment. Whether or not it is a sustainable strategy in the long run, we will see. But in the short term, at least for the "consumer" market, MS is giving up on Windows and it is moving its focus to Azure and the software that runs on top of Azure (Office, Sharepoint, Dev Services, XBox, Bing, etc).
The marketing strategy behind this is also interesting. Things are still labeled "Windows" to give the illusion that the "Windows" the end user gets on their new laptop is somehow "related" to the Windows in the cloud (Azure). Interesting strategy to make the "Windows" brand live for a little more at least..
It's a completely different matters.
At least this was still true in Windows 8.1.
The NT kernel is sometimes called a _hybrid_ microkernel, but this refers only to the fact that the internal modules are logically decoupled (with message passing between them, for example). Also, graphics actually used to run in userland until they moved it into the kernel for Windows 2000.
There are some other drivers that also run in user mode, but graphics drivers were the really big change. Most bluescreens in Windows XP were caused by graphics drivers.
Since Vista, Windows has been able to recover from a failure in the graphics driver. The screen blinks for a second, and then a balloon notification comes up, saying that the graphics driver has been restarted.
NT is a hybrid kernel because some drivers run in ring 0, others (typically peripheral drivers) run outside ring 0. Some drivers (specifically graphics card drivers) run split in kernel mode and user mode: A small part runs in kernel mode, while the complex part runs in user mode.
While you are correct that the graphics driver was moved to kernel mode for Windows 2000/XP, it was actually moved half-way back with Vista. This was in fact the reason why graphics drivers sucked in the beginning for Vista: MS only gave the vendors 4 months since the last change to the graphics driver model before Vista was released.
Two, compatibility. Even if you fix a bug, it usually needs to be versioned in some way to avoid breaking apps that rely on the bug. OS code, once shipped, becomes feature. Fixes require a fair amount of due diligence besides just identifying the problem and the correct fix. The historical context of how the issue was introduced and how it has migrated to other branches needs to be understood by grepping through the source history graph. Suites of build verification tests, regression tests, integration tests, and unit tests need to pass. Although Microsoft has extensive infrastructure for buddy builds and integration staging, external parties won't. So at best they could suggest a fix to Microsoft to complete the due diligence on. But usually suggesting a fix is easy and vetting it is the grueling part.
Three, private forks of Windows seem like maintenance and compatibility nightmares. Fragmentation would likely disrupt windows update's ability to apply patches and keep the system secure. Windows' ability to run across so many devices is kept sane by keeping a relatively small, consistent trusted computing base. Merging together forked Windows repos is a disaster. The XBOX team forked Windows 8 for a few months and made some tweaks to get XBOX One out the door, and then some folks had the nasty job of having to try and consolidate the codebases against moving targets. No one has enough context or time to perform these kinds of merges individually, nor would ever volunteer to, so they need to be massive coordinated efforts between teams.
Four, variants. You're not going to want to deal with all the possible permutations of Windows SKUs, processor architectures (ARM/X86/AMD64/IA64), build flavors, etc.
Five, it's a mess. There's plenty of archaic cruft, possible trade secrets, and lurking vulnerabilities. Open sourcing everything would be like opening Pandora's Box. It's too risky. Curating out some portion of this to open-source would be a massive undertaking and ongoing maintenance cost.
I think it makes more sense to take more mature modules, like .NET core or Roslyn, and open source them as separate entities. Modules are more reusable, and community-driven changes are easier to curate when they can be isolated. Windows has some components which it probably makes sense to open-source, but the entity as a whole is too unwieldy in its current form. .NET is designed more modularly.
TL;DR - Windows is an unwieldy behemoth and would be difficult to open source.
Are foreign governments a big market that Microsoft has lost a lot of customers from? I don't think so. The vast majority of the potential market for Windows is already running Windows, so I don't see what they'd really have to gain. The small but loud minority of open-source zealots won't be happy until every single Microsoft product is open.
I think this goes back to one of the core tenets of free and/or open source software: the user should be able to know, control, and modify exactly what their machine is doing.
If the source is not available you're just running a black box and praying that it will do what the person who gave it to you claims it will do.
I'm sorry to point out to you but a large set of computing devices are black boxes and it does not hurt their marketability. Cars, phones (the OS running the hardware, not Android), ... the pilot in the passenger plane does not want to hack his planes OS, nor most likely does the mechanics crew.
Practically, lots of people just want to get their job/art project/email/browsing done and do not care about the blackness of the box just as long as it works.
I think one of the reasons RMS got going was that he was irritated that the software from vendors did not work.
The software markets have advanced some what. Nowadays, for any product with a sizeable market it is fairly safe to presume the software works or at least won't fail miserably. And if it does, it's not just the lone consumer but thousands/million others who are pissed off as well. Yeah, crap gets released though.
On the other hand, if you have complete visibility into what your machine is doing and have the ability to modify it at will you can avoid all manner of failure scenarios that are essentially unrecoverable in the black box scenario.
We know people will run black boxes, drink poisoned sugar drinks, support genocidal megalomaniacs, torture others for limited monetary gain and/or endorphin rushes, etc. None of those realities imply that others should follow in the same footsteps, especially when there are workable alternatives that don't suffer from the same permanent failure scenarios.
Civilization is characterized by specialization of people. I cherish the notion that hardware and software should be based on open standards. For day to day work, I just want my gear to work. If it fails, I certainly do not have the time to dig in to the software layer because I have a work, children, housekeeping duties, and a bunch of art projects and higher level concepts I want to focus on.
"if you have complete visibility into what your machine is doing and have the ability to modify it at will you can avoid all manner of failure scenarios that are essentially unrecoverable in the black box scenario."
You presume all software is trivially simple. I can tell you, it is not. A large category of software requires years of specialization to actually grok what is happening.
As an extreme example if I owned a plane I would not like to hack it's software under any circumstance unless I were a professional aeronautics professional, and probably not even then.
Free software should be looked on from the point of ethics, and not from financial gain. Proprietary software is immoral, and that is the reason you shouldn't be building it.
https://www.gnu.org/philosophy/open-source-misses-the-point....
It's one thing to laud the common benefits of FOSS, or the ethical gains of charity. These things resonate with me. But I fundamentally disagree with - and as a proprietary software developer, am alienated by - your statement.
Is that actually what you mean? My day job - making games - is immoral? A daily dose of evil? If so, this is the kind of attitude that puts me off contributing to anything even remotely related to "free software".
Perhaps you're fine with that, but I feel it leaves us all poorer.
(edit: minor improvements to clarity.)
I think the word 'markets' was a bit misguiding in terms of argumentation. I meant "things which bring people added value and joy" and not "things which can be sold for money". Markets encompass both but I was thinking the consumer added-value in this instance.
"Proprietary software is immoral, and that is the reason you shouldn't be building it"
I think taken without any other context this is not realistic.
I think the concept of ownerhip and responsibility are far more important for high quality software for the point of view of short term end user value than openness.
Software has a philosophical and a mathematical dimension. I don't think anyone should be able to own those and that most software patents are harmful in this way. However.
Software is used as an enabling component everywhere. As an enabling component it's added value does not depend on it's freedom or openness, but from it's capability to function bug free and provide the features end users need. As the canvas in the art program, as the automatic stabilizer in the plane and so forth.
In these instances I claim the biggest human value those softwares bring is indenpendent from their openness.
To enable the example softwares to function correctly require lots of hard labour that is not fun at all. I.e. work. Often it is repeating the same old concepts over and over again, knitting the specific system together piece by piece.
I think there is no Photoshop killer because the people to whom it brings most added value are not programmers and it's usually not fun or rewarding at all to work with such a large codebase. Blender is a fantastic counterexample.
Of course, software should utilize open and hackable data formats so that the data does not vanish.
The long term value for the user and the concept of the software providing free speech capabilities then depends on the underlying software ecosystem, and there open source most definitely helps.
Open formats, open tools to hack on them, open platforms. Yes, definetly! Any other way is harmfull to all stakeholders. IMO, products can be closed source.
That black box model has been with Windows from day one and it hasn't stopped Windows owning 90% of the PC market.
I'm sure the IRS is kicking themselves for running XP for over a decade, building up such an extreme dependency on it that they are now paying huge sums of money for Microsoft to continue to support them.
The black box is only great so long as it actually works, and when it breaks you are completely screwed. It is in Microsofts business interests to make sure it works, but they also want you paying them money while maintaining control of your computer.
But when it does break, your only option is the true owner of your computer, who will milk you for all you are worth, because you are now trapped. You don't know you are in a cage until you want out.
To most users Linux is just as much of a black box as Windows is.
Even among Linux fans, the number of people who actually need to customize the kernel is tiny. The number of people who can customize the kernel is even smaller.
So where's the freedom? At the OS level, all that's happened is that the lockdown has moved from corporations to a subset of the developer community.
Most end users aren't any more empowered than they used to be.
Now - it's different in the web and language spaces, where there's a steady simmer of framework development, and many popular web projects/products wouldn't have been possible without framework sharing.
But there's still plenty of proprietary content there. Just try to get Google or Facebook to share their data collections with you and see how politically relevant open source 'freedom' is then.
If that seems like a tangent, it's missing the point that the value of a system doesn't come from the source code - it comes from the system as a whole, and includes usability, community reach, innovation, invention, and data.
Open source pretends to be a huge lever for freedom, but it's more like a battered fork caught in an avalanche.
In computing, the world-changing leverage is elsewhere, and always has been.
When that happens they ask me to fix it and if it wasn't me, then yes they would take it to a computer technician.
Just like they take their car to the mechanic.
Guess what. Not everyone is or wants to be a computer programmer and that group makes up the majority of all Windows users.
And why Windows has been so successful is you can get away with knowing very little about computers (like my mum and dad) yet still find Windows easy to use.
Years ago I saw a demo of a Windows subsystem running an ELF Apache server directly on Windows NT. It isn't anything that Microsoft would release though, because once you make it so Windows can run Linux applications, who is going to write Windows apps? It erodes the platform.
I see an official WINE for OSX, that has a perfectly working subsystem, introducing the same problems to that ecosystem.
They would fork it, but that is not why.
There aren't many people who have bought MS software for years and are now excited to use a fork or their own build. Even assuming that some other mega corp comes along and offers world class support/service and their own fork, it still probably wouldn't hurt MS much.
Most small companies would have released their code as GPL (versus MIT as the case here) to limit the risk of a fork fragmenting everything (not being able to merge forks back in or make everything compatible). But in Microsoft's case, because of their size, few companies could hope to make a better version than MS. Further, MS makes money in lots of ways and this isn't a zero-sum game for them. They'll profit immensely from a more open ecosystem. Companies such as IBM, Apple, Google, and Oracle already have proven it's possible to be profitable with open source.
Er, no.
The entirety of Oracle's dabbling in "open source" has been by shaking free software products out of the rotting carcass of Sun Microsystems and - in many cases - adding those products to the grave (see also: OpenSolaris, OpenOffice, various others). The exceptions - namely MySQL (which wasn't a Sun product) and Java (which is still doing reasonably well) - are few and far between.
Oracle Linux certainly exists, but I'm certainly not about to hold that monstrosity on any sort of pedestal.
As for the others, yeah, they're making money on FOSS (and not killing said FOSS in the process), though such free software tends to be integrated in very much proprietary end results (like OS X / iOS and the vast majority of Android distributions).
And Oracle Java has also died on every platform that is not Windows. OpenJDK took over the Unix space, and Google has Dalvik and the ART implementing the JRE.
Virtualbox still exists. I guess. It has not done anything in about half a decade, though.
Oracle's no golden example as a leader in open source (let alone libre software), but they demonstrate the probable trajectory for the Microsoft projects at this point: a healthy, cohesive community of developers (developers!) using the technology in an ever increasing number of projects and platforms.
What do you mean? I use VirtualBox for lots of stuff and it gets regular updates... it's also faster than VMWare in most benchmarks I've seen. Perhaps you're thinking of something else when speaking of 'not doing anything'?
However, there are still plenty of environments using MySQL (and I'd know; I maintain quite a few such environments). MariaDB is an obvious migration path, of course.
Really?! I am yet to see any production deployment of OpenJDK in any of the consulting projects I work on.
It is either Oracle JVM, a commercial license of it, or a third party certified JVM.
As for Android it has become even worse than J2ME.
It is funny. At some point Redhat said "screw those guys" and started obfuscating its patches to the kernel (Oracle Linux was based on RHEL's code which was open source) to make it harder for Oracle to apply and create the (what was seen as) a competing Enterprise Linux Distro.
You're forgetting that a lot of people traditionally haven't liked Microsoft because their software wasn't/isn't open. Yeah, Windows would still be a steaming pile of bovine manure regardless of which license it was made available under, but the availability of that source code would make it easy for better, Unix-like operating systems to pick up the necessary pieces to support Windows software, thus continuing to allow Microsoft to profit on their non-operating-system software (Office, SQL Server, Exchange, IIS, Internet Explorer^H^H^H^H^H^H^H^H^H^H^H^H^H^H^H^H^HSpartan, etc.) regardless of whether or not Windows itself is widespread in usage.
Even if the bug wasn't in our code, it was really helpful to see what's going on inside, helped us figure out why something didn't work a lot of time. Making false assumptions, passing stuff in a different format than the system expects etc.
We all, always worked with a decompiler in eclipse, just because it really did make life so much easier sometimes. And well, of course, sometimes there really was a bug in the stack, and finding a workaround is much easier when you know what's going on.
If Windows was good and near-bug-free, Wine would have long been completed. Windows is not just its kernel.
And of course Wine is an outlier. Not only in that it contains its own 20 years of legacy code but in the fact that it is black box reverse engineering. It can't use disassembly to suss out details. Wine's difficulties stem from its requirements as much as anything else. These days VM's are the way to go if the going is intended to get things done. A Windows box in the cloud is pennies per hour.
Here's a link from 2008 that shows how it works:
http://blogs.msdn.com/b/sburke/archive/2008/01/16/configurin...
But it's fairly easy to determine what their strategy is, given that they've been open sourcing most things that touches Azure. Azure also hosts Linux Servers and given the world is moving towards hosting on Linux, they're following the trend to stay relevant and appeal to more developers.
Basically this comes down to making the .NET ecosystem more appealing and attracting more developers to Microsoft platform and development tools which will integrate seamlessly with their Azure hosting services and other commercial server products.
Is it though? I would believe that the people using the community edition are the same people that were previously using the express edition, i.e. hobbyists and students who were not going to pay for it anyhow. And as you already described in your last paragraphs: if their plan works out, I would imagine visual studio license revenues to go up in the long term as more people are attracted to the eco-system.
I don't pretend to understand the calculus of the decision, just offering this point you may have overlooked.
Prices for cloud servers are falling, so do they really plan to take part to a race to the bottom? I remember this discussion from November https://news.ycombinator.com/item?id=8582096
No, they can code in Linux using Vim if they want.
Not exactly. Anyone inside an "enterprise organization" (according to Microsoft's arbitrary definition) is even worse off than before, because Microsoft won't be releasing the Express editions any more.
From http://www.visualstudio.com/products/visual-studio-community...
Here’s how individual developers can use Visual Studio Community:
- Any individual developer can use Visual Studio Community to create their own free or paid apps.
Here’s how Visual Studio Community can be used in organizations:
- An unlimited number of users within an organization can use Visual Studio Community for the following scenarios: in a classroom learning environment, for academic research, or for contributing to open source projects.
- For all other usage scenarios: In non-enterprise organizations, up to 5 users can use Visual Studio Community. In enterprise organizations (meaning those with >250 PCs or > $1 Million US Dollars in annual revenue), no use is permitted beyond the open source, academic research, and classroom learning environment scenarios described above.
I doubt that there were ever significant numbers of developers in enterprise organizations using Express Editions anyway. If you are doing serious business, the cost of paid licenses (and MSDN subscriptions) is generally justified if you are going to be using MS technologies.
That was Sun's strategy for Java; it didn't work out well for them. Java became huge, but Sun never did figure out how to make a dollar from it.
They also get commercial support contracts from it.
And they got money from licensing various trademarks, test suites, J2ME and so on.
But yeah - ultimately Sun weren't able to build a killer business out of Java. They had a variety of small revenue streams but nothing that could compete with Windows.
Making ASP.NET Linux deployable ensures that Windows stays in the hands of developers. Making Azure Linux friendly ensures that Microsoft can take a slice of that market. And pushing Universal Apps and giving Visual Studio Community and Windows 10, an OS that allows Universal Apps to run on the desktop, for free motivates developers to fill up the app store.
This decision was inevitable and IMHO a huge step in the right direction.
About the .NET on Linux move, so the strategy could be to make more people willing to develop with .NET, bet that they buy VisualStudio, which means Windows desktop licenses and be prepared to see Windows Server replaced by Linux instances running (hopefully for them) on Azure. For that to work they must be bold in selling Azure and luring developers to the .NET stack. I don't foresee developers leaving their 5/10 years investment on other stacks en masse. Maybe new developers will consider .NET as a viable alternative to all the other open source tecnologies. It's a generational gamble and it's going to pay only if they really can compete against AWS and the other VM providers.
However I understand that they must do something, or they'll end up as the company that makes a console and an OS for video gamers and for cheap computers.
I'd buy the next version in a heartbeat if they offered it.
What version? There is DX9 support on Linux and IIRC a partial DX10/11 implementation bit-rotting somewhere.
IMO, open sourcing Visual Studio itself is not all that interesting vs. open sourcing the .NET platform.
[1]: http://instagram.com/p/yqQe0bK3Bq/ [2]: felix.rieseberg@microsoft.com
https://github.com/dotnet/coreclr/blob/master/src/mscorlib/s...
[1]: https://github.com/munificent/wren/blob/master/src/wren_valu...
[2]: https://github.com/dotnet/coreclr/blob/master/src/mscorlib/s...
// We want to ensure we can change our hash function daily.
// This is perfectly fine as long as you don't persist the
// value from GetHashCode to disk or count on String A
// hashing before string B. Those are bugs in your code.
hash1 ^= ThisAssembly.DailyBuildNumber;
I'd love to hear the story behind this one :D
The shipped product doesn't include this "randomness".
The idea is that the hash is good enough for normal list, but it's not a cryptographic hash and it's easy to find collisions. Then you can make a lot of requests with strings that has the same hash value. Now the hash operations are O(N) instead of O(~1) and everything is slower.
Using an unpredictable hash calculation makes this attack more difficult.
>>> (lambda w:w[2:]+w[:2])(''.join(sorted("Phyton",key=lambda c:math.sin(ord(c)^50))))
'Python'http://referencesource.microsoft.com/#mscorlib/system/string...
IE: Environment.GetResourceString("ArgumentOutOfRange_Index")
The string there is in multiple areas of that class, and the same behavior is displayed for all of them. Wouldn't logic suggest everything such as above would be moved in to a constant repository for clarity and also less potential human error for future additions?
http://grepcode.com/file/repository.grepcode.com/java/root/j...
It's sort of surprising to me how much huger the .NET version is, in terms of code. Virtually all the lines in the Java version are API docs. The .NET version doesn't seem to have them (they must be elsewhere?) but it does have a lot more code and that code is much lower level.
Not sure what that means, if anything, but it's interesting.
http://blogs.msdn.com/b/ericlippert/archive/2011/07/19/strin...
This lets them interoperate with OLE Automation.
https://github.com/dotnet/coreclr/commit/90ef39bc3c9886e7967...
"This change fixes a potential problem in unwinding on Linux"
Today, .NET Core builds and runs on Windows. We will be adding Linux and Mac implementations of platform-specific components over the next few months. We already have some Linux-specific code in .NET Core, but we’re really just getting started on our ports. We wanted to open up the code first, so that we could all enjoy the cross-platform journey from the outset.
"You can 'watch' the repo to see Linux and Mac support being added over the next few months."
All the groundwork was done by Ballmer. It had to be because now that he and Gates have reduced their ownership stake and are no longer the two largest shareholders, Wall Street's flavor of the month ideas cannot be ignored.
The 'new' Microsoft has been building at least since they hired Hanselman back around 2008. He was talking then on his podcast about taking the job to advocate open source. Even then Microsoft worked with the Mono team. They moved Office to an open file format.
It takes a long time to change an aircraft carrier's course. This is Ballmer's strategic vision. His passion for developers even made it onto Youtube.
Or rather: When OpenDocument was standardized by ISO and threatened to create demand for open, common, standardized interchange formats, they created a similarly and confusingly named XML version of their existing format, with insufficient documentation to allow complete third-party implementations, and pushed it as a competing ISO standard, using tricks such as (accidentally, I believe they said) encouraging partner companies to join standards bodies just for the vote: http://en.wikipedia.org/wiki/Swedish_Standards_Institute#The...
That may have been true at the time, but the documentation for OpenXML is actually very good. It's incredibly detailed -- I think the standard is somewhere around 5000 pages, and fairly readable. Of course, I haven't ever actually had to write my own implementation (thank god).
As Grace Hopper said, the great thing about standards is there a are so many to choose from.
If it's possible to transpile either Java source or better Java class files to a CLR assembly, even some of the community momentum that Java has might turn into a benefit for .NET, too.
In particular: http://sourceforge.net/p/ikvm/wiki/Ikvmc/
But holy shit, who in their right mind still uses CVS?!
Regarding .NET, it is likely it will benefit Microsoft significantly. First, because Microsoft would not do it without strong reasons. Second, we can guess at those reasons: Microsoft wants to grow its developer ecosystem. .NET has been limited due to being Windows-focused. Opening it up makes sense.
(Yes, Mono exists, but the .NET cross-platform experience still wasn't good enough. Not necessarily Mono's fault, but regardless, opening .NET can solve this (possibly at a cost to Mono).)
But in this context you seem to imply that there are practical differences i.e: Not all Open Source licences are considered Free Software in the practical sense.
If that is the case, could you provide an example?
For instance, this licence: http://opensource.org/licenses/AFL-3.0
It provide free usage, studying, display, publishing, but also explicitly says that some of the part could be binaries (machine-readable), you can't sell anything derivative, and the licence is personal with no right to give the licence to anyone else.
So, you can consult and modify in the frame of your academical work, but no more.
But in this context you seem to imply that there are practical differences i.e: Not all Open Source licences are considered Free Software in the practical sense.
The Open Source Initiative (OSI) was certifying all sorts of licenses as "open source" under their definition. Basically if you allowed people to see your source code it was considered open source. That's not really practical and most open source licenses had an agenda of the company retaining control, which means people can't really do what they want. To most developers there are basically the BSD/MIT licenses that allow you to do whatever you want, and the GPL/LGPL licenses that allow you to do what ever you want - so long as you pass that freedom on to your users. These are both forms of Free Software, though the distinction causes much argument. Every other "open source" license is generally more restrictive and meant for someone to retain ultimate control, including the old Microsoft licenses.
In my opinion the OSI did more harm to the movement than good by "certifying" a huge number of irrelevant licenses so companies could claim be doing the cool new thing. None of that code can be integrated into anything else under different terms - at least not without consulting a lawyer.
This (premise of your entire post) is very much incorrect.
OSI has never certified the notorious MSFT "Shared Source" licenses that you are probably referring to.
Please read the Wikipedia article on the subject, you will find that the licenses that are certified by OSI are the same licenses that the FSF calls "free software", and the licenses that OSI didn't certify are "non-free" according to the FSF.
http://en.wikipedia.org/wiki/Shared_source
The OSI "Open Source Definition" criteria are based on the "Debian Free Sofware Guidelines", which are in turn inspired by the FSF's "Free Software Definition".
In practice all 3 of these organizations tend to come to the same verdict, with very few exceptions in fringe cases (such as the GFDL).
[0] http://www.gnu.org/philosophy/open-source-misses-the-point.h...
https://github.com/dotnet/coreclr/blob/master/build.cmd#L140
https://github.com/dotnet/coreclr/blob/master/build.cmd#L159
I guess this explains why they saw no need to fix the somewhat broken SLN file-format in the first place, but actually did something about project-files. They don't share their customers pain on this point.
[1] http://www.theregister.co.uk/2015/01/15/codeplex_repository_...
As a social-networking website, the most important thing that defines it is the number of users. You could publish your code on Codeplex or Bitbucket, but you would be simply limiting your reach.
For the curious: http://voices.canonical.com/jussi.pakkanen/2011/09/13/autoto... (tldr: autotools won't work on windows, you need a shell emulator, like cygwin, and gcc)
Premake is nice, also. But CMakes tend to work better for a big project.
Additionally, if you don't truly plan on enforcing many requirements of the license (e.g., if a distributor fails to "cause any modified files to carry prominent notices stating that You changed the files" (4.b.), will you send them a letter telling them to correct the problem?), then why bother using a license that includes those requirements?
How the wheel of freedom has turned.
* disclaimer: yeah I know the Stallman crowd have their own particular definition of "freedom" that is vastly different and would disagree
I suppose this is important to Mono guys as mono is GPL AFAIK.
Plus there are the other benifits (especially when it comes to free software projects being able to reuse that code without worrying so much about license compatibility).
Now one of the guys pushing it, is CEO of Microsoft and we are finally seeing a (real) difference.. I joined the MS community a long time ago and this is (again) a heart warming addition!
Good job Microsoft, you're a bit late to the party. But no doubt, the ROI will show sooner or later! ;-)
Note: You'll need a terminal account to boot it, but it only takes 10 seconds to come online once you do that.
Since it's very easy to decompile .NET binaries and Windows has been a traditional place for crackers and what not, I think that code base is very well inspected already.
For example: http://referencesource.microsoft.com/#PresentationFramework/...
I would recommend something like Eto.Forms (https://github.com/picoe/Eto) which is an abstraction over native GUI toolkits (WPF, WinForms, GTK+, Cocoa)
Works really well and mature.
One of the projects I am currently working on, a greenfield application, requires WindowsForms for reasons I cannot expose here.
1) It's going to be used in conjunction with other legacy applications that only run on Windows PCs anyway.
2) GUIs designed for both phones and PCs don't work well on either, it seems to me.
3) In fancy high-level frameworks you often eventually end up calling a bunch of Win32 functions, so I might as well learn it. :)
Would be great if MS open-sourced WinForms as well so we could fill in the gaps.
C++ tooling is behind its time (CMake, no dependency management) and JS approach seems kludgy right now.
Java was pretty close (JDK .. or NetBeans, support packaging to Windows or Mac AppStore) but the UI component for OSX is not pleasing and would be nice if it can produce something for Ubuntu/Redhat at least (don't care Arch or the rest at the moment).
Basically I want something better than what Oracle Java has to offer today :)
PS: I would require a great IDE, unit-testing/automation-testing, good scriptable build (Maven/Gradle style, not Ant/NAnt/MSBuild).
Although there are skins that can make it look native on each platform, I didn't bother with this for my app. Trying to match native on a cross platform app is a fools errand. A few months after you ship your app, the OS developers will decide to reskin everything and anything not using their native toolkit will look out of place. So my app takes its inspiration from Twitter Bootstrap and just doesn't even try to look native. You can skin JavaFX with CSS so it's quite easy to match the look, at least in some ways. Nobody has complained and quite a few people said the app looks great. I would definitely do this again for my future apps. Pick a nice design that isn't native to any platform in particular, and people won't hate you for it.
BTW Java now comes with a packager tool that makes self contained native installers which don't depend on the user having Java installed. Deployment is a lot more practical these days.
I guess it's no surprise that microsoft software has a human-edited source file that's over 35000 lines...
IIRC, it was originally machine-generated... from LISP code written by David Bacon, under contract from the then-GC owner Patrick Dussud.
Because it's a gargantuan 1193.581 kb.
Has anyone heard or seen whether MSFT is planning to support this?