A blog for developers programming with Autodesk platforms, particularly AutoCAD and Forge. With a special focus on AR/VR and IoT.

18 posts categorized "Concurrent programming"

October 15, 2013

Despite the fact we can’t currently use it inside AutoCAD – we’re still using .NET 4.0 in AutoCAD 2014 – of late I’ve been working more with the async/await capability in .NET 4.5, which has been really interesting. I’ve worked with asynchronous operations in .NET languages on and off for some time, having started with F#’s Asynchronous Workflows and then spent some time with C#’s async/await after hearing Stephen Toub speak at Microsoft Switzerland a couple of years ago. It feels like it’s been a while since I did much of that, though: I used the Async CTP sporadically...
Read more →

October 04, 2013

I’ve been looking for an interesting problem to solve using MapReduce for some time now. I’ve been curious about the paradigm and how it can be applied to churn through large sets of data across multiple processing cores: something that’s especially relevant as we need to distribute processing – whether to cores that are local or up in the cloud – in order to improve software performance. I talked about much of this when I looked at F#’s Asynchronous Workflows way back when (nearly 6 years ago – ouch). MapReduce frameworks – and there are a number out there:...
Read more →

September 30, 2013

As promised, I’m going to spend some time this week looking at options for moving the Python code we’ve seen in this series of posts – that de-skews perspective images using CPython or IronPython code running on your desktop – to “the cloud”. Which in this case I’m taking to mean Google App Engine (GAE), as it has native Python support and I hadn’t done anything with it, before. :-) As a first step – and I should probably say “at first glance” – it’s really quite easy to take some existing Python code and host it behind a...
Read more →

March 19, 2012

As promised in my last post, I spent some time hacking together a basic application to get a feel for what it’s like to develop inside the WinRT sandbox for Windows 8. If you’re interested in the source code, here it is. Be warned: the code is really just to prove a concept – there’s a lot therein I’d consider sub-optimal for a production application. If you’re more interested in seeing the application in action, but haven’t yet installed the Windows 8 Consumer Preview, then here’s a quick screencast I recorded: A few comments on the experience of developing...
Read more →

February 27, 2012

In the first of this week’s posts on the new, developer-oriented features in AutoCAD 2013, we’re going to take a look at the AutoCAD Core Console. I predict that this one feature alone is going to be worth its weight in gold to many customers and developers. Picture this: a stripped down version of AutoCAD – but only from a UI perspective – that can be executed from a standard Command Prompt. We’re talking about a version with almost all the capabilities of full AutoCAD – with the ability to load certain applications and execute scripts – but launches...
Read more →

February 20, 2012

This post continues the series on fill algorithms for 3D printing by looking specifically at an Apollonian sphere packing. In the last post we got most of the way there, but today we’re going to introduce a more elegant algorithm for solving the problem (with pretty impressive results :-). Many thanks to Professor Ronald Peikert from ETH Zurich for kindly providing the C++ code used to generate the F# code in today’s post. The original algorithm was outlined in this paper co-authored by Professor Peikert, under the section The “Inversion Algorithm” and – as you might divine from the...
Read more →

June 27, 2011

I’ve been planning to look at it for ages – and have certainly mentioned it before – but other things have kept on cropping up. Well last Thursday, on my train trip back from Wallisellen (the home of Microsoft Switzerland), I finally managed to take the plunge and start working with the Async CTP for Visual Studio 2010. I’d been in Wallisellen to attend an MSDN TechTalk presentation by Stephen Toub, Principal Architect on Microsoft’s Parallel Computing Platform team. I’ve followed Stephen via his blog – and the Parallel Programming with .NET blog – for a long time, and...
Read more →

November 22, 2010

Or perhaps the title should really be “why it’s really a good idea to avoid misusing mutable state when using F# Asynchronous Workflows”. Ultimately I wanted to share a brief (or not, we’ll see), cautionary tale about the dangers of shared state when implementing concurrent tasks. I’ve been using F# for some time, and have it fairly well drilled into my skull by this point that shared, mutable state is bad. And yet occasionally it somehow creeps in as an expedient way to solve certain issues: perhaps it’s just a lack of discipline on my part or the years...
Read more →

April 30, 2010

In the previous posts in this series we introduced a command that downloaded and imported point clouds from Photosynth.net, we introduced a WinForms user interface on top of it and then replaced that UI with one implemented using WPF. As threatened last time, we’re now going to make some efficiency improvements in the original command implementation. In our previous implementation we were blindly asking for files, one after the other, and using failure to indicate when we’d reached the end. Which was fine, but it limited us in a few ways: we could not reliably parallelize this otherwise highly...
Read more →

December 07, 2009

I’ve now crossed the international date line (giving up a big portion of my weekend, but that’s life) and landed in Tokyo. Tomorrow I head on to Seoul and then to Beijing for the end of the week. In many ways a change of pace from the week in Vegas, but in other ways it’s more of the same (fun, that is :-). In this previous post we looked at some code to retrieve and process RSS information from various blogs using an agent-based message passing architecture. The code wasn’t completely asynchronous or parallelised, though, as we fired off...
Read more →

November 26, 2009

This is something I’ve been meaning to attempt for a while, and have finally been spurred to do it by next week’s AU Virtual session on F#. Not that I expect to have time to present this during the session (60 minutes is already feeling way too short for the material I want to cover), but I at least wanted to have this working so I could present with a touch more authority. :-) In last year’s session we used Asynchronous Workflows to improve the performance of IO-bound operations, such as retrieving multiple RSS feeds and displaying the results...
Read more →

February 02, 2009

As promised in the last post, we're now going to look at how to change the code to make the colour averaging routine work in parallel. The overall performance is marginally better on my dual-core machine, but I fully expect it to get quicker and quicker as the number of cores multiply. To start with, though, here's the modified "synchronous" version of the code - as I went through making the code work in parallel, I noticed a bunch of general enhancements that were applicable to both versions. Here's the updated F# code: // Use lightweight F# syntax #light...
Read more →

January 28, 2009

Well, I couldn't resist... as I mentioned in the last post - where we looked at creating a simple graph inside AutoCAD as an example of modifying objects inside nested transactions - the idea of graphing inside AutoCAD is a good fit for F#. This is for a number of reasons: F# is very mathematical in nature and excels at processing lists of data. I also spiced it up a bit by adding some code to parallelise some of the mathematical operations, but that didn't turn out to be especially compelling with my dual-core laptop. More on that later....
Read more →

October 27, 2008

This post continues on from Part 1 of this series. You'll find much of this content has been used before in these previous posts, although post does include content updated for F# 1.9.6.2 (the September 2008 CTP). The first thing we need to do is – as with any AutoCAD .NET project – add project references to AutoCAD’s managed assemblies, acmgd.dll and acdbmgd.dll. With F#’s integration into Visual Studio 2008 you do this in exactly the same way as you would for a C# or VB.NET project, by selecting Project -> Add Reference... from the pull-down menu or right-clicking...
Read more →

June 16, 2008

A question came up recently in an internal discussion and I thought I'd share it as it proved so illuminating. If I have an object of a type which implements IDisposable, is it good practice to explicitly dispose it (whether via the using statement or calling Dispose() explicitly)? The quick(ish) answer is: Yes it is, but sometimes you might choose not to as the increase in code simplicity outweighs the benefits derived from manually disposing of the objects. So, naturally, the devil is in the detail. Let's take a look at the three scenarios where you're likely to be...
Read more →

March 17, 2008

Someone asked me recently how I categorize different programming paradigms. I thought it was a very interesting question, so here's what I responded. Please bear in mind that this is very much the way I see things, and is neither an exhaustive nor a formally-ratified taxonomy. One way to look at languages is whether they're declarative or imperative: Declarative programming languages map the way things are by building up “truths”: this category includes functional programming languages (such as Miranda, Haskell and Erlang) which tend to be mathematical in nature (you define equations) and start with lambda calculus as a...
Read more →

February 21, 2008

In the last post we saw some code combining F# with C# to create a random "hatch" - a polyline path that bounces around within a boundary. This post extends the code to make use of Asynchronous Workflows in F# to parallelize the testing of points along a segment. In the initial design of the application I decided to test 10 points along each segment, to see whether it remained entirely within our boundary: the idea being that this granularity makes it very likely the segment will fail the test, should it happen to leave the boundary at any...
Read more →

January 25, 2008

In the last post we saw some code that downloaded data - serially - from a number of websites via RSS and created AutoCAD entities linking to the various posts. As promised, in today's post we take that code and enable it to query the same data in parallel by using Asynchronous Workflows in F#. Asynchronous Workflows are an easy-to-use yet powerful mechanism for enabling concurrent programming in F#. Firstly, a little background as to why this type of technique is important. As many - if not all - of you are aware, the days of raw processor speed...
Read more →