Slashdot Mirror


Microsoft Starts Working On an LLVM-Based Compiler For .NET

An anonymous reader writes Are the days of Microsoft's proprietary compiler over? Microsoft has announced they've started work on a new .NET compiler using LLVM and targets their CoreCLR — any C# program written for the .NET core class libraries can now run on any OS where CoreCLR and LLVM are supported. Right now the compiler only supports JIT compilation but AOT is being worked on along with other features. The new Microsoft LLVM compiler is called LLILC and is MIT-licensed.

58 of 125 comments (clear)

  1. Developers, Developer, Developers by CSHARP123 · · Score: 5, Insightful

    The old CEO was shouting developers, developers and pushing them aside. This CEO doesn't make a peep but quietly bringing in the developers

    1. Re:Developers, Developer, Developers by Richard_at_work · · Score: 3, Interesting

      How did Ballmer push developers aside? Under the latter part of his reign, Microsoft started open sourcing a lot of their developer frameworks etc (ASP.Net MVC in 2012, Entity Framework in 2013 etc) and we saw fairly large shifts in developer conferences and support.

    2. Re:Developers, Developer, Developers by ranton · · Score: 5, Interesting

      Well I can say these announcements have brought me back to developing in .Net. C# has been my favorite language by far ever since v3.5 (and was my favorite by a little since v2.0) but its vendor lock was becoming too much of a liability.

      The moment I can go back to C# and easily have my code run on *nix servers I will drop Java in a heartbeat. Just being able to use LINQ again in my professional life will be a blessing. And going back to Visual Studio over Eclipse / Netbeans / and even IntelliJ is also something I have been longing for.

      --
      -- All that is necessary for the triumph of evil is that good men do nothing. -- Edmund Burke
    3. Re:Developers, Developer, Developers by OzPeter · · Score: 1

      Just being able to use LINQ again in my professional life will be a blessing.

      Is there any other language that has something comparable to LINQ?

      --
      I am Slashdot. Are you Slashdot as well?
    4. Re:Developers, Developer, Developers by neilo_1701D · · Score: 5, Interesting

      How did Ballmer push developers aside?

      He pushed them aside by killing development systems (VB6,FoxPro), introducing new technologies with the promise of how critical they were to the future (Silverlight), and allowing the crown jewels of Windows development, the Win32 API, to slowly become more irrelevant with endless layers of cruft built on top (eg. .net, although a wonderful system, becomes more and more incompatible with the underlying OS; eg. GDI+).

      Microsoft started open sourcing a lot of their developer frameworks etc (ASP.Net MVC in 2012, Entity Framework in 2013 etc) and we saw fairly large shifts in developer conferences and support

      By your own words, we can infer that Ballmer's middle-empire period required large shifting from where it was to what it became.

      Ballmer wasn't bad; his jumping around on stage shouting "Developers!" showed that he knew what the true value of Windows was: the external developers who wrote Win32 code for retail products or company-internal developers. However, his middle-empire stage was a shift to focusing on selling to enterprise customers. This isn't a bad things by itself, but by taking his eye off the "Developer!" ball and focusing elsewhere, he guaranteed that plenty of developers went elsewhere. For example, with the death of VB plenty of developers shifted to Java rather than .net. The fact that it needed a large shift in support shoes just how far developers had slipped in Microsoft's priority.

      It's interesting to see how Nadella is shifting the focus again and broadening it (Windows 10 on Raspberry Pi, for example). Time will tell if Nadella is simply being an anti-Ballmer or if this glasnost is signs of a more fundamental shift in the way Microsoft does business. I hope it's the latter.

    5. Re:Developers, Developer, Developers by 31415926535897 · · Score: 1

      Different scopes.

      The old CEO wanted to enable developers in house. The new CEO seems to want to enable developers in the community.

    6. Re:Developers, Developer, Developers by omtinez · · Score: 2

      Python list comprehension, which is OK for simple queries but doesn't scale as nicely as LINQ

    7. Re:Developers, Developer, Developers by BaronAaron · · Score: 2

      Depending on what dependencies you use in your code you could have had it running on Linux years ago using Mono.

      I've had good experiences running ASP.NET MVC and console apps on Linux in production environments.

    8. Re:Developers, Developer, Developers by Anonymous Coward · · Score: 5, Interesting

      VB6 and FoxPro served their purpose and needed to end. They were prototypes for various parts of what became .Net.

      VB6 was discontinued right away when Microsoft combined VBRUNxxx.DLL with their Java implementation that got shitcanned by the anti-trust courts. Then they refined it into a common language runtime for a VB variant, a Java variant, and a heavily modified variant of C and all of the object oriented stuff that has cropped up around it. Later, they dropped the Java variant. Later still, they added a functional programming language.

      FoxPro was discontinued when they released LINQ, which basically mimics the one thing FoxPro had going for it that nothing else did.

      Win32 has not become "irrelevant", since all of the newer technologies still rely on those older ones. (.Net "winforms" simply packages up the old Win32 WNDCLASSEX and window class registration and instantiation into a handy Form object, so instead of 80+ lines of boiler-plate code, you use a simple new Form() and be done with it. I fail to see how this is anything but progress.)

      And .Net uses GDI and GDI+ directly, and has done so since day 1. More recently, it also uses Direct3D and Windows Media Framework directly.

      It's actually rather amazing that otherwise well-informed people on tech sites keep parroting this panicky crap that naysayers said years ago without doing any research into whether it's correct or not. It seems that the one thing Microsoft hasn't been able to change is the level of trust people place in them. A good portion of that was earned, but it's also about time that some people at least brush a few of the chips off of their shoulders.

    9. Re: Developers, Developer, Developers by Redmancometh · · Score: 1

      Yeah just target .net 2.0 and compile it on the server.

    10. Re:Developers, Developer, Developers by neilo_1701D · · Score: 2

      VB6 was discontinued right away when Microsoft combined VBRUNxxx.DLL with their Java implementation that got shitcanned by the anti-trust courts.

      I though it was because VB6 was a COM product?

      ... Later still, they added a functional programming language.

      Nice sledge :)

      Win32 has not become "irrelevant", since all of the newer technologies still rely on those older ones. (.Net "winforms" simply packages up the old Win32 WNDCLASSEX and window class registration and instantiation into a handy Form object, so instead of 80+ lines of boiler-plate code, you use a simple new Form() and be done with it. I fail to see how this is anything but progress.)

      And .Net uses GDI and GDI+ directly, and has done so since day 1.

      I completely agree with everything you've written... if you're a .net programmer, you're fine. But if you're a C programmer sitting directly on top of Win32, you're screwed

      My point, and I guess I didn't make it clearly, is that although these new technologies are fantastic, there is older code out there that is company-critical to companies who invested heavily in the creation of a solution, based on Microsoft's past history of obsessive backwards compatibility, and now find themselves with no way forwards, other than a costly rewrite.

    11. Re:Developers, Developer, Developers by AqD · · Score: 1

      Nope streams only offers the lambda, not expression (= half-compiled code which may be translated into SQL and XML and many other uses), and it's NOT compatible with existing iterable/collection APIs which means its use is very inconvenient and limited. If you really want to use those features you have to try my library jxtn.core.axi which modifies system interfaces to add such functionality.

      The expression stuff can be done by runtime bytecode analysis (not officially), i.e. reverting your bytecode back into expression and then rewriting it. The tech is just out of research last year and has been only used in Jinq, and it requires JVM bytecode - so not possible in dalvik or pre-compiled situation.

    12. Re:Developers, Developer, Developers by Anonymous Coward · · Score: 1

      VB6 was a COM object that implemented a "runtime" component. The same could be said for Microsoft's Java implementation. The runtime that backed VB6 and earlier (VBRUNxxx.DLL) was no less a runtime than the JRE or CLR. OK, it was "less", but it was still a runtime.

      My point was that .Net is an inner platform (as all interpreted-bytecode runtimes are), and thus everything it does can be done, albeit less elegantly, with the underlying native Win32 and COM libraries that it uses.

      I encourage you to read up on what WinRT really is. (That's WinRT, the library, not Windows RT, the ARM port of Windows. WinRT is also called WinMD, just in case you weren't already confused enough.) It allows you to make unmanaged "C++/CX" libraries, then use them from C++/CX, C++/CLI, the other .Net languages, and JavaScript. That's actually how those Direct3D and WMF libraries I linked to before are implemented. WinRT is something of a major overhaul to the good old IUnknown from COM that makes it mostly irrelevant which stack you use to write your apps.

      Far from isolating various developer groups and disciplines, they're actually bringing them all under one roof for the first time. Whether those groups will all play nice with each other, well, that's yet to be seen.

    13. Re:Developers, Developer, Developers by Ed+Avis · · Score: 1

      So... what is it you need that Mono doesn't do?

      --
      -- Ed Avis ed@membled.com
    14. Re:Developers, Developer, Developers by Dutch+Gun · · Score: 3, Interesting

      I completely agree with everything you've written... if you're a .net programmer, you're fine. But if you're a C programmer sitting directly on top of Win32, you're screwed

      Lots of cutting-edge applications are still written in C or C++ and directly use the Windows API (it's not called Win32 anymore). In fact, I'd go so far as to say the majority of large commercial applications you can think of are native apps: Photoshop, Microsoft Office, most videogames, web browsers, media players, etc, etc. Nearly all the new APIs released with new versions of Windows are available to native applications. There's no reason a company has to abandon their legacy C codebase if they don't want to. BTW, the "way forward" for C developers is called C++, and it's conveniently backwards compatible with your C codebase.

      The major reason one would consider switching to .NET from native code is productivity, not new functionality. The .NET APIs are much easier to use than the much older Windows APIs, and the languages .NET supports like C# are far easier to use as well. You don't even have to completely abandon your C or C++ code either. It's pretty simple to write interop layers to communicate between C# and C, and have done so many times at work.

      --
      Irony: Agile development has too much intertia to be abandoned now.
    15. Re: Developers, Developer, Developers by cyber-vandal · · Score: 1

      VB lives on in .NET although it looks like it might finally be dropped in vNext. Silverlight was dropped because technology moved on but is still supported for another 5 years.

    16. Re:Developers, Developer, Developers by ndykman · · Score: 1

      Not really. Sure, many languages have things like LINQ Select/Where (map/filter), but that's just for objects. It's the expression trees where things get interesting. Expression trees allow a provider to generate a different artifact than a map call over objects. LINQ to Entities creates calls which the Entity Framework turns into SQL.

      You can make a custom provider against any data source, really. There is an example of LINQ to Twitter that turns LINQ queries into Twitter API calls (http://linqtotwitter.codeplex.com/).

      This feature requires language support, because when an Expression is needed, the compiler needs to turn a lambda (and so on) into a expression tree, not into compiled CLR code in a closure.

      To be fair, something similar could be done in other languages with proper support. And writing a LINQ provider is non trivial, but it is possible and in certain cases, it can greatly simplify programming.

    17. Re:Developers, Developer, Developers by shutdown+-p+now · · Score: 2

      The nice thing about LINQ is that it covers more ground than just basic map/filter/reduce; notably, joins - which makes it possible to actually reasonably translate expression trees to SQL and such. And joins are a pain in the ass to write using raw lambdas, the sugar is very welcome there.

      Deep nested queries are also often convenient with sugar, because it has "let" for temporary values.

    18. Re:Developers, Developer, Developers by godefroi · · Score: 1

      .NET isn't an interpreted-bytecode runtime. It never has been. It's always been JIT compiled. Always.

      --
      Karma: Poor (Mostly affected by lame karma-joke sigs)
    19. Re:Developers, Developer, Developers by Xest · · Score: 1

      "He pushed them aside by killing development systems (VB6,FoxPro)"

      Except VB6 and Foxpro were never really developer tools. They were tools for non-developers to get basic programming tasks done. That was kind of exactly why they were developed- things like Visual C++ were always the tools targeted at professional developers.

      "the Win32 API, to slowly become more irrelevant with endless layers of cruft built on top"

      Win32 API became irrelevant, because it's become increasingly irrelevant. Why on earth would you want to keep an outdated API that's now decades old in it's design and origins as your primary development target when no one is using it? That just doesn't make any sense whatsoever. It doesn't make sense to maintain something that's inefficient to develop with, and I say this as someone who cut my teeth on Windows development with C and Win32 API many years ago. I have fond memories of it but I've no idea why you'd give a shit about it in this day and age.

      Your argument is classic of someone incapable of dealing with change, which, in the world of technology is probably one of the least desirable traits you can have. You can boil your argument down even further when you talk about layers of cruft, you can say using C with the Win32 API is in itself a layer of cruft built on top of just doing everything in pure assembly, which is a layer of cruft on top of just doing everything directly with machine code and fuck the APIs.

      "Ballmer wasn't bad; his jumping around on stage shouting "Developers!" showed that he knew what the true value of Windows was: the external developers who wrote Win32 code for retail products or company-internal developers."

      Except no one's actually done that for the best part of two decades now. Even before .NET really took off it was far and away MFC that was used for the majority of Windows development. Win32 API development was already largely dead when Gates left for all but the most basic things like setting up a message processing stub to get a DirectX or OpenGL program going.

      "However, his middle-empire stage was a shift to focusing on selling to enterprise customers. This isn't a bad things by itself, but by taking his eye off the "Developer!" ball and focusing elsewhere, he guaranteed that plenty of developers went elsewhere."

      So what? The enterprise became more important, fat client applications gave way to web applications. Ballmer doubled the profits of Microsoft during his tenure, so it looks like his focus change was exactly what the majority of businesses and developers needed. The fact there's a handful of luddites that bemoan the decrease in usage of Win32 API is meaningless because you're such an irrelevance in the grand scheme of things- most people can deal with change and follow necessary trends, even if you cannot. That's not a problem with Ballmer or Microsoft, that's a problem with you. You can't blame Ballmer's capability for pursuing necessary change for your inability to change.

      People shifted to Java because it was a paradigm that gained a lot of hype in both business and academic circles and had a 6 year headstart on .NET and that happened well under Gates' reign not Ballmer's. Mis-steps such as VisualJ++ were the reason for that. By the time Gates stepped down as CEO, .NET hadn't even been released so Ballmer's tenure was the one that was responsible for taking all those devs lost during Gates' reign back because a combination of a far more competitive .NET, and Oracle's screwing of Java has helped grow the .NET community massively.

      "It's interesting to see how Nadella is shifting the focus again and broadening it (Windows 10 on Raspberry Pi, for example). Time will tell if Nadella is simply being an anti-Ballmer or if this glasnost is signs of a more fundamental shift in the way Microsoft does business. I hope it's the latter."

      It's neither. It's a continuation of the status quo, or did you completely miss

  2. Anticipating RMS response by krel · · Score: 2

    I anticipate Stallman may have a heart attack soon.

    --
    karma: ouch!
    1. Re:Anticipating RMS response by cb88 · · Score: 3, Insightful

      RMS... doesn't like LLVM either.

      http://developers.slashdot.org/story/15/02/08/210241/rms-objects-to-support-for-llvms-debugger-in-gnu-emacss-gudel

    2. Re: Anticipating RMS response by spongman · · Score: 1

      Rms won't sleep until gcc outputs gpl. (write that in bash)

  3. Hard to trust them by monkeyxpress · · Score: 1

    I would like to believe that Microsoft really has turned a new corner with this more open strategy but it really is hard. We had to put up with so much rubbish from them over the years with Windows. As someone getting into web development it is also just blatantly obvious they tried to sabotage the adoption of a common standard for a long as possible to prevent the web becoming a cross-platform environment (IE6 I am looking at you). And then there was the whole changing Office pointlessly every two years so you had to buy a faster computer and pay them more money.

    In the end I think they are just a business business. What I mean by that is they don't really subscribe to any ideology, vision or values other than just dominating at all cost. There is no rule that says they can't do that and plenty of other companies do, so I don't blame them, but in the end unless I start hearing from MS employees that there has been a wholesale change in culture I just think this openness stuff will only last until they get back to a dominate position again.

    Having said that they do make some good dev tools and I won't turn my back on them. Because in the end the best thing to keep all the big companies in line is to ensure that none of them can get into a entirely dominate position, even if they promise us they won't be evil...

    1. Re:Hard to trust them by Marginal+Coward · · Score: 1

      I would like to believe that Microsoft really has turned a new corner with this more open strategy but it really is hard.

      "Only Nixon could go to China." How can you ever improve relations with a former enemy if you don't begin to trust them? It takes a bit of a leap of faith, then trust can be built in small steps over a period of time. We see the same sort of thing happening recently with Obama and Raul Castro. They're both taking small steps forward.

      In Microsoft's case, we see them taking a series of small steps toward building credibility in the Open Source world. That won't happen instantly, and there are some folks for whom it will never happen (RMS and followers, you know who you are.) But every time Microsoft takes some small step in the right direction, I see folks here immediately wondering what they're really up to. In fact, last time this sort of thing came up here, someone even brought up the Trojan Horse analogy. Maybe - but probably not. I prefer the simpler explanation that Microsoft's realizes that their business interests have changed. In fact, they would be stupid not to.

      Regardless, the war with Microsoft can never end for those who are unable to trust them under any circumstances. Just as World War II will never end for a Japanese soldier who refuses to leave the jungle. And like World War II, Microsoft's Windows Monopoly was over long ago.

    2. Re:Hard to trust them by Dutch+Gun · · Score: 1

      Don't conflate "open source" with "good guys". There's nothing inherently bad about a business wanting their own products and platforms to succeed. You'd be a pretty lousy business if that wasn't your goal. It's the *methods* they use to achieve succeed which are the critical factor in that determination.

      It's clear they're serious about their open source strategy, but that's because it makes good business sense, not because they're suddenly embracing all things FOSS. It's just an acknowledgement that they're not the dominant player anywhere except on the desktop. Thus, they want to make it easy for developers using their tools to port code to Linux on servers, or Android and iOS for mobile, along with Windows on the desktop. If they didn't do that, Windows as a platform would appear increasingly isolated and irrelevant to a broader development strategy.

      So, don't misunderstand, this is just Microsoft working to improve their own products. Since MS themselves are now cross-platform developers, they need Visual Studio to have good cross-platform capabilities as well. Of course, this also benefits their developer customers who are doing cross-platform work as well. The fact that this is actually a benefit to other operating systems is likely completely irrelevant to them - it's just the reality of the current market.

      --
      Irony: Agile development has too much intertia to be abandoned now.
    3. Re:Hard to trust them by fisted · · Score: 1

      They're doing whatever they perceive to be most profitable. If they are assuming closed source is the way to go, then closed source it is. Who gets to decide that, ultimately? The shareholders. What are the shareholders' objectives? Hint: It starts with R and ends in OI

    4. Re:Hard to trust them by KingMotley · · Score: 1

      You could not exchange documents with someone with a 4 years older Office. And this simple feature, exchanging data, had to be enforced by legal pressure...

      Say what? Uh, no. Office has always allowed exchanging data to where ever, from where ever. I think you've drank too much of some funky cool aid. Word has always allowed saving to and from the 1997 version (.doc), or to other formats (.txt, .rtf, .xml, .xps, .wps), it also allows saving to .pdf, and the newer .docx format in both strict and non-strict. You could always access the document via COM/OLE as well, and read and manipulate it, and there were public hooks for writing your own code to read/write into whatever format you wanted (they called them filters). The only thing legal pressure did was force them to include the .odt format as well, which is odd, because usually the courts get mad at Microsoft bundling stuff in that could have always been done by a 3rd party, but in this case, it wanted to opposite.

      FIlters is how the older versions of word were given the capability long after release to be able to read newer version of the file format as well. For example, older versions word being able to read .docx, which came out after their release. PDF was also originally added this way as well.

    5. Re: Hard to trust them by spongman · · Score: 1
  4. I don't understand by Blaskowicz · · Score: 4, Interesting

    With LLVM using an intermediate representation of code (LLVM IR) and CLR another : MSIL, now called CIL, does that mean it goes C# -> LLVM bytecode -> .NET bytecode?, does the JIT does both steps at once, why doesn't that mean every single language with a LLVM target can now run on the CoreCLR?, was LLVM modified, was what's in my first question horribly wrong?

    1. Re:I don't understand by Anonymous Coward · · Score: 2, Informative
      Other direction; the C# -> .NET bytecode step happens elsewhere, this project handles the .NET bytecode -> LLVM bytecode part:

      LLILC is an Open-Source project that Compiles msIL (.NET) code to native binary, using the LLVM compiler framework. We pronounce it "lilac". The project will provide both a JIT ("Just-In-Time") and an AOT ("Ahead-Of-Time") compiler targeting CoreCLR.

      From the Background page of the linked wiki.

    2. Re:I don't understand by HyperQuantum · · Score: 4, Interesting

      I didn't look into the details of the project, but to me it seems to like the following:

      A JIT compiler is used in a virtual machine to run a function/method by compiling it from some sort of bytecode or intermediate representation to native code and then jumping to the generated code to execute it. So in this case this would be when the Common Language Runtime wants to run a CIL method for the first time: it generates LLVM intermediate representation from the CIL, then uses LLVM to compile that to native code.

      So it would be: CIL --> LLVM data --> native code

      This means that the CLR, and thus all code compiled for .NET, can run on all platforms that LLVM can generate native code for.

      --
      I am not really here right now.
    3. Re:I don't understand by complete+loony · · Score: 2

      C# -> MSIL / CIL (CLR) -> LLVM bitcode -> machine code.

      The summary is slightly misleading. Though they are working towards using LLVM, they currently have about 90% of their core JIT tests working with LLVM on windows x64, the rest fall back to their current JIT. So you won't be able to use this to run C# on linux / arm for a while yet.

      There's been quite a bit of recent development on JIT support in LLVM. They had an old JIT a few versions ago which had it's own machine code generation pipeline. This was replaced with MCJIT, that leveraged the same code generation pipeline as the AOT path. More recently there's an effort called ORC to build a more flexible API to better handle the use cases that various JIT writers typically wish to implement. Their existing MCJIT API will still exist but it will become just one example implementation of using this underlying API.

      While it is possible to implement garbage collection and exception handling in LLVM, these areas of the compiler could benefit from more improvement. Particularly in the area of compatibility with the native Microsoft stack.

      --
      09F91102 no, 455FE104 nope, F190A1E8 uh-uh, 7A5F8A09 that's not it, C87294CE no. Ah! 452F6E403CDF10714E41DFAA257D313F.
    4. Re:I don't understand by Blaskowicz · · Score: 1

      Or if you want to get evil, asm.js
      Then write a javascript interpreter in C# ..

    5. Re:I don't understand by godefroi · · Score: 1

      This is in support of CoreCLR, the version of .NET without any Windows dependencies (or that's the plan, anyway, they're not there yet, I don't think).

      --
      Karma: Poor (Mostly affected by lame karma-joke sigs)
  5. Make sense, actually by Dutch+Gun · · Score: 2

    I think it's important to understand that the .NET JIT compiler should probably be considered more part of the .NET *runtime*, not necessarily part of the development platform for .NET. Since they want to port .NET to non-Microsoft operating systems, it makes sense to utilize LLVM to target those platforms for the JIT compiler rather than trying to write a new one from scratch. They needed a solid compiler to accompany their open source .NET platform for it to be a more complete open-source solution. Moreover, they've been extending Visual C++'s support for alternative platforms like Android, so it also makes sense that they'd be gaining expertise with LLVM.

    It's probably not the end of their proprietary compiler, or even necessarily an indication they're thinking this way, but it may make more sense for them to utilize LLVM so as to target a larger number of platforms. They just recently rewrote their own .NET compiler a couple of years ago and released it as open source, so it's sort of odd to see a new project so soon. I'm guessing they figured it would be more work to extend that project to support all the platforms they're releasing CoreCLR for than using LLVM. Hard to say.

    Also, there's still the native compiler, used for C/C++, and they've been sinking an enormous amount of development resources into making it compliant with the recent advances in those languages, so it also seems unlikely they're going to toss that work.

    --
    Irony: Agile development has too much intertia to be abandoned now.
    1. Re:Make sense, actually by Anonymous Coward · · Score: 1

      I think you misundertand how .NET is split. The new .NET compiler (Roslyn) is actually a program to convert source code (C#, VB) into CIL (common intermediate language). It is the CIL that is contained in a .NET executable file, and the JIT compiler turns this IL code into machine code. The LLILC project is intended to use LLVM as the JIT, and to give you the ability to compile to machine code ahead of time (rather than at runtime).

      dom

    2. Re:Make sense, actually by Dutch+Gun · · Score: 1

      Ah, I see... ok, that makes a bit more sense then. So Roslyn is more or less the front end of the compiler tool chain, while LLVM is the back end, so to speak. Thanks for the clarification.

      --
      Irony: Agile development has too much intertia to be abandoned now.
    3. Re:Make sense, actually by shutdown+-p+now · · Score: 1

      I think that "by their proprietary compiler", he was referring to the JIT compiler.

  6. I think that the people at OpenCOBOL... by emil · · Score: 1

    ...would beg to differ, with this fact from the COBOL wiki:

    In 1997, Gartner Group estimated that there were a total of 200 billion lines of COBOL in existence which ran 80% of all business programs.

    I would bet you that COBOL environments have had 1/10th, and perhaps 1/100th of the security problems as systems based on C.

    1. Re: I think that the people at OpenCOBOL... by Anonymous Coward · · Score: 1

      How about 2009 then?

      https://cis.hfcc.edu/faq/cobol

    2. Re: I think that the people at OpenCOBOL... by Ravaldy · · Score: 1

      I would believe these numbers if they pertained to the financial sector but there's no way they account for 80% of the business code running today (in 1997-99, probably). If it's true then I wrote 1 / 2,000,000 of the business code in use.

      There was a huge shift towards web technologies in the early 2000. The % of market share for COBOL would have started to drop significantly within the last 10-15 years. One sign is the removal of COBOL courses in universities and colleges.

    3. Re:I think that the people at OpenCOBOL... by david_thornley · · Score: 1

      I'll agree with you: COBOL systems have much fewer security problems as C systems. This is because nobody used COBOL to do anything fancy. If you wrote a device driver or piece of web software in both COBOL and C, I'd expect a lot more security problems in the COBOL system. Writing a financial reporting program in C is going to give you a lot fewer security problems than something like SSL.

      --
      "When you have eliminated the unacceptable, whatever is left, however improbable, must be the truthiness" - Holmes
  7. Open source attempts by Roceh · · Score: 1

    There is a couple of open source projects doing this already: http://csnative.codeplex.com/ https://github.com/xen2/SharpL...

  8. Re:Few understand this by gbjbaanb · · Score: 1

    but nobody sensible develops .NET without Visual Studio. .NET is becoming true to its Java roots - write once (on a Windows box with Microsoft tools and you might as well use Outlook and Office too) run anywhere.

  9. So cancel GNUCobol then. by emil · · Score: 1

    Did you have directory delete permissions?

    http://savannah.gnu.org/projects/gnucobol

  10. Re: Few understand this by Redmancometh · · Score: 1

    Xamarin is actually a VERY nice visual studio alternative. Not just for mobile either..

  11. COBOL has slumped to 12% as of 2011 by emil · · Score: 1

    Still nothing to sneeze at.

    "Java and C# .Net are now the languages of choice in the projects that the ISBSG receives. COBOL has slumped to 12% (it used to be 38%) and Visual Basic has dropped back to 5% after peaking at 15%."

    1. Re:COBOL has slumped to 12% as of 2011 by Ravaldy · · Score: 1

      The fact is that COBOL is in decline. It isn't used for new projects and most projects are probably in maintenance mode (that's me speculating based on people I know who work for financial institutions). Maybe nothing to sneeze at BUT I wouldn't pick COBOL for a new project..

  12. Re:I didn't get the memo by JcMorin · · Score: 1

    I see new versions, libraries and more commitment to .NET everywhere... I didn't get the memo they were dropping it.

  13. Re:Odd MS patched it today then, eh? Not... apk by theskipper · · Score: 1

    The IP of the MS update server must have been set to 0.0.0.0 in his hosts file. Mystery solved.

  14. Re:Or perhaps MS wants out of the language biz by KingMotley · · Score: 1

    Dead ending VB6? Are you kidding? They had been saying that it was being phased out before VB6 was released. It's been dead for 17 years now. Give it a rest already. VB6 SUCKED.

  15. Re:I didn't get the memo by KingMotley · · Score: 1

    Don't believe what Anonymous Cowards say. They are typically clueless. The next version of .NET should be released in the next 1-6 months (I'm guessing around 4).

  16. This makes a LOT of sense for Microsoft by jonwil · · Score: 2

    Right now Microsoft has a JIT compiler running on a few platforms that translates .NET byte code into native code. Instead of reinventing the wheel and writing their own JIT compiler for a bunch other platforms they want to be able to run .NET code on, they are instead using something that already exists in the form of LLVM.

    They aren't abandoning anything, just using LLVM instead of rolling their own JIT compiler on certain platforms where doing so makes sense.

  17. Re:EEE by shutdown+-p+now · · Score: 1

    Where do you see "their version of LLVM" here anywhere?

  18. Re: Or perhaps MS wants out of the language biz by spongman · · Score: 1

    Tell that to the office team. When we get C# as the embedded language in office, maybe then VB can die. For now, it lives on like a zombie dragged, toothless, by an ex-lover through the programming landscape by its old OLE apis.

  19. Re: Holy acronyms Batman! by spongman · · Score: 1

    You're not. This is a tech website. Click the link near the box where you typed 'Google.com' marked 'Martha Stewart'

  20. Re:Few understand this by LordLimecat · · Score: 1

    Im not arguing whether SecureBoot is good or bad, but you're making several false technical statements and Im not a big fan of arguments premised on BS.

    Bootsector malware is (or was) exceedingly common on Windows XP and 7, to the point where I was regularly using tools like aswMBR and GMER to remove it. Thats why there are so many tools to detect it-- it was quite common. Sinowal, TDSS, Whistler, and several other rootkits infect the boot sector.

    In any case Microsoft is not forcing OEMs to do anything. This is about a set of requirements that were given to get a Windows certification; one of them for Windows 8 was that OEMs were REQUIRED to allow other OSes to be installed. That requirement has been removed, which could have any of a number of rationale-- it is possible its for "lockin" reasons, but there are other valid reasons too, such as the rise of locked-down single-OS tablets. Microsoft continuing to have their "other OS" requirement could arguably alienate those OEMs, so they removed that requirement from their certification.

    You have an obvious issue with Microsoft as a whole, but thats not a valid techical argument against a specific one of their technologies. Secureboot IMO has a lot of baggage, but it has the very real benefit that it can defeat a number of very real and very common rootkits like TDL3/4 which have historically been nightmarish to deal with.