Group items tagged

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.

While on campus for the MVP Summit in February, I had a chance to visit Henry Sowizral over in building 41. Henry Sowizral is a Principal Architect in Microsoft Expression, and he and his team did something really cool: they converted an existing C/C++/MFC application to have a WPF front-end, while still leveraging all that existing code. If you have legacy code and are considering porting the UI to .NET, pick up some pointers from Henry. Once you've finished, check out Henry's presentation deck on how the team converted the Expression Design UI to WPF. See more WPF at Pete's site and blog http://10rem.net Follow Pete on twitter at @pete_brown

In order to test and run benchmarks on the work I'm doing around creating a managed variant of the JSR-166y ForkJoinPool along with supporting infrastructure for use with Scala Actors, I'm creating a test harness that captures a host of environmental factors about how it was run, and writing sbt actions to make it easy to run the benchmarks and automatically permute the variables.

In Stack Machines, Expression Evaluation, and the Magic of Reverse Polish, I showed how expressions can be evaluated by rewriting them in reverse Polish and translating this into machine-code instructions for a stack machine. I demonstrated with a stack-machine interpreter that I'd written as part of a working model of a Pascal compiler. But as well as expressions, the compiler needs to compile assignments and jumps, so — in my progress towards explaining the compiler — I'm going to extend the machine code so it can handle these. I'll demonstrate by interpreting a program that calculates five factorial.

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.

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.

As promised in the previous post, let’s continue with Grails support in  IntelliJ IDEA 8. Today we’ll see how the powerful IntelliJ IDEA‘s code completion applies to the Grails applications.

Asynchronous work flows are a very powerful tool in programming. They allow your threads to do other work while you wait for results from a long running piece of work. How would you write an asynchronous work flow in C#? Logically you might consider chaining together callbacks.

Dr. Cormac Herley spends most of his time thinking about why and how computer users reject security advice (originating from both fellow humans and software security warning prompts). Recently, his paper So Long, and No Thanks for the Externalities: the Rational Rejection of Security Advice by Users, received a fair amount of attention from the general media (Boston Globe, Tech Republic, NPR, etc). The paper also prompted our favorite software renegade, Dr. Erik Meijer, to send me an email simply asking "please set up and E2E with Cormac Herley". I did just that and the following conversation is what happened...