Group items matching

in title, tags, annotations or url

There's much excitement about JDK 7 and in particular Lambdas! I've waded through the bloat to help you get an understanding of it. If you search for JDK 7 in your favourite search engine the chances are you'll hit the controversies surrounding lambadas in Java fairly early on in your hunt. It's a contentious subject, which means it's getting a lot of attention from a lot of clever people, but this in turn makes the process slow and adds difficulty in making decisions. My take is that lambdas will be in JDK 7 - you can see plenty of evidence of that around the web and in the snapshot builds. That said, no decision is concrete (which is a wise tip from The Pragmatic Programmer no less!). This article is aimed at those who don't know much about functional programming or what Lambdas, Closures or Currying are and want to get 'primed'.

Just finishing off the chapter on bit syntax and pattern matching over bit strings for our Erlang book. We wanted to put in a realistic example, and chose a TCP segment as described  here. It's amazing how expressive the notation can be, and we get a definition which pretty much mirrors the diagram and explanation in the link above: nothing like doing it for yourself to convince you that it works.

The R programming language was featured about a year ago in a New York Times article (http://bit.ly/iaqQ). I've been an R user since 2000, so I've collected some resources for people who want to get started with R.   The first place to start is the R Project web site at http://www.r-project.org/. Next, you'll actually want to install R itself. There are several options, depending on your environment.

In short, Joe argues, "Throughout, it became abundantly clear that TM, much like generics, was a systemic and platform-wide technology shift. It didn’t require type theory, but the road ahead sure wasn’t going to be easy." The whole blog post deals with how many implementation challenges platform-wide support for STM would be in .NET, including what options were considered. He does not mention Maurice Herlihy's SXM library approach, but refers to Tim Harris's work several times.

First, right off the top here: Scala has true blue Java-like null; any reference may be null. Its presence muddies the water quite a bit. But since Beust's article explicitly talks about Haskell he's clearly not talking about that aspect of Scala because Haskell doesn't have null. I'll get back to Scala's null at the end but for now pretend it doesn't exist.Second, just to set the record straight: "Option" has roots in programming languages as far back as ML. Both Haskell's "Maybe" and Scala's "Option" (and F#'s "Option" and others) trace their ancestry to it.

In this session, Don McCrady discusses how C++ programmers can fully utilize multicore in their applications using the Concurrency Runtime (ConcRT), the Parallel Pattern Library (PPL), and the Asynchronous Agents Library that ship with Visual Studio 2010.

When a data (typically a variable) can be accessed by several threads, you must synchronize the access to the data to ensure visibility and correctness.

If you need a quick reference guide for the UML notation, check one of the following, IMHO, gret UML cheat sheets (in no particular order):

Dave Megginson (who drove the development of the SAX API that will be familiar to many XML developers who use Java) recently wrote Java is dead. Java stood out as a programming language (though not as a platform) in that Sun had refused to standardize it through an independent and reputable standards organization (a lot of the hard work had been done in one attempt to put it through ECMA and one to put it through ISO, both times Sun pulled out and eventually made their highly unsatisfactory JCP Java Community Process system.) Without the ability to alter Java significantly in ways that might go against their druthers, Java suffered two major forks (Microsoft's J++ then its C#, and IBM's SWT) where significant players disagreed with a major component (the graphics library). Java succeeded in middleware, and but failed to take advantage of the rise of browsers on the deskop: their HTML parser was great for the middle 1990s but was deliberately neglected to the point of being unusable: it is hard not to see this as a deliberate attempt by Sun to leave the browser market to its friends and enemies. I really liked Java, and bet my company on it (in a sense): I would not do that today.

As many long time readers know, I am an enthusiast of the F# programming language.  I make no apologies for the fact that, if you are developing software on the .NET platform, F# is one of the better choices you can make for numerous reasons.  It is one of the reasons I proudly contributed as a co-author to the book, Professional F# 2.0, which is being published by Wrox in October. Some of the oft cited benefits of F# are that, to distill them quickly, it is good at doing intensely mathematical operations, it is built for parallelism, and it is good at helping define domain specific languages.  Those benefits are so often cited by speakers on the F# speaker circuit that they pretty much seem cliche to me at this point (note, yours truly is proud to call himself a member of said circuit, and often gives this talk!)  As great as these features are, there are a couple features, that in my more mundane F# experiences, seem to stand out as things that “save my ass”, for lack of a better phrase, more often than not.

The latest episode of the Robots Podcast looks at the following scenario: Imagine being able to throw a hand-full of smart matter in a tank full of liquid and then pulling out a ready-to-use wrench once the matter has assembled. This is the vision of this episode's guests Michael Tolley and Jonas Neubert from the Computational Synthesis Laboratory run by Hod Lipson at Cornell University, NY. Tolley and Neubert give an introduction into Programmable Matter and then present their research on stochastic assembly of matter in fluid, including both simulation (see video above) and real-world implementation. Read on or tune in!

scala> val ONE_DAY = 24 * 60 * 60 * 1000 ONE_DAY: Int = 86400000 scala> var manyDays: Long = ONE_DAY * 10000 manyDays: Long = 711573504 scala> var manyDays: Long = ONE_DAY * 10000L manyDays: Long = 864000000000 scala> ONE_DAY * 10000 res1: Int = 711573504

Microsoft Technical Fellow and C# creator Anders Hejlsberg explains the new C# and VB.NET asynchronous programming model, available as Async CTP now, which makes async programming much easier for .NET developers.

One of the common discussions that I've had with several colleagues when we're making use of some of the higher order functions that can be applied on collections is whether to use the LINQ style syntax or to chain the different methods together. I tend to prefer the latter approach although when asked the question after my talk at Developer Developer Developer I didn't really have a good answer other than to suggest that it seemed to just be a personal preference thing. Damian Marshall suggested that he preferred the method chaining approach because it more clearly describes the idea of passing a collection through a pipeline where we can apply different operations to that collection.

In functional programming, monadic characterizations of computational effects are normally understood denotationally: they describe how an effectful program can be systematically expanded or translated into a larger, pure program, which can then be evaluated according to an effect-free semantics. Any effect-specific operations expressible in the monad are also given purely functional definitions, but these definitions are only directly executable in the context of an already translated program. This approach thus takes an inherently Church-style view of effects: the nominal meaning of every effectful term in the program depends crucially on its type. We present here a complementary, operational view of monadic effects, in which an effect definition directly induces an imperative behavior of the new operations expressible in the monad. This behavior is formalized as additional operational rules for only the new constructs; it does not require any structural changes to the evaluation judgment. Specifically, we give a small-step operational semantics of a prototypical functional language supporting programmer-definable, layered effects, and show how this semantics naturally supports reasoning by familiar syntactic techniques, such as showing soundness of a Curry-style effect-type system by the progress+preservation method.

In this interview made by InfoQ’s Sadek Drobi, Don Syme, a Senior Researcher at Microsoft Research, answers questions mostly on F#, but also on functional programming, C# generics, type classes in Haskell, similarities between F# and Scala.

Flare is an ActionScript library for creating visualizations that run in the Adobe Flash Player. From basic charts and graphs to complex interactive graphics, the toolkit supports data management, visual encoding, animation, and interaction techniques. Even better, flare features a modular design that lets developers create customized visualization techniques without having to reinvent the wheel. View the demos and sample applications to see a few of the visualizations that flare makes it easy to build. To begin making your own visualizations, download flare and work through the tutorial. You should also get familiar with the API documentation. Need more help? Visit the help forum (you'll need a SourceForge login to post). Flare is open-source software released under a BSD license, meaning it can be freely deployed and modified (and even sold for $$). Flare's design was adapted from its predecessor prefuse, a visualization toolkit for Java

The Control Gallery is a directory of over 900 controls and components to use in your own applications. You will find everything from simple controls to full e-commerce components.

We describe a practical method for reasoning about realistic concurrent programs. Our method allows global two-state invariants that restrict update of shared state. We provide simple, sufficient conditions for checking those global invariants modularly. The method has been implemented in VCC, an automatic, sound, modular verifier for concurrent C programs. VCC has been used to verify functional correctness of tens of thousands of lines of Microsoft's Hyper-V virtualization platform and of SYSGO's embedded real-time operating system PikeOS.