If you’ve downloaded either the Facebook Developer Toolkit or Facebook.NET Starter Kits I recommend voting in Facebook’s poll regarding which client library you use. It seems to me there’s no good reason Facebook shouldn’t provide an ASP.NET support on par with PHP though I’m biased. Here is the blog post about the poll.

Heck, even if you haven’t downloaded my starter kits but you do ASP.NET development be sure to vote!

Microsoft just announced the release of Visual C++ 2008 Feature Pack which, albeit a bit late arriving, includes an impressive feature list:

• Look & feel support for...
  • MS Office
  • Visual Studio
  • Internet Explorer
• Visual Studio Docking
• Auto hide windows
• Vista theme support
• Menu/toolbar customization
• Shell management and more

If all this stuff is as good as it sounds it would appear Microsoft finally delivered on what Steve Teixeira said they were going to do. To top it all off the whole thing is a free download. I wonder if/when they’ll do the same for WinForms. Btw, I’d imagine this will make a few third party component vendors squirm a bit.

[UPDATE: April 10, 2008] Changed the wording of the last sentence to clarify that I meant "component" vendors based on Oliver's comment where I think he implies that I meant CodeGear which was not the case.

o, Google releases Google App Engine a cloud computing service for building web applications in Python. Very cool! Over the coming days and weeks I’m sure there will be plenty of comparisons with Amazon’s Elastic Compute Cloud for us to consume. Cloud computing is an interesting model, one where I believe an independent dev tools company could flourish.

In fact, before leaving CodeGear I sat down with Jim Douglas to discuss ideas around web development focusing on the growing eco-system of web services that companies are publishing on what now seems like a daily basis. The discussion covered a variety of web services available as well as platforms like Facebook, all things I’ve been thinking about for a long time. To the right is a photo of a page from my developer’s journal which outlines a concept I had (in March 2006) for extending Delphi applications, including the IDE, using web services. For those of you familiar with Delphi’s ToolsAPI it’s like extending the IDE, or any Delphi application, without installing/updating binaries on the local machine. The net effect is it affords the small company the opportunity to deliver more features faster with less impact to their installed base as opposed to getting stuck on a designer. With the advent of so many different API’s from so many different companies I think there’s a good opportunity for a company to stitch these services together and provide developers an entire toolset for use within their applications.

Over the past few years we’ve really witnessed the web grow into an honest to goodness platform and I think Facebook’s salvo really helped lead the way. Initially, we’ve seen the explosion in the world of social networking which I believe is largely due to the allure of ad revenue from millions of page views fueled by viral growth.

Eventually, with things like the Elastic Compute Cloud and Google Apps Engine I believe we’ll see more mainstream web application development move "into the cloud". Today, to leverage Amazon’s services it’s like working with Legos where you need piece things together to build out a site. One example I think illustrates the difference between Amazon and Google is Amazon’s Copy Proposal for S3 read it and let it sink in. I think that illustrates a fundamental difference between how these services are likely to evolve. On the other hand Google’s App Engine appears to be a more well rounded service which will make it interesting to watch Amazon’s response.

One thing is for sure, we won’t likely see Amazon or Google or Microsoft or IBM develop tools that would allow developers to leverage services from many different companies which is where I believe there is an opening for something creative to occur. I guess time will tell who will jump at that opportunity as it’s not likely to come from one of the big name players. I think this idea is already happing in the social network arena where sites like Plaxo and FriendFeed are aggregating data from a number of different services.

Another cool thing about moving "into the cloud" is the opportunity to use whatever OS you want on your local machine. I’m using a MacBook Pro and I’d love the opportunity to boot to the other half of my hard drive and work in OSX for awhile.

Btw, just landed in my inbox:

Thanks for signing up to try Google App Engine!  Your account has been activated, so you can begin building applications!

Looks like it could be a long night!

What’s your take on cloud computing?

Having recently released my first major project after having left CodeGear/Borland I’ve found myself reflecting on the last few years and my decision to leave CG. It seems particularly apropos as my first Falafel review was today.

For awhile back in late 2006 early 2007 I’d felt like I was in a rut and watching all kinds of cool things happening in the .NET world. A few years earlier, I’d made the decision to work on Internet technology because I felt it was important and early on had me working on things like ISAPI thread pooling back in 2002 which was cool. Eventually, when Borland decided to get into .NET with C#Builder I got to work on the ASP.NET designer with Jim Tierney which was a great experience and served to "keep my head in the game". I learned a lot about .NET and ASP.NET in particular and had the chance to write my first designer from the ground up. I used to wonder how many people Microsoft had working on their ASP.NET designer? I bet it was more than two.

The up hill battle

Prior to leaving Borland for Microsoft in 1999 I’d spent a great deal of time working on what eventually became the core of the ASP.NET designer, the integration of the MSHTML control. Even with all the capabilities we were able to wring out of it I became very discouraged trying to keep pace with Microsoft’s designer. When VS.NET 2005 RTM’ed it really hit me hard because I knew Delphi’s ASP.NET designer simply wouldn’t catch up at least not on the trajectory it was on. I recall many difficult conversations about which direction to take including dropping the designer entirely and focusing on creating a richer code editor experience geared towards web development. The primary issue was that Microsoft’s WebForms architecture placed an incredibly heavy burden on the design environment in an attempt to make it function like VB, Winforms and VCL designer’s developers had grown to love.

I was frustrated not spending time working on framework code people could leverage in their own applications and instead putting every last minute into the designer which, in the end, is more or less geared towards trivial applications. A fact that’s true even of Microsoft’s ASP.NET designer which has diminishing returns as the complexity of an application grows. Not a good value add proposition. For me, it was a pretty dark time and I didn’t feel my efforts were headed in the right direction, a point amplified when I attended Google Developer Day in May '07. To be honest, I found myself sitting through session after session wondering why I was the only CG developer attending this free conference a mere 15 miles from the office thinking the entire team should have been there. You could say it was an epiphany of sorts 28 days before what would be my last day.

Another issue I struggled with was believing CG would eventually be freed from Borland’s confines. It’s been just over two years since the original announcement and to my knowledge still no word. Then there’s the decline in BORL stock, dropping an astonishing 70% in the eight months following my departure. While I managed to survive a dozen or more layoffs in 15 years I’m glad I dodged what must have been a nerve racking free fall.

Basically, there was a lot on my mind this time last year.

Life in the .NET world

Back to the point, it’s been a welcome change working exclusively in .NET and in many ways a reprieve from Win32. I’m enjoying the .NET ecosystem and learning lots of new tools which is something I wasn’t really aware I missed on the Win32 side. I think one of the key things that Microsoft was missing prior to .NET was a runtime that developers could "party on" (to quote an old Microsoft phrase) and with .NET they have that in spades.

Probably one of the most liberating things has been getting away from the Windows API and focusing less on the individual function calls and more on solving real world problems. The other day Mark Edington called me regarding a SendMessage question and I can’t say I really miss those days. Another exciting piece is knowing that there is lots more to explore like all the new features in C# 3.0. Admittedly, I really struggled not having the constant drum beat of language innovation present in the .NET world.

.NET Tooling

Speaking of tools one of the most enjoyable parts of .NET development for me has been using VS.NET, NDepend, NUnit, NCover and writing code that’s easier to test  supporting things like Mock Objects. Reflection is a beautiful thing. I’ve also enjoyed the .NET Open Source community including dasBlog, CruiseControl.NET, FileHelpers , edtFTP , ScrewTurn , SubSonic and many others. I think the past nine months have done a lot to reinvigorate me as a developer and I’m feeling more engaged and learning more now than I had in years in Win32 land. It’s interesting to think the guy I sat right across the hall from had so much to do with launching both these development communities.

What’s your .NET experience been like?

[UPDATED: April 1] Fix link.

Preamble: Here’s a post I wrote nearly a year ago which I’ve sat on until now. I know the Agile vs. Waterfall (or whatever other development methodology) issue has been rehashed a great deal but now that I’m working as a consultant and particularly after having pushed my first project into production, I felt it was time to hit the "post"  button.

First, notice that the in the title the "P" in Product is a capital letter. When I was at CodeGear (CG), there was an effort to use Agile software methodology and I reached a point where I felt it was not good for large, complex, version 10.0 code bases sold through channel sales for profit. To me the Agile Manifesto describes what I’d refer to as a "close combat" software development that calls for the ultimate flexibility necessary to adapt quickly to a dynamic situation. But that level of flexibility comes at a high price, like close combat itself, given the unpredictable nature of a dynamic environment. It’s been my experience that that’s not retail product development and what I’ve come to realize over the years is that if you fail to evolve your development process along with your product your chances for success will likely follow.

For me, what came out of the formal Agile training I received while at CG and a year spent using the process is that it was worth learning but the team would have benefited more by not trying to completely switch lock, stock and barrel (first mistake). The first clue, which admittedly I missed, came during the training where it was made clear there would be a "transition period", lasting potentially several iterations before each mini-team could accurately "calculate" it’s velocity. With 20-20 hind sight I believe a better approach would have been to start with a complete review of what was wrong with the existing process and an analysis of why Agile was necessary. I now believe what we did was probably typical of many teams as the "Agile mentality" washed over the shores of development engulfed us all.

We (the development teams at CG) bought into the whole thing, got training, switched project management software, started SCRUM meetings, daily stand-ups, a backlog the works. That was wrong. I think it was too much change all at once and when the product requirements changed late in the process we reconfigured the team to respond accordingly and wound up relying on an older tried and true development process that had been used for years. At that time, CG polled it’s customer base and with that knowledge decisions where made to refocus on other areas of the product. The interesting thing is that Agile more or less fell by the way-side and no one really seemed to skip a beat. We needed a complete RTM plan with priorities and requirements pitted against hard dates. And yes, dates were, and I presume still are significant as CG works towards becoming an independent company. We desired many of the principles of Agile though many of which aren’t new nor unique to Agile. I mean who doesn’t want:

• Satisfied customers
• Sustainable development
• Technical excellence
• Motivated individuals

If your team hasn’t switched to Agile or is perhaps considering switching you need to take a long hard look at your current process and at the very least get your ducks in a row before you decide that a true culture change is best for your team.

I think Agile fits particularly well in the world of contractors (of which I’m now a member), internal facing application development and IT and in those worlds makes a lot more sense. I’m now doing contracting work and I think working on small deliverable chunks over short periods of time is a great way to sustain a project. In fact, working as a contractor on a project several years ago, I didn’t focus enough on Agile principle #1:

Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.

Which directly lead to the end of the contract. Needless to say, lesson learned.

Relevant Links

Post-Agilism: Process Skepticism
Agile people still don’t get it
Accountability in a Scrum World
The start of the end for Agile software development?

Over the past six months I’ve been working on a system to automate invoicing using EDI. The system is built on CruiseControl.NET and a collection of custom written source control providers and CCNET tasks. Back in December, I blogged about this project which integrates with a custom ERP system built from scratch by Falafel that processes half a billion dollars worth of transactions a year so it’s nice to finally see my small part come online.

There are several Open Source projects used in the implementation including:

• CruiseControl.NET - the heart of the system
• FileHelpers - for CSV file processing
• edtFTP - for an FTP source control provider and CCNET Tasks
• ScrewTurn wiki - for documentation
• SubSonic - for mapping SQL Server data to XML
  

Here’s a diagram of the system with CCNET at the heart:

One of the many benefits of using CruiseControl.NET is the visibility the system can provide to the people in Accounts Receivable. Not only can they see what’s going on via the CCNET web dashboard but they can even install CCTray and monitor from their desktop as invoices are processed throughout the day. On the web dashboard clicking through to a specific "build" log for a given EDI 810 "build" provides invoice details including invoice number, customer name, date and dollar amount.

As you can see I still need to customize the dashboard to fit into the web-based ERP system’s look and feel.

CCNET’s plug-in architecture made it perfect for this situation as it has numerous features that can be leveraged to create this, perhaps unusual, usage of a Continuous Integration server. I suppose CI could just as easily stand for Continuous Invoicing.

EDI 850 Up Next

My next task will be to re-work on an existing, read old, EDI 850 Purchase Order set of processes and integrate them into CCNET. Anyway, this has been a fun project to work on and I’ve learned a lot along the way and I’d like to give a tip 'O the hat to John Waters, Falafel’s CTO, for all his help. If you’re looking for an ERP guru, I think you’d be hard pressed to top John plus he’s got a great sense of humor. One afternoon while driving back through the farm land of Watsonville from our client’s site, one of the largest organic food companies in the world, he quipped:

Here we go driving through our business objects...

Something only another geek could really appreciate!

Lastly, I have to admit after 15 years of doing product development feels very satisfying to design and implement a system that solves a real world business problem. There’s just no substitute for hands on experience!

Related posts:

• Using CruiseControl.NET to manage EDI Invoice processing
• Processing fixed length or delimited files quickly and easily in .NET
• More Continuous Integration posts

[UPDATED: March 4, 2008] Forgot SubSonic which I use for data mapping/xml creation!

Recently, I’ve been spending time analyzing code from a project I’m working on using NDepend 2.6. NDepend is described as...

...a static analyzer that simplifies managing complex .NET code bases.

It digs deep into your code providing an incredible level of detail. Should you decide to take a look at NDepend be sure to give yourself several hours to spelunk as there’s tons to dive into. For starters here is a screenshot of what you can expect when you load a project:

In this image the mouse (not pictured) is hovering over an assembly name in the Dependencies pane, in the center of this image. Simultaneously the assembly region is is highlighted in the Metrics pane, in the top right.

Querying your code

While I’m still very new to this tool and digging away the thing that’s really caught my attention is CQL. Here’s a closer look at the CQL Query pane:

CQL stands for Code Query Language and it’s exactly what it sounds like, SQL for code, the heart of NDepend. In fact, you can check out the CQL v1.5 spec. In the above image, the queries you see are provided by default when you load a new project. On the left is a list of query groups which is a one to many with the queries listed on the right. In the image at the top I’ve selected a query titled "Methods too big" which equates to this in CQL:

// <Name>Methods too big (NbLinesOfCode)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE NbLinesOfCode > 30 ORDER BY NbLinesOfCode DESC
// METHODS WHERE NbLinesOfCode > 30 are extremely complex and
// should be split in smaller methods
// (except if they are automatically generated by a tool).
// See the definition of the NbLinesOfCode metric here http://www.ndepend.com/Metrics.aspx#NbLinesOfCode

Notice the blue highlights on the Metrics pane, again the one with the gray sphere’s, which represent methods from the query result set. Double clicking any of the sphere’s opens that method in VS.NET, very nice. Btw, NDepend includes copy/paste syntax highlighting of CQL queries, also a nice touch.

Clearly, CQL is incredibly powerful and the engine that drives the code analysis used in NDepend. I think it’s a very natural approach for .NET developers and if you’ve worked with SQL at all you’ll find picking up CQL straightforward. Although, NDepend does go one step further by providing CQL Intellisense making it easier to get started with the new query language.

While the Intellisense support is nice it would be even better if it listed things like assemblies, namespaces and types (among others) where appropriate rather than just listing "assembly" or "type".

Continuous Integration Support

If you’ve followed my blog you know I’ve written quite a bit about CruiseControl.NET which NDepend integrates nicely with. Included is a command line tool which will generate your NDepend output for integration with your build results. Here is a short screencast available with more details so I’ll leave it at that.

Conclusion

I’ve already spent numerous hours exploring my code and playing with CQL and I still just scratching the surface. I’ve also managed to find and fix a number of issues and improve and optimize my code. The NDepend website has lots of screencasts on how to accomplish various tasks using NDepend and be sure to read Patrick’s blog for lots more information on NDepend.

What do you use for static code analysis?

In the interest of full disclosure, I was provided a copy of NDepend v2.6.3 for review with no strings attached for which I’d like to thank NDepend’s developer Patrick Smacchia for the license and providing such a great tool to the .NET community!

Since I’ve had a lot of interest in the VS.NET Starter Kits I created for the Facebook development I thought it worth mentioning I’ve updated both to their latest releases.

Facebook Developer ToolKit is now at v1.5 (starter kit download)

Facebook.NET is now at v0.3 (starter kit download)

Here are the relevant blog posts:

Visual Studio Starter Kit for Facebook application development

VS.NET starter kit for Nikhil Kothari’s Facebook.NET

Enjoy!

With the advent of Microsoft’s new MVC framework for ASP.NET I think there will be a fairly significant impact on developers who have come to rely heavily on WebForms and related controls. I believe the new framework will require a significant "rethink" of how applications and controls are developed. If you watch Scott Hanselman’s video you’ll see he uses Rob Conery’s Mvc.ToolKit to flesh out the UI and notice that it doesn’t use the designer nor web controls at all.

The MVC framework is clearly going to change how the VS.NET web form designer will be used and certainly makes it less important. It will be interesting to follow the evolution of the framework and to see how MS updates the designer and code editor to fit this new (as in new to MS) model. It will also be interesting to see how 3rd party control companies like Telerik and Developer Express respond.

While at CodeGear I had frequent discussions with Jim Tierney (who I co-developed Delphi’s ASP.NET designer with) about moving Delphi’s designer away from being a WebForm centric because of the development costs involved and instead focus more on the code editing experience. I think the MVC style of development does just that and I expect Microsoft to come up with a number of improvements to the framework and tooling to better support it. I’ll be curious to watch what this means for Delphi’s ASP.NET support.

One thing I think is particularly interesting is with WebForms out of the way ASP.NET developers will be in a better position to leverage non-Microsoft AJAX frameworks such as Dojo, Prototype etc. etc.

Kudos to Microsoft for following through on this much needed alternative to WebForms!

A few months ago I started working in an area I previously knew little about, EDI. EDI stands for Electronic Data Interchange and it defines standards for how businesses communicate with one another electronically. The basic flow of information for what I’m working on looks like this:

 
The document numbers above correspond to the following:

• EDI 850 = Purchase Order (PO)
• EDI 810 = Invoice
• EDI 997 = Functional Acknowledgement

My client represents the seller’s side of this diagram and I’m specifically working on the lower half of this picture, the invoicing portion, as there is existing software which handles PO’s. As indicated in light red there is a trading partner involved which brokers various services between buyers and sellers including providing EDI services. The EDI "documents" are cryptic delimited text files exchanged via numerous transport mechanisms though FTP is used in this case.

The Flow

Basically, there is a system which polls the trading partner, again via FTP, looking for new purchase orders. When one is found the file is downloaded, validated, processed and an acknowledged (EDI 997) is transmitted back to the trading partner. Eventually, the order works it’s way through the system and an invoice is generated at which point, an EDI 810 is generated and transmitted to the trading partner, validated and again acknowledged with an EDI 997, a mirror image of the EDI 850 processing. For brevities sake I’m glossing over parts of this process but you get the gist of what’s going on.

When I first was assigned to start working on EDI invoicing I had a lot of things to learn including EDI, the current processes involved in invoicing and the software that handled purchase orders among others. I quickly learned via not so subtle hints that the existing software which handles PO’s wasn’t considered maintainable and is badly in need of replacement.

Using CruiseControl.NET

Once I got my feet grounded I realized this system closely resembled a continuous integration process and started investigating using CruiseControl.NET as the primary engine to drive invoice handling. I already knew CruiseControl.NET brought a number of interesting features to the table including:

• Open Source
• Polling architecture for trigging task execution
• Open plug-in architecture for things like source control providers and task execution
• Easily configured using XML (ccnet.config)
• A customizable web based portal for monitoring projects
• Email publishing for notifications
• Logging

Basically, you can envision CruiseControl.NET as the two blue circular arrows in the middle of the above diagram. In a future, post talk more about the specific implementations of ISourceControl and ITask that I’ve written to manage this EDI process.

In this, my second post in a series on automated testing, I’m going to talk about a few steps you’ll need to take after your team has committed to automation. Diving into the deep end and immediately writing a bunch of tests isn’t the place to start. Organizing your project, preparing your code base and planning for automation are the first priorities. Of course, the assumption here is that you’re adding automation after the fact.

Organizing your build

If your project isn’t easy to build you’ve identified the first thing that needs fixing. Having a repeatable automated build is key to a successful test automation strategy. Essentially, getting your build organized means the following two things:

• Version control
• Continuous Integration

Version Control

The first step to organizing your build and preparing it for continuous integration is to make sure it’s under version control. There are lots of ways to implement version control but it’s the first step to repeatability which is what test automation is all about. Personally, I really like SubVersion otherwise known as SVN, and would highly recommend it particularly if you’re just starting out. There’s been plenty written about the benefits of version control so I won’t go into that here just make your choice and get your code checked in.

Build Automation

The next step is automating your build process. Jeff Atwood wrote The F5 Key Is Not a Build Process discussing the benefits of moving your build process beyond your IDE of choice and I couldn’t agree more. Build automation is really going to be the key to successful test automation. When changes are committed to your repository a build gets kicked off and subsequently launches your test automation. With this setup you’re automation is guaranteed to run against every change to your repository immediately notifying you when a change has "broken" the build.

For continuous integration I’m a fan of CruiseControl.NET but as with source control you have a lot of choices. CruiseControl.NET is open source and includes a web dashboard that’s easy to modify and supports writing plugins making it easy to extend the build system. Its rather light on documentation so if you don’t want get your hands a little dirty I’d recommend something like Automated Build Studio from AutomatedQA.

 

Putting it all Together

If you find this to be a bit daunting, have no fear I’ve put together a 10 minute video that demonstrates this entire process from beginning to end for a simple project. Of course, your project will be more complex but you’ll get a feel for how easy it is to get going. Note, I made this video in April '07 while still employed at Borland which is no longer the case nonetheless the video is still relevant.

Previous entries in this series:

• Automated testing advice - making the commitment

Other related posts I’ve written:

• Automated testing of ASP.NET web applications using Selenium
• Developing GUI test automation for a Continuous Integration environment
• Modeling UI for automated GUI testing
• Automated testing of Windows applications is hard

We’re using CruiseControl.NET with an MSBuild task to build the solution file for a large ERP system which includes 21 .csproj files and recently when some code was moved to a new project the build started failing with this error:

Velocity.sln : Solution file warning MSB4051: Project {958E0376-0272-4149-A1CF-E03521D12A72} 
is referencing a project with GUID {14F4138C-4DA7-4029-A8D3-B1B3954C2839}, 
but a project with this GUID was not found in the .SLN file.

The weird thing is that from within VS.NET the project would build just fine. It turns out that the .sln file was missing "EndProject" line just above the GUID mentioned. Here is the fragment of the .sln file with the problem (fyi, I’ve wrapped the two project lines):

Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VelocityProductionPlanning", 
  "VelocityProductionPlanning\VelocityProductionPlanning.csproj", 
  "{4BAFD59F-EBB5-4FDA-8639-F7FC63F7F351}"
 ProjectSection(WebsiteProperties) = preProject
  Debug.AspNetCompiler.Debug = "True"
  Release.AspNetCompiler.Debug = "False"
 EndProjectSection
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VelocityLibraryMessaging", 
  "VelocityLibraryMessaging\VelocityLibraryMessaging.csproj", 
  "{14F4138C-4DA7-4029-A8D3-B1B3954C2839}"
EndProject

Notice, the project VelocityProductPlanning has no "EndProject" line. That caused MSBuild to generate the above warning and subsequently the build to fail.

Hope this helps.

I've created a Visual Studio Starter Kit for developing Facebook applications in ASP.NET using C#. This isn't necessarily new though this post title more accurately describes the download. I'd never created a Start Kit before and in fact, it was easier than I thought. I've been following Internet Searches people use to find my blog and "Facebook" as a search term is certainly picking up and it seems many, many people are blogging about FB these days.

Let me know if you have any problems or suggestions for improvements.

It's Thursday meaning my last day at CodeGear and my final Delphi wisdom list:

• Use the public newsgroups (though feel free to skip non-tech)
• Read the blogs
• Use Torry's
• Use a community search engine or build your own
• Use CodeCentral
• Use open source
• Log bugs
• Digg stories you read on Delphi blogs
• Add Delphi blogs to your Technorati favorites
• Comment on Delphi blog posts
• Ask questions the smart way
• Start a Delphi blog

It's Wednesday so here's my list for the Delphi IDE:

• Learn the difference between design-time and run-time packages
• Use incremental search
• Learn to create/install/deploy your own components
• Learn to build your project from the command line
• Use View as Text
• Learn to import a type library, from the command line
• Use the History tab
• Learn to partition your application to use packages
• Use a debug desktop
• Use "Automatically close on successful compile"
• Learn to use the call stack
• Learn to use the thread view
• Learn to step in the CPU view
• Use conditional breakpoints
• Use the ExtraUnits registry key
• Watch my video
• Watch Nick's videos
• Use component palette filtering
• Learn all the shortcuts for your keybinding
• Use selective symbol table loading to debug large packaged applications
• Don't ignore hints and warnings
• Use Syntax Check

My Other Lists
Delphi RTL and Language Wisdom
Delphi VCL Wisdom

What's your IDE list look like?

As promised, I finally got a chance to clean up the code and wrap up a nice little example of calling into and out of the WebBrowser control hosted in a VCL application. The code is available here. Be sure to read this post as well as this post for additional details. If you find this of interest you'll also want to check out this post from Allen Bauer as well as this post from Marco Cantu.

The source code of this example uses the same Automation.pas unit that Allen distributed with his code.

Enjoy!

[UPDATE: April 25, 2008] Related posts:

• Part 1: Mashup of Google Maps and VCL
• Part 2: Using Google Maps from a Windows Client application
• Calling Windows Client code from Javascript hosted inside the WebBrowser control

It's Tuesday and following up my VCL list from yesterday, here my list for the RTL and Object Pascal language:

• Learn to create your own TList descendants
• Learn to write your own TCollection/TCollectionItem descendants
• Use Format
• Learn TThread then, understand TThread.Synchronize
• Use TFileStream, TStringStream, TMemoryStream
• Learn how to use the classes in SyncObjs.pas
• Learn to call a function from a dynamically loaded DLL
• Use exceptions
• Learn when to use stdcall
• Learn to use open array parameters
• Use the *utils.pas units, DateUtils, StrUtils, MaskUtils, ConvUtils, VarUtils etc.
• Learn the Math unit
• Use SafeMM
• Learn which exceptions the RTL throws
• Use try...finally
• Read the comments in SysUtils.pas
• Call FindClose after calling FindFirst
• Learn how to load packages dynamically
• Use FindCmdLineSwitch
• Just because it's not in Windows.pas doesn't mean it can't be called from Delphi
• Learn function inlining
• Be careful using "with"
• Learn to use interfaces
• Use dynamic arrays
• Read the Language Reference manual

What am I missing?

I thought it might be fun as I wind down my last week at CodeGear to post a few Baz Luhrmann-esque lists on various Delphi product areas. So here's the first list relating to VCL:

• Learn to use Actions then, learn to write action descendents
• Learn how to create controls dynamically
• Learn the difference/relationship between Parent and Owner
• Learn how to handle a Windows messages
• Learn how to use the OnCreateXXX methods in ComCtrls.pas
• Use TCustomTreeView.ChangeDelay
• Use TTreeNode.Data, TListItem.Data, TStringList.Objects
• Learn how to use TMenuItems dynamically
• Use Visual Form Inheritance
• Use a custom icon for your application
• Learn TScreen, TMonitor, TMouse, TClipboard
• Use TApplicationEvents
• Learn to use Align = alCustom
• Learn when to override CreateParams
• Learn when to use DoubleBuffered
• Use frames
• Learn to use packages

So, perhaps this can spread this through the Delphi blogsphere. If your a Delphi blogger let's see your list.

One bug in Windows that's been there entirely too long is right clicking icons in the Windows tray (pictured) where the popup menus overlap. The tray poses it's own unique set of challenges with various tricks you can employ but this overlapping problem is really annoying.

Of course, Raymond Chen has blogged a number of times about tray related things so be sure to check them out if you're application uses the tray though I'm not sure there is a cure for this particular problem. Anyone?