Thursday, November 13, 2014

Visual Studio Community 2013 (www.visualstudio.com)

Who can use 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 > $1MM in annual revenue), no use is permitted beyond the open source, academic research, and classroom learning environment scenarios described above.
How does Visual Studio Community 2013 compare to other Visual Studio editions?
  • Visual Studio Community 2013 includes all the great functionality of Visual Studio Professional 2013, designed and optimized for individual developers, students, open source contributors, and small teams.

Microsoft Open Sources .NET and Mono under MIT (tirania.org/blog/)

Today, Scott Guthrie announced that Microsoft is open sourcing .NET. This is a momentous occasion, and one that I have advocated for many years. .NET is being open sourced under the MIT license. Not only is the code being released under this very permissive license, but Microsoft is providing a patent promise to ensure that .NET will get the adoption it deserves. The code is being hosted at the .NET Foundation's github repository. This patent promise addresses the historical concerns that the open source, Unix and free software communities have raised over the years. Read more.

Friday, July 18, 2014

SlackBlogs: Slackware is 21 Years Old

SlackBlogs: Slackware is 21 Years Old: On July 16 1993, Patrick Volkerding announced the availability of Slackware 1.00 on comp.os.linux usenet and since then, Slackware has beco...

Tuesday, May 13, 2014

Introducing ASP.NET vNext (hanselman.com/blog/)

There’s some really cool stuff going on on the ASP.NET and Web Tools team. We’ve been pushing stuff at Microsoft for a few years now and our craziness is spreading to the .NET core team and beyond. Today we’re announcing a preview (read: alpha) of the next generation of .NET on the Server. You may have heard about some of these announcements at Build:

  • .NET Native - compile .NET ahead-of-time. Everything gets faster.
  • .NET Compiler Platform ("Roslyn") - All new C# and VB compilers, new language features, compiler-as-a-service and it’s Open Source.
  • Nextgen JIT - All new optimized JITter for the latest processors
ASP.NET vNext will take things to the next level. Today, you run ASP.NET using the same CLR that desktop apps use. We’re adding a cloud-optimized (my cloud, your cloud, their cloud - server stuff) version optimized for server scenarios like low-memory and high-throughput. Read more...

Friday, April 18, 2014

Why The Clock is Ticking for MongoDB (rhaas.blogspot.com.br)

Last month, ZDNet published an interview with MongoDB CEO Max Schireson which took the position that the document databases, such as MongoDB, are better-suited to today's applications than traditional relational databases; the title of the article implies that the days of relational databases are numbered. But it is not, as Schireson would have us believe, that the relational database community is ignorant of or has not tried the design paradigms which he advocates, but that they have been tried and found, in many cases, to be anti-patterns. Certainly, there are some cases in which the schemaless design pattern that is perhaps MongoDB's most distinctive feature is just the right tool for the job, but it is also misleading to think that such designs must use a document store. Relational databases can also handle such workloads, and their capabilities in this area are improving rapidly. Read more...

Thursday, April 10, 2014

Mono and Roslyn (tirania.org)

Last week, Microsoft open sourced Roslyn, the .NET Compiler Platform for C# and VB. Roslyn is an effort to create a new generation of compilers written in managed code. In addition to the standard batch compiler, it contains a compiler API that can be used by all kinds of tools that want to understand and manipulate C# source code. Roslyn is the foundation that powers the new smarts in Visual Studio and can also be used for static analysis, code refactoring or even to smartly navigate your source code. It is a great foundation that tool developers will be able to build on. I had the honor of sharing the stage with Anders Hejlsberg when he published the source code, and showed both Roslyn working on a Mac with Mono, as well as showing the very same patch that he demoed on stage running on Mono. Read more...

Saturday, April 5, 2014

Quote of The Day (2014-04-04)

There is no passion to be found playing small - in settling for a life that is less than the one you are capable of living.

-Nelson Mandela

Friday, April 4, 2014

Rust 0.10 Released (mail.mozilla.org)

Mozilla and the Rust community are pleased to announce version 0.10 of the Rust compiler and tools. Rust is a systems programming language with a focus on safety, performance and concurrency. This was an exciting release cycle where we broke apart the libextra library, introduced cross-crate syntax extensions and macros, improved the smart pointer experience with the Deref trait, and improved error handling in I/O. Outside of the compiler, this release has seen the introduction of a new RFC process as well as support for nightly binary installers. Read more...

Thursday, April 3, 2014

Welcome to the .NET Compiler Platform: Roslyn (roslyn.codeplex.com)

The .NET Compiler Platform ("Roslyn") provides open-source C# and Visual Basic compilers with rich code analysis APIs. You can build code analysis tools with the same APIs that Microsoft is using to implement Visual Studio! Read more.

Monday, March 31, 2014

Firefox: Generational GC has landed (blog.mozilla.org)

Big news: late last week, generational garbage collection landed. It was backed out at first due to some test failures, but then re-landed and appears to have stuck. This helps with performance. There are certain workloads where generational GC makes the code run much faster, and Firefox hasn’t been able to keep up with Chrome on these. For example, it has made Firefox slightly faster on the Octane benchmark, and there is apparently quite a bit of headroom for additional improvements. Read more...

Thursday, March 20, 2014

Green threads are just threads (glyph.twistedmatrix.com)

Be as the reed, not the oak tree. Green threads are just threads.

    … that which is hard and stiff
    is the follower of death
    that which is soft and yielding
    is the follower of life …

    – the Tao Te Ching, chapter 76

As we know, threads are a bad idea, (for most purposes). Threads make local reasoning difficult, and local reasoning is perhaps the most important thing in software development. With the word “threads”, I am referring to shared-state multithreading, despite the fact that there are languages, like Erlang and Haskell which refer to concurrent processes – those which do not implicitly share state, and require explicit coordination – as “threads”. My experience is mainly (although not exclusively) with Python but the ideas presented here should generalize to most languages which have global shared mutable state by default, which is to say, quite a lot of them: C (including Original Recipe, Sharp, Extra Crispy, Objective, and Plus Plus), JavaScript, Java, Scheme, Ruby, and PHP, just to name a few. With the phrase “local reasoning”, I’m referring to the ability to understand the behavior (and thereby, the correctness) of a routine by examining the routine itself rather than examining the entire system. Read more

Wednesday, March 5, 2014

Critical crypto bug leaves Linux, hundreds of apps open to eavesdropping (arstechnica.com)

Hundreds of open source packages, including the Red Hat, Ubuntu, and Debian distributions of Linux, are susceptible to attacks that circumvent the most widely used technology to prevent eavesdropping on the Internet, thanks to an extremely critical vulnerability in a widely used cryptographic code library. The bug in the GnuTLS library makes it trivial for attackers to bypass secure sockets layer (SSL) and Transport Layer Security (TLS) protections available on websites that depend on the open source package. Initial estimates included in Internet discussions such as this one indicate that more than 200 different operating systems or applications rely on GnuTLS to implement crucial SSL and TLS operations, but it wouldn't be surprising if the actual number is much higher. Web applications, e-mail programs, and other code that use the library are vulnerable to exploits that allow attackers monitoring connections to silently decode encrypted traffic passing between end users and servers. Read more...

Friday, February 28, 2014

Keep fun in computing (Structure and Interpretation of Computer Programs)

``I think that it's extraordinarily important that we in computer science keep fun in computing. When it started out, it was an awful lot of fun. Of course, the paying customers got shafted every now and then, and after a while we began to take their complaints seriously. We began to feel as if we really were responsible for the successful, error-free perfect use of these machines. I don't think we are. I think we're responsible for stretching them, setting them off in new directions, and keeping fun in the house. I hope the field of computer science never loses its sense of fun. Above all, I hope we don't become missionaries. Don't feel as if you're Bible salesmen. The world has too many of those already. What you know about computing other people will learn. Don't feel as if the key to successful computing is only in your hands. What's in your hands, I think and hope, is intelligence: the ability to see the machine as more than when you were first led up to it, that you can make it more.''

-- Alan J. Perlis (April 1, 1922-February 7, 1990)

Structure and Interpretation of Computer Programs

Thursday, February 27, 2014

Mono 3.2.7 is out! (news.mono-project.com)

After 5 months in development, mono 3.2.7 is out. This is the work of 1235 commits by 65 contributors. A lot of very exciting new things come with this release. The highlights are all the love our JIT received. A much improved ABCREM pass that now can remove a lot more bounds check on 64bits architectures. We added Alias Analysis and Loop Invariant Code Motion that allows even better code to be generated. Performance under some benchmarks was improved by more than 20%. Read more...

GitHub's new text editor Atom (atom.io)

At GitHub, we're building the text editor we've always wanted. A tool you can customize to do anything, but also use productively on the first day without ever touching a config file. Atom is modern, approachable, and hackable to the core. We can't wait to see what you build with it. Read more...

Wednesday, February 26, 2014

Apple's SSL/TLS bug [22 Feb 2014] (imperialviolet.org)

Yesterday, Apple pushed a rather spooky security update for iOS that suggested that something was horribly wrong with SSL/TLS in iOS but gave no details. Since the answer is at the top of the Hacker News thread, I guess the cat's out of the bag already and we're into the misinformation-quashing stage now. So here's the Apple bug: Read more...

Tuesday, February 25, 2014

Announcing the new Roslyn-powered .NET Framework Reference Source (hanselman.com)

In 2007 ScottGu's team announced they were releasing the .NET Framework source code for reference. Just a little later, Microsoft made it possible to step through the .NET Framework Source code while debugging. This was announced to much fanfare, and for a while, it was very cool. It wasn't "Open Source" but it's definitely "Source Opened." However, as time passed, the original Reference Source website for the .NET Framework sucked for a number of reasons, mostly because it wasn't updated often enough. Fast forward to today...we're back and the .NET team is launching the fresh new and updated .NET Reference Source site with a Roslyn-powered index! Read more...

Friday, February 21, 2014

Things That Make Google F1 and the FoundationDB SQL Layer So Strikingly Similar (foundationdb.com)

The Google F1 database paper just became generally available. It’s the database that runs AdWords, so I suspect Google kind of cares about it. Google F1 bears an amazing resemblance to our FoundationDB SQL layer. Both leverage an underlying scalable and transactional storage substrate to allow unprecedented scalability at both the storage and SQL processing levels. Both leverage hierarchical schemas, arranging tables into a hierarchy that is mirrored in storage by interleaving rows of parents with rows of children. Both systems make the tradeoff that higher latency is acceptable for gaining almost unlimited bandwidth and scale. A query may require more round-trips and take a (bounded) longer time, but the overall throughput of the system, measured in number of queries that can run in parallel, is much higher.

The fact that Google has built and is using F1 for their AdWords business demonstrates how the architectural approach works for even the most demanding of applications. However, F1 is only available to Google’s internal teams, while our open-source FoundationDB SQL Layer is intended to have a somewhat broader audience. Read more...

Friday, February 14, 2014

CSS source map support, network performance analysis & more – Firefox Developer Tools Episode 29 (hacks.mozilla.org)

Firefox 29 was just uplifted to the Aurora release channel. This means that it is time to report some of the major changes that you can expect to see inside of the Developer Tools for this release. Read more.

Thursday, February 6, 2014

Managing Node.js Callback Hell with Promises, Generators and Other Approaches (strongloop.com)

Callback hell is subjective, as heavily nested code can be perfectly fine sometimes. Asynchronous code is hellish when it becomes overly complex to manage the flow. A good question to see how much “hell” you are in is: how much refactoring pain would I endure if doAsync2 happened before doAsync1? The goal isn’t about removing levels of indentation but rather writing modular (and testable!) code that is easy to reason about and resilient. In this article, we will write a module using a number of tools and libraries to show how control flow can work. We’ll even look at an up and coming solution made possible by the next version of Node. Read more.

Monday, February 3, 2014

Linux 3.4+: arbitrary write with CONFIG_X86_X32 [CVE-2014-0038] (seclists.org)

Bug:
----
The X86_X32 recvmmsg syscall does not properly sanitize the timeout pointer
passed from userspace.

Exploit primitive:
------------------
Pass a pointer to a kernel address as timeout for recvmmsg,
if the original byte at that address is known it can be overwritten
with known data.
If the least significant byte is 0xff, waiting 255 seconds will turn it into a 0x00.

Restrictions:
-------------
The first long at the passed address (tv_sec) has to be positive
and the second long (tv_nsec) has to be smaller than 1000000000.

Overview:
---------
Target the release function pointer of the ptmx_fops structure located in
non initialized (and thus writable) kernel memory. Zero out the three most
significant bytes and thus turn it into a pointer to an address mappable in
user space.
The release pointer is used as it is followed by 16 0x00 bytes (so the tv_nsec
is valid).
Open /dev/ptmx, close it and enjoy.

Not very beautiful but should be fairly reliable if symbols can be resolved.

Tested on Ubuntu 13.10

Read here more. Here is an example code.

Examining Postgres 9.4 - A first look (craigkerstiens.com)

PostgreSQL is currently entering its final commit fest. While its still going, which means there could still be more great features to come, we can start to take a look at what you can expect from it now. This release seems to bring a lot of minor increments versus some bigger highlights of previous ones. At the same time there’s still a lot on the bubble that may or may not make it which could entirely change the shape of this one. Read more

A re-introduction to JavaScript [JS Tutorial 2006] (developer.mozilla.org)

Why a re-introduction? Because JavaScript has a reasonable claim to being the world's most misunderstood programming language. While often derided as a toy, beneath its deceptive simplicity lie some powerful language features. 2005 saw the launch of a number of high-profile JavaScript applications, showing that deeper knowledge of this technology is an important skill for any web developer. Read more...

Friday, January 31, 2014

You might not need jQuery (youmightnotneedjquery.com)

jQuery and its cousins are great, and by all means use them if it makes it easier to develop your application. If you're developing a library on the other hand, please take a moment to consider if you actually need jQuery as a dependency. Maybe you can include a few lines of utility code, and forgo the requirement. If you're only targeting more modern browsers, you might not need anything more than what the browser ships with. At the very least, make sure you know what jQuery is doing for you, and what it's not. Some developers believe that jQuery is protecting us from a great demon of browser incompatibility when, in truth, post-IE8, browsers are pretty easy to deal with on their own. Read more...

Thursday, January 30, 2014

Ruby 2.1: Out-of-Band GC (tmm1.net)

Ruby 2.1's GC is better than ever, but ruby still uses a stop-the-world GC implementation. This means collections triggered during request processing will add latency to your response time. One way to mitigate this is by running GC in-between requests, i.e. "Out-of-Band". Read more.

Wednesday, January 29, 2014

The Descent to C (chiark.greenend.org.uk/~sgtatham/)

This article attempts to give a sort of ‘orientation tour’ for people whose previous programming background is in high (ish) level languages such as Java or Python, and who now find that they need or want to learn C. C is quite different, at a fundamental level, from languages like Java and Python. However, well-known books on C (such as the venerable Kernighan & Ritchie) tend to have been written before Java and Python changed everyone's expectations of a programming language, so they might well not stop to explain the fundamental differences in outlook before getting into the nitty-gritty language details. Someone with experience of higher-level languages might therefore suffer a certain amount of culture shock when picking up such a book. My aim is to help prevent that, by warning about the culture shocks in advance. This article will not actually teach C: I'll show the occasional code snippet for illustration and explain as much as I need to make my points, but I won't explain the language syntax or semantics in any complete or organised way. Instead, my aim is to give an idea of how you should expect C to differ from languages you previously knew about, so that when you do pick up an actual C book, you won't be distracted from the details by the fundamental weirdness. I'm mostly aiming this article at people who are learning C in order to work with existing C programs. So I'll discuss ways in which things are commonly done, and things you're likely to encounter in real-world code, but not things that are theoretically possible but rare. (I do have other articles describing some of those.) Read more...

Thursday, January 23, 2014

We spent a week making Trello boards load extremely fast. Here’s how we did it. (blog.fogcreek.com)

We made a promise with Trello: you can see your entire project in a single glance. That means we can show you all of your cards so you can easily see things like who is doing what, where a task is in the process, and so forth, just by scrolling. You all make lots of cards. But when the site went to load all of your hundreds and thousands of cards at once, boards were loading pretty slow. Okay, not just pretty slow, painfully slow. If you had a thousand or so cards, it would take seven to eight seconds to completely render. In that time, the browser was totally locked up. You couldn’t click anything. You couldn’t scroll. You just had to sit there.

So I set out on a mission: using a 906 card board on a 1400×1000 pixel window, I wanted to improve board rendering performance by 10% every day for a week. It was bold. It was crazy. Somebody might have said it was impossible. But I proved that theoretical person wrong. We more than achieved that goal. We got perceived rendering time for our big board down to one second. Naturally, I kept track of my daily progress and implementation details in Trello. Here’s the log. Read more...

Wednesday, January 22, 2014

Entity Framework 6 vs NHibernate 4 (devbridge.com)

This article is dedicated to discussing the latest releases of the NHibernate and Entity Framework. NHibernate is (was?) a number one ORM Framework for ages. Its feature list is growing and some things such as code-based mappings and automatic migrations have found a place in Entity Framework. Moreover, it is now open-source, so they are now accepting pull requests as well. Read more

Wednesday, January 8, 2014

Do We Live in the Matrix? (discovermagazine.com)

In the 1999 sci-fi film classic The Matrix, the protagonist, Neo, is stunned to see people defying the laws of physics, running up walls and vanishing suddenly. These superhuman violations of the rules of the universe are possible because, unbeknownst to him, Neo’s consciousness is embedded in the Matrix, a virtual-reality simulation created by sentient machines.

The action really begins when Neo is given a fateful choice: Take the blue pill and return to his oblivious, virtual existence, or take the red pill to learn the truth about the Matrix and find out “how deep the rabbit hole goes.”

Physicists can now offer us the same choice, the ability to test whether we live in our own virtual Matrix, by studying radiation from space. As fanciful as it sounds, some philosophers have long argued that we’re actually more likely to be artificial intelligences trapped in a fake universe than we are organic minds in the “real” one. Read more...