10 July 2008

This Blog Has Moved To http://blog.programmerslog.com

Hi everyone.

This blog has now moved to Programmer's Log at its own domain using Wordpress. The content of this blog will remain, but all new posts will be made at the Programmer's Log. I've already posted a minor update to the TortoiseSVN Visual Studio integration.

Thanks for reading all this time on Blogger. I have made just over 300 posts and I'm not planning on stopping there, so I hope you can join me.

Oh yes, and don't forget to check out my new employer's website Cambridge Visual Networks (Camvine).

Thanks again,
Garry Bodsworth

22 June 2008

A more idealistic time...

Here in the UK we had an episode of The Money Programme broadcast on the BBC called Bill Gates: How a Geek Changed the World. Follow the link to see it on the iPlayer.

An interesting part of this is Steve Wozniak: How it began which is highlighted and can be watched on the BBC News site here. It's certainly nice to think of a time when the computer business wasn't all about taking over the world. It's a brief video from how he got involved in computers, through starting Apple.

It's nice to see some programmes on TV that look at computing, in fact I'm amazed at the lack of ones about the history of computing. Although we may be getting a dramatisation featuring Leonardo DiCaprio as a co-founder of Atari...

18 June 2008

Firefox 3 Released

Go get it here:


Download Day


Have a little read on how to make it even better for the Mac here.


Firefox 3

17 June 2008

Bill Gates Talks Some Sense - A 1986 Interview

The Programmers At Work blog have posted a 1986 interview with Bill Gates - you can read it here.

What is incredibly bizarre is that he talks a lot of sense and a lot of it is still applicable today. Certainly 20 years later substitute assembler for C, and C with a scripting language in the article and you can believe it was a recent article.

It's hard to believe Microsoft is the same company that Bill Gates is talking about in this interview as he has such a pragmatic outlook towards development. With those attitudes you can see why Microsoft became successful, but it also shows you can't stay that way forever without great effort. Most of my teenage years and adult life I have seen Microsoft as this big monopoly and it was nice to see something that shows what it was like before then.

10 June 2008

GUI Toolkits - eGUI++ Easy GUI

I've blogged a few times in the past about John Torjo's Win32 GUI Generics. It was really quite an impressive accomplishment using the advanced C++ techniques in Windows development, but was a bit of a rough diamond. I did do some minor changes to my local copy when I was playing around with it to make sure that the widgets used the correct Windows theming engine, and it was surprisingly easy to add which is a testament to the quality of the code. It did take ages to compile though with all those templates.

I notice that now John Torjo has posted eGUI++ to his blog. Hopefully this is a progression using all he learnt with his previous iteration in Win32 GUI Generics.

There is an article about eGUI++ on the MSDN here written by John. It covers the basics of what he has done and covers some of the features. It is typesafe at compile time which is great for catching errors early as most GUI toolkits you rarely find those types of problems until runtime (especially when using Windows resources).

You can download it from here. The example presented on that page is quick and to the point. Hopefully this is a toolkit to watch.

Upcoming Cambridge Talks

Tomorrow there is the latest BCS SPA talk in Cambridge. This month we have Dependency Injection by Stephen Oakman. If you're in Cambridge and fancy a computer talk with the obligatory pub-based discussion afterwards, give it a go.

Coming up in July Cory Doctorow is giving a talk in Cambridge called "Life in the Information Economy" as part of the Cambridge Business Lecture series. You can sign up here.

We made a bet, some decades ago, that the information economy would be based on buying and selling (and hence restricting copying of) information. We were totally, 100 percent wrong, and now the world’s in turmoil because of it. What does a copy-native economy look like? How do everyone from barbers to musicians become richer, more fulfilled and more civilly engaged in a real information society. And what do we do about the fact that a couple of dinosauric entertainment companies are determined to screw it up?


He's a science fiction author, blogger and journalist. If you follow BoingBoing.net you'll have read a lot of his stuff. He makes his books available under the Creative Commons licence and I would consider him one of the foremost thinkers (and doers) in the modern minefield of information and ownership (he was European Affairs Coordinator for the Electronic Frontier Foundation).

Comics adaptations of his fiction have been made available under the Creative Commons licence. Follow this link for more information.

03 June 2008

Redmine - Part 2

I have been playing with the project management/issue tracker Redmine a bit more over the past couple of days. I have been getting more and more impressed the more I use it because it is so swift to use, by swift I don't mean it runs fast, I mean it gets work done with the minimum of fuss.

The issue tracking system is pretty simplistic if you do a direct comparison to something like Bugzilla, but it provides the essentials. The best bit though is the support for custom fields out of the box, so you can pretty much set up your bug report the way you want it. You can do all the normal things as well like configuring your workflow.

Using the listview of issue gives you a great context menu that you can use to do common actions like setting the priority, status, and completion percentage.

The issue tracking also integrates time tracking so you can see the progress. You have a percentage complete as well as estimated time and actual time. The time estimations can be tagged with which sub-task took the time (like design, code and test).

I spent a bit of time messing around with the source control integration. I decided to try it out with a Git installation I had laying about. In the end it is pretty simple to actually do, and it provides a simple interface with coloured diffs. This means it becomes trivial to cross reference issues, documents, code, revisions, and more in one place. I noticed that the commit comments get added to the reports by adding the issue number.

The icing on the cake is that it is all wrapped in a clear and intuitive user interface. It looks good and makes use of all the Javascript goodness that users come to expect and it actually helps to make it easy to use.

29 May 2008

Bug Databases - Redmine

While on my Internet travels I found a bug database system I hadn't encounterd before called Redmine. It's open-source and based on Ruby-On-Rails, and provides much more than simply bugtracking. It refers to itself as a project management tool as it provides enough tools to do that.

Features include:
* Per project wiki and forums
* Issue tracking
* Source control integration (Subversion, CVS, Darcs, Bazaar, Mercurial, Git)
* Gantt chart and calendar
* Time tracking functionality
* News, documents & files management

I did a quick test install on a Ubuntu virtual machine to see what it was like. The user interface is really quite slick and very easy to use because it makes the most of Javascript. Even when you have a list view you get a nice context menu to do the simple and most often done changes (priority and the suchlike).

One of the most interesting parts I found of the system is the paradigm it uses to partition data. You create a project and it is possible to have per-project wikis, forums, and repositories. You can even use different source control systems per project. What makes it interesting is that you can point a project at a sub-branch of a repository, so it would be possible to have a project per branch or group of branches. This would make it much easier to track implementations on a per-branch basis.

With document and wiki management available it is then possible to integrate the peripheral information for a product with the items involved in actually implementing it. With the integrated wiki you can also have your requirements and design documents easily at hand.

I know some of this is very similar to Trac, but it is good to see another tool approaching the same space. Some of the features like the ease of source control integration is really nice.

21 May 2008

Web Development - Pylons

I was reading some information about Ruby On Rails and watching a few of the screencasts and I was really impressed about how fast you can create a database-backed website. One of the good blogs about it is A Fresh Cup where a Microsoft refugee embarks on a career in Rails development. It pointed to a very interesting article Ruby’s Not Ready whcih compares Ruby to Python.

Through that article I discovered Pyhton has its own "On-Rails" equivalent Pylons for rapid website development. Since Python resources out there are so numerous this would be a very interesting platform to build on. I guess that also means for enterprising C++ developers using Boost.Python they could have some interesting performance improvements.

For the most part Pylons seems about as productive as Rails, as outlined in the tutorial for making a quick blog.

It's pretty easy to try this stuff out on a Mac if you have MacPorts installed (and Porticus to make it extra nice).

19 May 2008

Goings On In The Land Of Eclipse

I've been playing around with some of the Alpha/Beta releases of Eclipse. I haven't played around with it for quite a while but some of the advancements look really interesting.

Currently Eclipse has 3.4.M7 is available for download. One of the most interesting features is that the user interface now supports WPF on Vista. The Java toolkit SWT now has a WPF back-end, you can see its resolution independence if you look at it through the Magnifier application on Windows. Also, in general, the user interface looks much more integrated into the native platform.

You can see a list of new and newsworthy items for Eclipse 3.3 here and 3.4 here.

The main reason I was trying out the new version was to give the C/C++ toolkit CDT 5.0 a go. Doug Schaefer has blogged about it here.

I was just playing a little with it to see how it compared to the older version and it seems a bit faster. It has the beginnings of some nice refactorings and templates which should make some common coding tasks a bit simpler.

Hopefully when this all comes out Wascana will have a new version released with a nicely packaged C/C++ development environment for Windows. It could make a compelling alternative to other IDEs, as well as giving you access to other great tools like PyDev (for Python), Mylyn (task and bug management), and I suppose Java as well...

18 May 2008

Firefox 3 On The Mac

I've been using Firefox 3 on the Mac for the past month so I thought I'd share some of my experiences when using it. There release candidate download page is here.

The reason I didn't start using it beforehand was because I was waiting for a supported version of the Del.icio.us bookmarks add-on as it has become indespensible to me. You can get this here.

I run a few add-ons to make it look more integrated with Mac OSX:
* Locationbar 2 for improving the recognition of URLs.
* Fission for the progress in the URL field like Safari.
* GrApple Delicious (Blue) theme which looks very good (and integrated on the Mac).
* And don't forget AdBlock Plus whichever platform you are running on!

With all of those add-ons working (you can also force add-ons to work by using the Nightly Tester Tools) I was ready to use Firefox 3. For a Beta (and now the Release Candidate) it is amazingly stable.

The entire program is much more responsive and lighter on the system resources. The integration and look and feel (with the add-ons) is excellent, although I would prefer if spell-checking with edit fields to be on by default (although there is a hack here).

In general it is a large step forward although I am not using the biggest new feature - the bookmarks replacement "Places". As usual though the major feather in Firefox's cap is the add-ons and once you have them you find it impossible to use anything else.

Also, I am using it on Windows Vista at work and it is fast, responsive and looks much better, although I would prefer not to have the blue tinge to the window. I'd recommend upgrading now because once you've tried 3 you can't go back.

13 April 2008

Microsoft STL Performance

On the Boost discussion group there is a discussion started about High Cost of MS "Safe" STL for Release Builds. It is an interesting look at the massive differences between "safe" and "non-safe" options in Microsoft STL.

I don't think there has been a clear look at the efficiencies and inefficiencies in the MS-STL implementation, especially with the different options (iterator debugging and safe options). There have been some looks at comparing different STL implementations but it always difficult to do a good comparison, the main problem being comparing the correct "latest versions".

Going back a while I was justifying the use of STLPort instead of Microsoft STL supplied with Visual Studio. Simply, it was a performance thing with both memory and efficiency. Certainly with the new STLPort visualisers for the Microsoft debugger it is an even playing field for ease of use.

You can read those here:
* Visual Studio 2005 - Lets Break Everything! - a bit about how to switch off some of the more annoying "features".
* Development - STLPort versus Microsoft STL performance - A quick summary of my observations on the performance in a real-world complex application.
* More on STLPort and Microsoft STL performance - A little more background.

11 April 2008

Sharing Is Good - The Open-Source Insomniac

Insomniac Games who are behind Ratchet & Clank and Resistance: Fall Of Man have recently decided to start sharing knowledge. Gaming is a notoriously secretive industry and is not well renowned for its open-ness, and Insomniac think its mad that developers keep reinvenhttp://www.blogger.com/img/gl.link.gifting the same core pieces of functionality that don't even make up the bread'n'butter of gaming.

First up is the R&D section on their website. This section contains presentations and papers about various subjects including graphics, gameplay, memory and performance.

Next up is the open-source BSD-style licensed code. The section is called the Nocturnal Initiative and is a wiki. There are links to community forums which aren't busy yet.

At the moment some of the source code available is:
  • C++ Delegate/Event System
  • Pointer to reference counted objects
  • Pointer to heap allocated arrays
  • Endian conversion code
  • Insertion ordered std::set
  • Reversible key and value std::map
  • Interprocess Communication
    • Fast non-blocking message-based design
    • Works over BSD-style sockets (TCP) or Named Pipes
    • Windows platform included, additional platforms are easily added
  • Debugging Helpers
    • PDB-based symbol information querying
    • Capture stacks within your program making heap object tracking and leak debugging easier
    • Give your application automatic crash reports dispatched via email that contain handy user/machine informaton, call stack, and memory page allocation stats
  • Console Output Manager
    • Log console output to one or more trace files
    • Color code the console output based on Error/Warning/Debug print statements
    • Throttle output verbosity (configured via command line arg or environment variable)
    • Outline nested stages of processing performed by your application (for builders/exporters)
    • Augment crash reports with the current outline state of your application (very useful for tracking down new crash bugs)
  • Instrumenting Profiler
    • Cross platform (Windows and PS3 currently)
    • Macro-instrumented stack timer based profiler
    • Concise profile report printed out at program exit
    • Logs instance data out to human readable log file (Profile Analyzer is in development)
  • C++ Reflection
    • Instrument your application classes and register them with the type registry
    • Can serialize object instances to XML or our (faster) custom binary format
    • Flexible parsing mechanics allow you to read in old versions of your class
    • Handles renaming member variables as well as changing member type (within reasonable limits)
    • Supports serializing std::vector, std::set, and std::map containers with primitives or pointers to other reflect objects
    • Supports serializing enum and bitfield members using string representation (supports reordering enum elements)
    • Provides for automatic object comparison and cloning
    • Implements introspection using a visitor interface

Some of it looks pretty good. I hope this means that there is more sharing of C++ code which is always a good thing, maybe even some of the libraries could be Boost-ified...

More STL - MCSTL and STXXL

In a few previous posts I have mentioned some alternative STL implementations. You can read about rdestl here as well as uSTL and stdcxx here.

I've stumbled across a couple of other STL implementations for more specific purposes that I thought some people might find useful.

First up is MCSTL - The Multi-Core Standard Template Library which is a multi-core implementation of certain STL algorithms. This has actually been integrated into the GCC STL implementation with version 4.3. It uses OpenMP internally for the multi-threading so would be limited to compilers with valid implementations of that functionality.

Next up there is STXXL: Standard Template Library for Extra Large Data Sets. I think the blurb sums it up:
The core of STXXL is an implementation of the C++ standard template library STL for external memory (out-of-core) computations, i.e., STXXL implements containers and algorithms that can process huge volumes of data that only fit on disks. While the compatibility to the STL supports ease of use and compatibility with existing applications, another design priority is high performance.
After seeing some extra long and large computations on huge data sets this can be used to get around limitations of the platform with less addressable space.

10 April 2008

Visual C++ 2008 Feature Pack Released

Good news for Windows C++ developers the update to Visual Studio 2008 has been released. This "Feature Pack" contains some of the new TR1 C++ standard library as well as a major MFC update.

Details from the Visual C++ Team Weblog can be found here with some videos and links.

TR1 Update

The TR1 update is an integration of some more Dinkumware library functionality. The features available are:
* array - Defines the container template class array and several supporting templates.
* functional - Defines several templates that help construct function objects, which are objects of a type that defines operator(). A function object can be a function pointer, but more typically, the object is used to store additional information that can be accessed during a function call.
* memory - Defines a class, an operator, and several templates that help allocate and free objects.
* random - Defines many random number generators.
* regex - Defines a template class to parse regular expressions, and several template classes and functions to search text for matches to a regular expression object.
* tuple - Defines a template tuple Class whose instances hold objects of varying types.
* type_traits - Defines templates that provide compile-time constants that give information about the properties of their type arguments.
* unordered_map - Defines the container template classes unordered_map and unordered_multimap and their supporting templates.
* unordered_set - Defines the container template classes unordered_multiset and unordered_set and their supporting templates.
* utility - Defines several general templates that can be used throughout the Standard Template Library.

MFC Update

The MFC Update integrates BCGSoft's libraries into the base MFC and provides masses of useful user interface constructs for native developers. Details from the Visual C++ Weblog is here.

Some of the new features are:
* Office 2007 Ribbon Bar: Ribbon, Pearl, Quick Access Toolbar, Status Bar, etc.
* Office 2003 and XP look: Office-style toolbars and menus, Outlook-style shortcut bar, print preview, live font picker, color picker, etc.
* Visual Studio look: sophisticated docking functionality, auto hide windows, property grids, MDI tabs, tab groups, etc.
* Internet Explorer look: Rebars and task panes.
* Vista theme support.
* “On the fly” menus and toolbar customization: users can customize the running application through live drag and drop of menu items and toolbar buttons.
* Shell management classes: use these classes to enumerate folders, drives and items, browse for folders and more.


You can download all this from here.

Git For Windows - msysgit

Today I finally got a chance to install msysgit - the Git port for Windows using MinGW.

I was extremely impressed with the painless install and the ease of integration (into the shell context menu and the commandline). The installer size is a trim 8Mb so it is a quick download to try out.

The main thing I have tried out at the moment is the newly functioning (for Windows) Subversion bridge. The git-svn import seems fairly speedy even on Windows and works seamlessly. It is interesting how efficiently the data gets stored inteh repository as well, and the possibility of reconstructing information that has been lost due to file moves and other lossy operations in Subversion.

Git-GUI also works. Obviously it does not look spiffy and shiny but presents the information you need, and access to the operations you need (on a basic level).

I would say Git For Windows is very close to being "ready" and providing you are not in need of the more difficult corner cases it is ready for production use. The guys working on it have done a great job.

Now all we need is their version of TortoiseSVN to take off called git-cheetah (which probably is getting easier thanks to some of the Tortoises sharing code now to do with displaying overlays).

Git Is The New Unix

There is a great article about what Git really means as a platform. You can read it here.

This kind of opened my eyes to how Git differs from not only other source control systems, but other distributed source control systems. I recommend giving it a quick read.

GTK+ The Future

Lots of information has been revealed recently about possible future directions for GTK+. There is a comprehensive article on ArsTechnica here.

Imendio, one of the active developers of GTK+ made a recent presentation you can see here. This outlines what they see as the future direction and release plans for GTK+ in the future, with more detail available in the position document. Essentially it involves taking it forward by having a clear roadmap to break the ABI which has been stable for a long time, but has limited leaps forward in development.

Havoc Pennington had a proposal also, this is available here. His proposal did not necessarily overlap the Imendio one but involved using a scenegraph API for defining the UI. He also suggests looking at the OpenGL based Clutter which uses a GObject API for its rich user interface experience.

Some additional experimentation has been made with integrating OpenGL with GTK+. A lot of work has been done to try and keep GTK+ up to date with theming and transparency but it can look off the pace especially when attempting to mimic the look of a native platform. Hopefully all these changes will improve the situation on push the GUI even further since Windows development tools seem to be pushing the "every application looks different" paradigm, Apple making iTunes look the same on all platforms and applications like Songbird using the same theme on all platforms (and still looking good).

05 April 2008

ACCU 2008 Conference

Disclaimer: These are my interpretations of what I learnt from the talks rather than a transcription of what they said. This means that I probably misheard and misinterpreted some parts which may be hazardous to your health.

DisplayLink were very generous and allowed me to attend the ACCU 2008 conference this year. I chose to go for Wednesday and Thursday's talkhttp://www.blogger.com/img/gl.link.gifs, but next time I plan to attend the whole conference. I thought I would present some thoughts on those talks I did attend.

Overall it was well worth spending the time at the conference, meeting a variety of interesting people. I know people always say you learn more in the bar afterwards but I would say there would have to be some pretty intense knowledge exchanges to beat the information I picked up over the two days.

Value Delivery For Agile Environments
Tom Gilb
Slides

I can sum up the talk in three words "Measure Measure Measure". Tom Gilb used his keynote to explain EVO, an envelope framework to surround a smaller development-centric process, which was in this case Agile. He sees Agile as deficient in that it is a development process geared for delivery, but less thought is put into what you actually deliver.

The problem comes then with what do you measure, how you measure, and then how do you interpret those metrics. By doing this and combining it with a fast deliverable methodology like Agile then you end up with constant iterations with feedback able to deal with the changing nature of the world (most probably defined by requirements).

I felt that the talk had an implicit feeling of "How To Survive". You need to identify your stakeholders, the people that determine the success and failure of your project and make sure that the needs of the most important and influential ones are met. If they like what you are doing by meeting and possibly exceeding their needs then you are more likely to gain extra resourcing as you are then seen as a successful group.

Bits And Mortar
Ric Parkin

Like an extended episode of Grand Designs we were taken through an analysis of buildings. Well, no not really, but some of the theories that we are using in computer science have been looked at before and not only recently, in a completely different problem domain, and this field is architecture (and the evolution of buildings).

I'm not the world's biggest fan of analogies because pedantics always want to poke holes in it and take it off course thus negating any benefit from using it. I wish I never used analogies but I am like a lemming following everyone else. Luckily there was a thoughtful audience and the core was suitably abstract to avoid those problems.

The basis of the talk was the work of an architect Christopher Alexander. He posited the theory of patterns which obviously directly relates to what engineers are doing right now, and in fact sometimes he doesn't even refer to architecture and buildings.

Due to my ignorance all of this was completely new to me, and I could take a lot away from the talk because a lot of the ideas of the evolution of a building (and therefore design) is directly applicable to the realm of computer science. If you look at a building as a finished intransient product after it has been completed then you forget about the lifetime of the building and how it evolves much like a codebase. Knowing when to rebuild or rip-down parts requires suitable knowledge of what you are doing and you can also apply patterns other people have proved to be successful subsequently.

Unfortunately (for Ric) the talk will be forever remembered as the place he uttered in public "I don't mind introducing bugs".

Practical Multi-Threading
Dietmar Kuehl

This talk covered the basics of the new C++ standard. It was a packed room so a lot of people are interested in this area.

It certainly looks like writing multithreaded applications will be much less code in C++ than it has traditionally been. I like the idea of getting more functionality for less code. Items like condition variables will be supported in the C++ Standard Library. There was also a brief part about some of the TR2 features (C++0x + 1) like futures which makes using concurrent processing of independent blocks of code even easier and simplifying the synchronisation.

Also some of this will be helped even more by the lambda expressions as I can see some of the simple operations can be kicked off and calculated independently on a single line.

Also there was some coverage of Intel's Threading Building Blocks which provides concurrent containers and also concurrent algorithms like parallel_for or parallel_reduce. This all provides some higher level semantics for expressing the concepts of multiple threaded processing.

When Good Architectures Go Bad
Mark Dalgarno

This was more of an interactive session where people's experiences fed directly into the talk, so it means each time you would hear a write-up about it there would be a different opinion. Luckily my group had some interesting anecdotes. I do wonder why we all stay working in computers if we suffer this much abuse(!)

We used our experiences of the world to come up with examples of where the architecture had begun to "smell" and what this represented. Then looking at case studies we attempted to identify and find potential solutions to eliminate these smells. For my example of a system that had been going for a very long time through so many different platforms, teams, languages, I said to cancel it because it was not making enough money to warrant its existence.

The most frightening solution to architectural decay which also came up at the SPA conference when Mark did it previously, was "Kill The Architect". I thought I was cynical(!)

This was a talk where you got more out of it if you put more into it. Hopefully Mark will put up some of the responses he got from the audience on his blog. In fact he could probably write a very frightening book about it.

Caging The Effects Monster: The Next Decade's Big Challenge
Simon Peyton-Jones

Unfortunately due to beer-and-lack-of-sleep-related circumstances I decided to close my eyes in a darkened room for the duration of this talk. I did not feel too guilty as I had seen Simon's talks for the BCS SPA Cambridge meetings. I posted about that talk here.

The functional programming track at the ACCU Conference seemed to be really well attended and seems to have grabbed the imagination of a number of people.

The Future Of Concurrency In C++
Anthony Williams
Slides

This talk was hosted by the maintainer of the Boost.Threads library. He went through some of the more complex parts of the upcoming C++0x and C++0x TR2 as well as what is available through Boost.Threads currently.

One of my favourite parts of the entire thing is the concept of thread-local storage as a built-in keyword. No more GetTLS and the suchlike. I could immediately see a use of a static member of a class that is per-thread in order to create a memory allocator for STL containers which would allocate via only the thread's heap. If you know that some information is local to a single thread then you won't have any memory contention (in the program - I am not thinking about the hardware or underlying implementation) to slow down the memory access. You have to have a clear design and use of this though otherwise you could blow your program's brains out, but also that design works very nicely with thread pools...

Unfortunately some of the higher level concepts will take until probably the next standard TR2 to get to compilers. Of note this will contain thread pools and futures. Futures mean you can run a thread for a calculation and start it off in a single statement and thehttp://www.blogger.com/img/gl.link.gifn check the result after doing some more work and it will wait until the result is posted. Also getting the result will then propogate any exceptions that had occurred on the calculation thread.

The good thing is a large portion of the C++0x threading implementation is available through Boost.Threads thanks to Anthony's sterling efforts for 1.35, so you can always have a play.

Adobe Source Libraries : Overview And Philosophy
Sean Parent
Adobe Source Libraries (ASL) Open-Source
Lots of interesting papers and articles
Alexander Stepanov's collection of papers, articles and presentations

I can think of worse things to be remembered for but I hope that Sean Parent is not only thought of as Alexander Stepanov's boss. He heads up the Software Technologies Lab at Adobe that create generic libraries that are used in all Adobe's products. This talk was divided into two sections, one concentrating on the data structures and generic programming, and the other about declarative UI.

A very interesting part of the talk is the way he said he was using Alexander Stepanov's skills, he basically said "Write a book defining generic programming". The research for this has lead to lots of leaps forwards for Adobe's programming technologies. Also he said that Stepanov gives lectures to the Adobe programming staff to improve their education.

This talk started a little above my head by defining Regular Types which is very similar to the definitions and rules for what can be derived for functional programming except you can have side-effects. This then provides the basis for generic programming.

We had a close look at the ideas behind the Move library currently maintained by Adobe but could go (back) into Boost. This library uses Return Value Optimisation to minimise and eliminate copies, and I was surprised to learn this was through the use of passing by value rather than by reference.

There was also a look at the copy_on_write functionality which meant the object is only copied when it is written to and it uses the move library as part of its basis. This also provides the platform for Adobe's history tool in Photoshop and minimises memory impact. Then there was a look at the Forest container which approaches the binary tree in a very tidy way. Also they have a string library that uses the move library so concatenations are much more efficient.

They are the right tools to solve certain datatype problems in a very concise and efficient fashion. But the idea behind it all is to only use small pieces of code as building blocks towards the larger solutions. What they want to do is reduce the number of lines of code declaring the applications by a very large factor (like from 3 million to 30,000).

The second half of the talk was based around declarative UI and the structures Adobe have put in place to solve problems that still exist to this day. I've looked at the two main libraries that make this up before called Adam and Eve, where both really amount to being constraint solvers, one solving the data and one solving the layout.

The layout library is probably the simplest to explain as it works out from the size algorithms you provide the layout that follows the guides that have been set up. This also means that it can scale the layouts with relative ease. The scripting language is used to define the layout called Eve.

The property library is used to solve data dependencies (a lot of which are typically cyclic) for user interfaces. I have used something similar but much more simplistic in the past because it keeps the data separate from the UI itself. This also means that you can script the operations.

The papers and documentation on the Adobe site can probably explain all this much better then I ever could, but they are al interesting building blocks for solutions to some overlooked problems.

Overall I enjoyed the talk especially the first half as it was a bit eye opening their practical approach to implementing generic programming with real benefits. Unfortunately the talk was really badly attended considering both halves were up against some tough competition (especially about functional programming), but hey they all missed out on some really good stuff.

31 March 2008

DisplayLink for Mac OSX

Something work related for a change... As you can see from my profile I work for DisplayLink where we make USB display technology. Most people can't believe that it will be very good, but whenever anyone sees one of our docks or adapters in action are impressed by the quality and the ease of use.

Here at DisplayLink we have just released the Beta version of our Mac OSX software. This means you can now use our USB displays on Mac - which I imagine could be very nice for the MacBook Air if the monitor has an integrated USB hub.

You can get the Beta drivers here. The general download page is here. The Mac team have done a great job on this and it looks very impressive when you see it going. As it is a beta it is not perfect, but it is very functional and robust.

I've installed it on my MacBook Pro now, but I forgot to bring anything home to actually test it - duh!

30 March 2008

C++ Is Great

There is an interesting interview with Bjarne Stroustrop on DDJ. It covers mainly how to train people in C++ and the future of C++.

The most interesting part of the entire interview is the bit about the ISO standard committee and how it all works. People seem to complain C++ doesn't move fast enough (although the same people also complain there is too much as well). What interested me is that it is lacking in funds. Now I am pretty sure that every software company in the world has some C++ to varying degrees with most of them being critical to the company itself. Yet, there is no funding or involvement in what is an open process for the language, the most I have seen by some is some people write one of those whitepapers (for instance the EASTL) and then chuck it into the ether. It looks like it is a lot of hard work to really be serious about and to succeed at improving the language, and even Microsoft couldn't succeed in circumventing the process.

I know this could be considered pot calling the kettle black because I have no involvement and nor does my employer(or my previous employers), but I am still fresh at knowing exactly what is going on (even at the age of 30!).

I suppose in an ideal world there would be less Not-Invented-Here (NIH) Syndrome and more participation in helping to improve the libraries and the core language. I am not saying though that the people who use it are to blame as the committee should really have some form of outreach better than they currently have. Boost is being moderately successful in its outreach which is helped by the mailing lists/forums and website as well as participating in things like the Google Summer Of Code. Just imagine if the C++ Standards Committee could get the talented top 1% of C++ developers involved... As developers we could help shape the future of the language and provide real solutions, which is more than could be said for something that is commercially controlled (even if it is published as an open standard).

Boost 1.35 Released

A new version of the Boost Library for C++ has been released. Version 1.35 adds 12 new libraries as well as the usual improvements and bugfixes. Also there is a new look website which is a nice looking refinement with better access to the documentation. Boost is a great addition to any C++ developer's armament.

I think this is also the first release using all their new tools and processes (Subversion, Trac, website and other stuff) so I think it is possible that future releases will be more frequent with this framework in place, because I think the plan was originally to have a release twice a year. That might mean there is a possibility of the logging library by John Torjo being integrated soon as well as some others.

Some of the work brings the current libraries in line with the new C++ TR1 library standard - mainly to do with threads.

The new libraries are:

  • Asio: Portable networking, including sockets, timers, hostname resolution and socket iostreams, from Chris Kohlhoff.
  • Bimap: Boost.Bimap is a bidirectional maps library for C++. With Boost.Bimap you can create associative containers in which both types can be used as key, from Matias Capeletto.
  • Circular Buffer: STL compliant container also known as ring or cyclic buffer, from Jan Gaspar.
  • Function Types: Boost.FunctionTypes provides functionality to classify, decompose and synthesize function, function pointer, function reference and pointer to member types. From Tobias Schwinger.
  • Fusion: Library for working with tuples, including various containers, algorithms, etc. From Joel de Guzman, Dan Marsden and Tobias Schwinger.
  • GIL: Generic Image Library, from Lubomir Bourdev and Hailin Jin.
  • Interprocess: Shared memory, memory mapped files, process-shared mutexes, condition variables, containers and allocators, from Ion GaztaƱaga.
  • Intrusive: Intrusive containers and algorithms, from Ion GaztaƱaga.
  • Math/Special Functions: A wide selection of mathematical special functions from John Maddock, Paul Bristow, Hubert Holin and Xiaogang Zhang.
  • Math/Statistical Distributions: A wide selection of univariate statistical distributions and functions that operate on them from John Maddock and Paul Bristow
  • MPI: Message Passing Interface library, for use in distributed-memory parallel application programming, from Douglas Gregor and Matthias Troyer.
  • System: Operating system support, including the diagnostics support that will be part of the C++0x standard library, from Beman Dawes.

19 March 2008

Source Control - Subversion and TortoiseSVN 1.5

There is no official release date for Subversion 1.5 although Alpha 2 is currently available. I thought I'd post about the upcoming features that will be making their way into the release. there is also a little bit at the end about TortoiseSVN 1.5 features.

Merge Tracking

The most important feature in the upcoming 1.5. The initial concept is based on svnmerge.py but has gone far beyond that and is fully integrated into the repository format. This means it will be possible to see which revisions have yet to be merged or have already been done. For people with complex branching or regular merging it should be an indispensable feature.

Interesting links about it are here, here, and here. The functional spec is available here.

Sparse Checkouts

This allows for checking out portions of a larger repository. This means it is possible to specify the depth that the operations take into the directory structure.

Conflict Resolution

There are improvements to the conflict resolution for merges. It is now possible to use the command-line to perform the resolution and a better interface for graphical clients.

Changelists

It is possible to work on several sets of files on a single working copy. You can associate those files together with a name in order to work on more than one problem in a single working copy. I really needed this feature at work today trying to do more than one thing in a single working copy.

Externals Improvements

The improvements allow svn:externals to be pegged at a revision. Also they can use relative paths from the current directory (that will be really good in some instances with external deliverables) and if you use externals it makes managing a code tree much easier because it treats it like it is part of the current code tree.

Copy/Rename Improvements

There is an improvement in the behaviour on copy/renaming of files (not currently directories until version 1.6) by the client trying to be smarter. If a file has been renamed/copied then rather than the server sending the whole new file it does the copy operation so you should not lose the changes that had been made to the old file.

TortoiseSVN 1.5

This should be released not long after the main Subversion 1.5 release. The major changes will be the user interface work for merge tracking, changesets, and sparse checkouts. There are some other features that will be part of the 1.5 release:
* Client side hook scripts – You can run some scripts before or after committing - this should help people create better processes.
* If a program has done some file operations like renaming and deleting without using the Subversion interface (drag-right-click) then it is possible to fix the file relationships in the UI. This would be quite useful to inte3grate as an external tool in Visual Studio.
* Repository browser now has a two pane look like Windows Explorer with a tree-view and list of files. Apparently it is much faster.
* A new merge wizard rather than the dialog which improves the workflow for merging.

13 March 2008

GUI Toolkits - GTK+ 3.0

GTK+ is used by a large variety of programs on a decent number of platforms. It doesn't have the best reputation for certain bits and pieces, some fairly, some unfairly.

Discussions have begun on what will be the new version of GTK+ 3.0. The most important news is that they will be able to break the ABI which they have heroically maintained all through the 2.0 releases, this should mean lots of good stuff now they are let off the leash.

You can check out the start at this blog post.

The touchstones for the GUI toolkit will be to improve the theming abilities (which in theory will improve look and feel cross platform), animations for swishy interfaces, and proper canvas widget/window. It will be remaining C which is excellent news for the millions of easy language bindings.

It should be interesting to see what happens, hopefully only concentrating on the GUI rather than a lot of the other toolkits which are a bit "kitchen sink" will do for it.

Lucasarts - The Good Old Days

Now I am 30 I can get away with saying things were so much better in the olden days. Actually, no that is not even vaguely true, there is always probably the same good to crap ratio, but the marketing of the crap means you have to dig a little deeper and smarter.

Anyway in the olden days Lucasarts the gaming arm of all things Star Wars was actually astoundingly good at making games. They had the best and brightest and created some of the most unforgettable experiences a person could have on their computer. Their adventure games were masterclasses for scripting and game echanics.

Anyway on to the point of this post - some linkage - two great articles about Lucsart classics, from the very beginning and the very end of their work in adventure games:
* Grim Fandango - Walk Don't Run
* Maniac Mansion - Lucasarts Secret history

And also another completely unrelated gaming article is the excellent retrospective of a game developer starting his commercial career with Donkey Kong on the Atari platform. Check out the post here.

SPA Talks - Continuous Integration and Type Driven Testing

In the space of two weeks there have been two BCS SPA Cambridge talks organised by Mark Dalgarno.

Continuous Integration by Ivan Moore

The second talk by Ivan Moore after his interactive talk about Test-Drive-Development (which was a crash course on Java as well). This time it was not as interactive but just as practical. In addition to the slides he actually demonstrated his own continuous integration system (available from Sourceforge) build-o-matic. It has some interesting features like pictures to show the guilty parties when thebuild or tests break. It also is quite a simple build system which means you can more or less build anything with it.

He was preaching to the converted as most of the audience were practicing continuous integration anyway. I think the main lesson to take away from the talk is to not compromise at any point on the builds or the tests even in with a heavy workload.

Type Driven Development in Haskell by Simon Peyton-Jones

This talk was really about how to write more robust programs in functional programming. The talk involved more of a discussion of functional languages and their benefits as well as how to write tests that more define the concepts and rules for inputs and the outputs.

Mostly the testing part reminded me of the static assertions that are available in the C++ Boost Library. I think that there must be a bridge to utilise more aspects of functional programming in a library like fashion because of the interesting optimisations that can be made. Also mathematical correctness is a bonus.

The lecture itself was interesting and certainly animated. The sign of a good talk is that it makes you think, and I am certainly thinking about functional languages and their applications (after all templates can be used in that fashion but it does put a lot of strain on the compiler). I can certainly see some useful applications in the field of CAD/CAM - shame I left hat field...

06 March 2008

iPhone SDK

After nearly a decade of avoiding having a mobile phone the iPhone was the device that made me change my mind. It is a great device that means I use my laptop a lot less because I can surf the 'Net and get my imap gmail on it in a very seamless fashion.

Today Apple announced the iPhone SDK (the website has completely crashed for me....). It will give a whole new ease of life to an already excellent product. One of the greatest aspects of the iPhone is that it is constantly updated with new features like a full computer.

There is a comprehensive write-up on Engadget and Ars Technica of all the announcements today including proper Exchange support.

The SDK gives access via Objective-C to the OS features. You get access to the accelerometers and multi-touch when writing your apps. XCode provides the environment to develop in and there is an iPhone simulator. The features you have access to are:
* Keychain
* Bonjour
* SQLite
* Core Location
* Quicktime media layer
* Core Audio
* Core Image
* Core Animation
* PDF rendering
* OpenAL
* OpenGL ES

The games look pretty damn good on the iPhone fromt he presentation from Super Monkey Ball to Spore to the specially designed Touch Fighter. It looks like a Wii style changing of the game by using the advantages that the device offers rather than dwelling on what is now missing in comparison to gaming systems.

Also the apps created will be distributed by the App Store that will be run by Apple. If you develop free or open-source apps Apple will host them and distribute them for free.

Also there is a leak of the BBC iPlayer for the iPhone mentioned in this comment on Engadget.

05 March 2008

More STL - uSTL and stdcxx

Thanks to a commenter on the RDESTL post I made yesterday, they pointed me at the uSTL (I assume pronounced micro-STL).

It is a partial implementation of the STL specification. It reduces code size by making memory allocation a non-templated base class. As far as I can tell this reduces executable size because of less template bloat. Whether it is faster or smaller in memory for the containers is another matter. I suppose by reducing the executable size cache coherency could be improved leading to some interesting speed-ups.

It is for POSIX-based systems, and there is no maintained Windows port (a choice of the developer) although some peole have got it to work on Windows with differing levels of success.

And another STL implementation I stumbled across is the Apache stdcxx. The project was started from a code donation by Rogue Wave who decided to open-source their commercial offering.

At the end of 2007 stdcxx made it to an Apache Top-Level Project which means it should be well supported. And apparently performance s quite good as well.

04 March 2008

STL-related : rdestl

A while back I blogged about the EASTL - Electronic Arts Standard Template Library.

It is an interesting look at how EA have internally implemented their own STL with their own improvements/changes specific to their problem domain.

Maciej Sinilo has spent some time putting together a small subset of the STL changed for some game development requirements called the RDESTL. The related blog posts can be read here, here and here. It provides some basic containers (vector, etc), a string class, and some additional container types like intrusive containers. It also provides the EASTL outlook on allocators (which I don't agree with but that is another story).

It is definitely interesting to see the code as it is quite readable. I do wonder whether it achieved part of the EASTL goal which was allowing the compiler to optimise more aggressively because the code is simpler with less indirection.

Also, here is a link to someone else who is replacing the STL. Link via the excellent warpedvisions (with an excellent biting comment).

Upcoming SPA Cambridge Talk - Type-driven testing in Haskell

Simon Peyton Jones of Microsoft Research is doing the upcoming BCS SPA talk in Cambridge. The subject is "Type-driven testing in Haskell" so people who have an interest in functional languages should like it. As usual the talk is free and there is a light buffet.

Sign up through this link.

Synopsis:

One of the joys of functional programming is that code is so much more testable. For a start, testing pure functions is much easier than testing side-effecting procedures. Better still the auto-generation of test cases can be done by a library, without any external tools. And where we want exhaustive testing, it is possible to use lazy evaluation to cut the search space dramatically. I’ll explain these idea using demos from Quickcheck and Lazy Smallcheck, two popular libraries.

While the focus of this talk is testing, I’ll introduce functional programming as I go along, so that you don’t already have to know Haskell to make sense of the ideas. I’ll also try to give a flavour of why I think you’ll be seeing a lot more crossover of functional programming ideas into the mainstream, over the next few years.

Simon Peyton Jones

Simon Peyton Jones, MA, MBCS, CEng, graduated from Trinity College Cambridge in 1980. After two years in industry, he spent seven years as a lecturer at University College London, and nine years as a professor at Glasgow University, before moving to Microsoft Research (Cambridge) in 1998.

His main research interest is in functional programming languages, their implementation, and their application. He has led a succession of research projects focused around the design and implementation of production-quality functional-language systems for both uniprocessors and parallel machines. He was a key contributor to the design of the now-standard functional language Haskell, and is the lead designer of the widely-used Glasgow Haskell Compiler (GHC). He has written two textbooks about the implementation of functional languages.

More generally, he is interested in language design, rich type systems, software component architectures, compiler technology, code generation, runtime systems, virtual machines, and garbage collection. He is particularly motivated by direct use of principled theory to practical language design and implementation -- that's one reason he loves functional programming so much.

His home page is at http://research.microsoft.com/~simonpj.

GUI Toolkits - Mythos

A while back I blogged about some ideas for GUI toolkits, not that I ever managed to get off my backside and do something about it.

Well someone has done a great job with a DSEL (domain specific embedded language) with a toolkit called Mythos. To quote the website "Mythos is a GUI library written in C++ using modern C++ techniques." It does state on the website that it is more of a proof of concept than a fully-blown attempt.

Still, it looks really interesting and has a few different components that make it up. There is khaos which does the low level windowing bits and pieces. nyx is the window layout library with a DSEL that lets you define the ayout in the C++ files. iris does the event handling with another DSEL for associating events and actions. gaia is the widget abstraction.

Overall it looks like a very interesting use of modern C++ applied to GUI toolkits. It is a different approach to something like Adobe's ASL (adam and eve) but I think if the use of the code generation available through templates should be used to take the legwork out of defining user interfaces. Mythos, which is the work of one person as far as I can tell (Benaka Moorthi) is a pretty neat accomplishment.

07 February 2008

Vista Graphics Hackety Hack

There is nothing more depressing than knowing you have to use a computer loaded up with Vista, especially when developing, because it is a constant battle.

But deep in the bowels of the OS there are some interesting things, but they tend to be undocumented. I'm not a fan of the layering of the GUI, and I always wondered if it was possible to use the base parts of the GUI DLLs which things like WP use as teir basis.

Some exceedingly talented and clever developers have spent their brain cycles reverse engineering the completely undocumented dwm and milcore.dll (apart from the thumbnail API). I'm not a fan of all the managed stuff especially since it mainly resoves down to the unmanaged core DLLs anyway. Go check out the blog here with lots of videos of some exceedingly clever things.

What is even better is that the developer has released it as open-source. Hopefully this will provide a basis for more adventurous and useful developments. With this amount of flexibility available then it should be possible to create something where Vista gets some good productivity gains.

30 January 2008

Useful Free Mac Applications

I'm tight, if there is a free tool to do something I will find it. It is a bit harder work to find those applications when you use a Mac, but I have over my time using my Macbook Pro found plenty of stuff to help me get full use out of my computer. So I thought I would share them:
  • Adium - Instant messaging with the GAIM base.
  • AppFresh - Make sure that installed programs are up to date.
  • Audacity - Edit audio files (I used it to make iPhone ringtones).
  • Bean - Simple and easy to use document editing.
  • Chamonix - A CHM reader for OSX.
  • Cocopad - A simple scribbler application.
  • CoRD - Connect to other computers using the MS remote desktop protocol.
  • Docker - Lots of settings for the dock on Leopard.
  • Eclipse - The ubiquitous platform for IDEs.
  • Firefox - Because I love the plug-ins. I'll doa post about them another time to geta more integrated Firefox (could be moot with v3.0).
  • Google Earth - Because i wanted to see old maps wrapped around the globe.
  • Google Notifier - Keep an eye on your Google inbox.
  • Gridwars - Free game allegedly like Geometry Wars.
  • Handbrake - Rip movies to your desired format.
  • Inkscape - Vector drawing.
  • MacPorts - Package manager for thousands of open-source programs. I have mentioned this before.
  • MacTheRipper - DVD ripping.
  • Max - CD ripping software.
  • NeoOffice - OpenOffice integrated Aqua style.
  • Onyx - More settings for your Mac!
  • Perian - Loads of codecs for OSX.
  • Pixen - Simple art package.
  • Porticus - Great Cocoa front-end for MacPorts.
  • Senuti - Get music from your iPod back to your computer.
  • SvnX - Graphical front-end for Subversion.
  • scplugin - TortoiseSVN style integration for the Mac.
  • TinkerTool - More settings for the Mac.
  • VLC - Great open-source video player.
I tend to prefer open-source to free in most instances, and MacPorts (with Porticus) gives so much that it deserves more than a one line description... oh well ;)

Interesting stuff - GPU general programming

An interesting library I stumbled across on the Internet the other day enables the user to accelerate general code by using your graphics hardware. An open-source library libsh provides a high level metaprogramming language in C++ for programming GPUs.

Unfortunately, libsh is no longer actively developed because the developers behind it have created a commercial business around it (those lucky guys have found a way to make programming pay!)

It would be nice to utilise the processing power of the GPU, essentially treating the hardware like another (more specialised) processing core. After all graphics cards have more transistors than the average CPU... I think I mentioned something like this in my multithreading post many a moon ago. But I suppose also it ties into virtualisation of the procesing hardware available on the computer which I even posted about before.

A great website for this type of stuff is General-Purpose Computation Using Graphics Hardware which does exactly what it says on the tin. There are active forums and tons of news and information.

Surprisingly there is not a huge amount of general purpose stuff out there freely available but as GPUs become more powerful and more programmable I am sure that will change. Personally I think the future would be to use a core of these multi-core processors to do the graphics, even if it is slightly specialised for stream processing or something. That would certainly negate the need for faster graphics buses as it would run on the processor (although other buses would still need to progress). But yet again I have digressed....

21 January 2008

C++ Static Code Analysis

I've mentioned before about the usefulness of PC-Lint when doing C++ development on Windows. It closes off a whole class of bugs that can live in a codebase and raises teh minimum standard of development.

I came across a really decent article you can read here. They integrated it into their automated build process and bootstrapped Msbuild to use it.

Also, you can't forget that there are some good tools that can make it easier to use. There is LintProject to run Lint across an entire project, and also there is the Visual Lint which is a nice integration into Visual Studio.

It would be nice however if somehow it was possible to integrate it completely with the cl.exe commandline.

14 January 2008

Starting A New Development Project

With all the tools out there to make developer's lives easier, what would I do when starting a new project. When starting a new development project the initial decisions you make reflect throughout the life of the codebase because once the ship is in sail it is hard to change direction without real willingness.

There are really two areas that this would cover, first the tools you use, and then how you use those tools.

Lets say that you are developing on Windows. You would use Visual Studio instinctively, unfortunately the build system sucks in the worst way when it comes to project dependencies and command-line operations. You could use something like CMake or bjam or any one of the other build systems available. The problem then is that the features always lag behind what is available within the IDE.

But I am going off on a tangent. I am deciding on a development environment for a new project (C++). Right then what could we use that is more or less free...
* Source control : Subversion
The main reason to use this is that there are so many tools available (most specifically TortoiseSVN).
* Bug tracking : Trac
I would rather a more powerful bug tracking system (I am a big fan of Bugzilla) but the tight integration with Subversion is a major plus point. Plus you get a wiki for free, and with the plug-ins you can have continuous integration and a myriad of other things integrated in one Intranet website.
* Compiler : Visual Studio
This means you can support 32 and 64-bit (which MinGW sadly lacks at the moment) targets.
* Continuous Integration : Cruise Control.NET
Regular builds make sure that you haven't gone too far down the wrong path. It can also be used to do other processes like testing or analysis. You can integrate it with Trac as well here http://syntactic.org/2007/7/23/cruisecontrol-net-trac-integration or here https://oss.werkbold.de/trac-cc/.
* Wiki : Trac
Developer documentation should be quick and easy to edit and should be encourages. It's good news it is also part of Trac.
* Unit testing : Boost
Using Boost in a C++ project makes perfect sense, so using their unit testing framework would therefore be a good idea. It can be difficult to drive but other C++ unit testing frameworks are as much a pain so rolling your own could also be an idea.
* Batch testing : Python
Python scripting would be a good idea for doing actual system testing. What would be even better is the ability to run the program due to Python being embedded in the program to drive it. Get the output well formed and I think it can be integrated with Trac as well.

When you start:
* All commits must have a comment and preferably a bug number so you can always work out the reasoning behind all edits. Being able to work out why is always useful to a developer.
* Compile with the warning levels on the maximum available level and have warnings as errors.
* Try to use some static analysis like Lint to improve the baseline coe quality.

By building in high standards in the beginning you don't have to go through laborious and error-prone tasks later in the day retrofitting some standard process. Also, I like the idea of having Trac as a port of call or documentation, source code, and analysis means as a developer you can't complain any of the process is too difficult.

I've probably left out loads but its a start at least...

DisplayLink lots of links

Working for a new company is weird. But it is weirder when the week you join the company is getting tons of CES coverage from Las Vegas. It seems positive on the whole which is great stuff...

Stacks of links:
Link 1
Link 2
Link 3
Link 4
Link 5
Link 6
Link 7

I've been using two connected devices on a Windows PC with Vista and it has been working great for development, I really can't notice much difference from connecting to a VGA connector. At least it makes it easier for people to actually work out the kind of company I am working for ;)

08 January 2008

Visual Studio 2008 Feature Pack Beta

Microsoft have just released the beta of the Visual Studio 2008 "Feature Pack" which is an update for the C++ portion of the environment. The main features are substantial updates to MFC and TR1 library support.

The VC++ 2008 MFC libraries have been extended to support creation of applications that have:
* Office Ribbon style interface
* Office 2007, Office 2003 and Office XP look and feel
* Modern Visual Studio-style docking toolbars and panes
* Fully customizable toolbars and menus
* A rich set of advanced GUI controls
* Advanced MDI tabs and groups
* And much more!

This feature pack also includes an implementation of TR1. Portions of TR1 are scheduled for adoption in the upcoming C++0x standard as the first major addition to the ISO 2003 standard C++ library. Our implementation includes a number of important features such as:
* Smart pointers
* Regular expression parsing
* New containers (tuple, array, unordered set, etc)
* Sophisticated random number generators
* Polymorphic function wrappers
* Type traits
* And more!

Note: This feature pack does not include C99 compatibility or support for special math functions.


Certainly for anyone maintaining MFC based products it is a free upgrade tot he look and feel of the program with tons of advantages.

You can download it here. Unfortunately it tries to force you to download Silverlight which I have been avoiding like the plague but the attempts to get you to install it from Microsoft are getting more aggressive.

07 January 2008

New Year - New Start

Part of the reason I have been so quiet recently isn't just getting old and turning 30, or even the Norovirus I managed to catch in time to blow the bowels out of Christmas. The main reason is that I had my head down before starting a new job.

Today was my first day at Displaylink which is a rapidly expanding display technology company in Cambridge who are good enough to host the ACCU Meetings.

Hopefully I can now get back to a normal blogging service now all of the upheaval should be coming to an end. I had a good seven and a bit years working on the same codebase and hopefully have contributed some decent things to those companies. It was always a shame to say goodbye to NC Graphics when PTC took over, but it also helped me to decide to try something new.

Now I can't see it as a conflict of interest I should do some CAM blogging although it would never be as good as Julian Todd's and I would be approaching it from a higher level perspective.