I've worked up a series of examples based on some of the web work I've been doing which I think you'll find interesting. And not coincidentally these examples provide a great lead-in to generic types which are a nifty addition to the Clarion language.

Really, I've become addicted to test-drive development and generics. Be careful; it could happen to you.

Besides all the good stuff in May there's the Aussie DevCon at the end of the month, where Bob Z promises to raise the curtain on the new AppGen. I can't personally make it to the conference this year but ClarionMag will have coverage.

First the bad news: no AppGen yet in the latest release (build 3276). But for the first time SV has released some information about the status of internal testing. Key points:

• Some apps (and dictionaries) convert cleanly
• Code generation is being tested
• Editors/window and report designers are being integrated

Z didn't say but I assume that code generation is being tested against the existing ABC templates.

The latest build also sports a completely rewritten IDE parser. Besides some speed improvements this should significantly improve code completion, which hasn't been that reliable or effective in past releases. It also promises a more useful class browser.

The blog entry also mentions a new "file schema pad" which is like the table schematic in the C6 AppGen. The Dictionary Editor and Synchronizer are code complete and in testing.

The Data Diagrammer's new Reports View is a handy way to get a sorted view of all aspects of your dictionary. I won't go into that in any detail here - just check out the blog post.

Generics

One of Z's blog posts coveres the introduction of generic types, often just called generics. These types use a special syntax with angle brackets, as in

<type>

where type can be any type such a simple long or string, all the way up to any interface or class you create. This may not seem immediately useful to you, but generics are really, really handy. Think of a situation where you don't know ahead of time what kind of object you're going to want to use in a certain situation. In Clarion you have the ANY data type for this situation; in Clarion# you're more likely to use a reference of the type object, since all classes inherit from object (in Clarion#, ANY is actually the Clarion.ClaAny class).

If you create, for instance, a queue of object references, you can assign anything you want to each queue element. But when you want to use one of those objects, all your code will see is the methods and properties of the object class, not of your class. To actually "see" your class the code has to first type cast the object reference back to the right data type. In Clarion# you do this with the tryas operator:

myobj = q.obj tryas MyClass

Casts are expensive; the runtime environment has to do a bunch of checks to make sure that you can safely cast the object to the specified type. If you attempt the wrong kind of cast you'll get an exception. The power of type casting is also the danger - if you can cast to anything, you can also cast to the wrong thing.

Generics maintain the flexibility of using object references while enforcing a type you specify at runtime. In a sense, generics are simply type parameters; just as you pass data to a method, you pass type information to either the class as a whole or to a class's method (the class or the method must be set up to accept a type, of course). I'll only discuss the former approach here.

The idea of passing a type to a class is to tell the class that anywhere it has code that references a generic type (often written as <T>, assuming the class/method uses just one generic type) it should substitute the type you just gave it. Here's Z's example:

myStringList         List<string>
myIntList            List<Int32>
myPersonList         List<Person>
mp                   Person
    CODE
    myStringList = new List<string>()
    myStringList.Add('Joe')
    myStringList.Add('Jane')


    myIntList = new List<Int32>()
    myIntList.Add(2)
    myIntList.Add(3)
    myIntList.Add(4)
    myPersonList = new List<Person>()
    Loop i# = 1 to 5       
        mp = new Person()
        mp.Name = 'Joe' & i#
        myPersonList.Add(mp)
    End     

Keep in mind that List is really System.Collections.Generic.List. I could show you the C# class declaration, but for fun here's a Clarion equivalent of the List class declaration with the Add method:

List                class<T>
Add                     procedure(T item)
                    end


List<T>.add            procedure(T item)
    code
    ! Add the passed item to a collection

Actually that's not what List really would be like in Clarion because List also implements some generic interfaces, which I've left those off to avoid further confusion, and contains a bunch of additional methods. The point of this example (yes, there is a point) is that when you create a new List this way:

myStringList = new List<string>() 

you're telling List that wherever it sees <T> it should now see the string data type. And when you call the Add method, the T parameter is now a string parameter. That means that the class knows the data type you're passing, so it never has to do a cast when you want a string back.

That's a really quick intro to the idea of generics; there are a lot of variations on the theme. Generics are an important subject and one you can be sure will be covered in ClarionMag at some point, hopefully sooner rather than later. At this point generics and delegates are both pretty high on my hit list of Clarion# topics; I haven't sat down to either one yet so if someone out there would like to write an article or two on either of these (or both!) please let me know.

LINQ got a fair bit of coverage. LINQ stands for Language INtegrated Query, and is another fascinating product to come out of the C# team headed up by Anders Hejlsberg, the man largely responsible for Turbo Pascal and Delphi. (Some say there's a Clarion connection to Hejlsberg - certainly there's one via Niels Jensen, one of the founders of Borland who later left to form JPI, which merged with Clarion to become TopSpeed Corporation.)

LINQ is pretty cool stuff, and I expect it will become the standard .NET query language before too long. The big deal with LINQ is you can use it to query a lot of different kinds of data. You can query SQL, of course, but you can also use it with XML and all kinds of lists and collections. Just as you have ADO.NET providers (think drivers), so you have LINQ providers for databases such as Oracle, PostgreSQL, and MySQL. But don't get hung up on just databases. How about querying Amazon, or Flickr?

I've been tracking LINQ for a while, but I'm less familiar with Windows Presentation Foundation (WPF). There are any number of ways to create user interface elements in .NET, and WPF (formerly Avalon) aims to be the "one ring to rule them all." WPF produces vector-based graphics, not raster graphics, so the idea is you can scale user interface widgets under WPF. So how do you build WPF applications? You use a markup language called XAML (pronounced "zammel") to assemble the UI and wire up the business logic to that UI.

The visual scalability of XAML/WPF apps is evident in the Visual Studio XAML editor; there's a slider control with which you can resize the window and its controls. Depending on the number of controls, you might scale down all or part of a desktop window so it could fit on a mobile device.

How about WPF on the web? That's where Microsoft's Silverlight comes in - it's a way to present XAML apps in a web browser.

The final item before lunch was a reporting demonstration, but David had difficulties connecting to SQL Server. These connection problems were responsible for a number of glitches in the presentation; you gotta love demos. We did get to see a report wizard after the lunch break (using an Access database) and after many years of enjoying (if that's the right word) Clarion's extensive reporting capabilities I have to say I found the reporting demo singularly unimpressive. But at least you no longer need Crystal Reports in Visual Studio.

And here's a nicety in VS: when the Intellisense window is displayed, it may cover some of your code. Pressing Ctrl fades the window so you can see the code underneath. Here's the usual Intellisense window:

And here's what it looks like when I press Ctrl:

You might have to squint a bit - the window is seriously faded. As soon as I release Ctrl the Intellisense window is back to its usual appearance.

Sometimes it's the little things that matter so much.

The lone afternoon session began with a lengthy and sometimes quite funny commercial/video, featuring a psychiatrist counseling a user who had lost his first love for his PC. He rediscovers his passion upon visiting a thinly-disguised Apple store, which he derides as a "candy coated wonderland of faux artsiness."

The rest of the session dealt with web development, including a described (but not demonstrated) web control which creates forms and views based on the structure of the database (rather than a data dictionary). There were some nifty demonstrations of web services courtesy of Windows Communication Foundation (WCF, formerly Indigo), which I didn't entirely follow. But it appears that among other things WCF makes it easy to create one service which is available in multiple dialects, including SOAP, REST, JSON, and POX (plain old XML). And if you're accustomed to FireFox's web development addons, take a look at Web Development Helper for IE.

Visual Studio's ability to debug Javascript looks pretty useful; if you've done any amount of web development, you're either already using Javscript or you will soon.

There are also a couple of nifty new web controls, including ListView, which allows you to customize the HTML used to display the data, and DataPager, which makes paged browses easy to create. These are both new in .NET 3.5.

David answered the oft-asked question of which of Microsoft's many web-related tools developers should actually use. The short answer:

• Use Expression Web to for the visual aspect of regular web applications
• Use Sharepoint Designer for the visual aspect of XAML/WPF applications
• Use Visual Studio for all the back end code/business logic
• Forget about FrontPage - it's going away

On the subject of separating the user interface from the business logic, Microsoft's new ASP.NET MVC framework got a mention. MVC stands for Model-View-Controller and has been around for almost thirty years. In the last decade or so it's become more popular for web applications (ClarionMag is delivered to you by way of a custom MVC application) and with Microsoft finally getting on the bandwagon MVC appears to be going mainstream. A preview release of ASP.NET MVC is available, and requires .NET 3.5.

One final note on web development: if you're still using tables to format your web pages you need to get down and dirty with cascading style sheets, or CSS. For an extreme example of how you can radically change the appearance of a page with style sheets, and without altering the page itself in any way, check out the CSS Zen Garden and click on the alternate design links. Each link simply applies a different style sheet to the page you're viewing.

Of course, it wouldn't be a proper Microsoft seminar without some treats from Bill. The goodie bag included an NFR version of Visual Studio 2008 Standard Edition, the November 2007 CTP for SQL Server 2008 with a voucher for an eval version of Standard Edition when released, one year trial editions of Windows Server 2008 and Vista Ultimate SP1, plus a few other lesser items. If you can't get to a seminar, or you don't want to shell out for Visual Studio, you can still get the individual express versions for free.

I don't use Visual Studio that much, but I do find it handy to keep around as a learning tool and a reference point. I sometimes find myself compiling (and occasionally writing) C# code so I can be sure it works as expected; mostly I do this in Clarion.NET using the C# compiler, but certainly VS is the gold standard for hand coding, especially when it comes to the latest and greatest .NET libraries. For more on Clarion# as compared to Visual Studio check out the Clarion.NET FAQ.

If you get a chance to take in a similar seminar, I think you'll probably find it worth your while. I certainly gained a helpful perspective on some of Microsoft's new technology.

Just as I was releasing Paul's article I came across a note Bob Foreman posted some time ago in the newsgroups (I don't recall just where or when), listing the Clarion language functions which can be used in conjunction with the template language. That is, you can use them in template expressions, making the template language an even more powerful code-generation tool. You can even use EVALUATE within template expressions, although BIND isn't available.

• ABS
• ACOS
• ADDRESS
• AGE
• ALL
• ASIN
• ATAN
• CENTER
• CHOOSE
• CHR
• CLIP
• CLOCK
• COS
• DATE
• DAY
• DEFORMAT
• EVALUATE
• FONTDIALOG
• FORMAT
• GETINI
• INLIST
• INRANGE
• INSTRING
• INT
• LEFT
• LEN
• LOG10
• LOGE
• LONGPATH
• LOWER
• MATCH
• MEMORY
• MONTH
• NUMERIC
• PATH
• PUTINI
• RANDOM
• RIGHT
• ROUND
• SHORTPATH
• SIN
• SQRT
• STRPOS
• SUB
• TAN
• TODAY
• UPPER
• VAL
• YEAR
  
• 
  

If you've never taken the time to look at the template language, you're missing out on one of the truly great things about Clarion programming. Check out the template programming topic, in particular the Understanding Clarion Templates series.

• Fully enabled dictionary editor - insert, delete, change, update all items
• No more auto-instantiation, and for the most part no more need to use & in declarations
• Zero based indexes
• := operator no longer used; instead, use the = operator
• Deep assignment operator added
• Optional parenthesis for NAMESPACE and USING
• USING alias support
• Generic classes can be used (but not yet declared)
• NEW can be used as a modifier to hide an inherited member

There are a ton of bug fixes and other changes. I'll have a closer look at some of the new stuff in an upcoming article.

Here's the blurb:

Back for its third year, The Best of Andrew’s Kitchen 2007 is meant as a showcase of a world inhabited by Clarion programmers. Join other friendly Clarion developers in showing off what has been beautiful, unique, humorous, touching, memorable, or just plain meaningful in your 2007.

Details:

1. Email photos to mail@frostbytes.ca. One photo per email please!
2. Please submit images as high-resolution JPG. (Images will be
   down-sampled as necessary.
3. Photos must have been shot from January 1, 2007 to December 31, 2007.
4. Include the following information in the body of your email:
   1. Title of image.
   2. Photographer name.
   3. Location.
   4. Date.
   5. Short (2-3 sentence) description.
   6. Technical data. (Optional.)
5. Five entries per person maximum.
6. Entries must be received by February 8, 2008.
7. Copyright remains with the individual photographer, but will be made visible on the website and/or a downloadable slide show.

View this year's entries at http://www.frostbytes.ca/gallery/bestofak2007.

View the 2006 entries at http://www.frostbytes.ca/gallery/bestofak2006.

View the 2005 entries at http://www.frostbytes.ca/gallery/bestofak2005.

]]> http://www.clarionmag.com:8080/blog/20080114ClarionapponaMac.html Wayne Freeman has reported success in running a simple (i.e. "Hello world") Clarion# application as a Mono app on a Mac, under X11. Mono is a Novell-sponsored open source project which lets you develop and run .NET client and server applications on Linux, Solaris, Mac OS X, Windows, and Unix.

I've been trying to get a web app running on a Linux box, using Mono's XSP web server for ASP.NET. In ASP.NET applications, source is compiled by the web server; while it's possible to tell XSP to use the Clarion# language, the Clarion# CodeDOM provider isn't yet set up to handle Unix-style paths with / instead of \, so compilation fails. But this appears to be a relatively easy fix, and SV is aware of the problem.

]]> http://www.clarionmag.com:8080/blog/20080111Nineyearsandcounting.html Welcome to 2008! Unoffically, this is the start of Clarion Magazine's 10th year of publication. Officially, the ninth anniversary of the very first ClarionMag article is this February 8th. Time flies when you're publishing!

Last month was Clarion Magazine's first ever Clarion.NET/Clarion# feature issue. It's hard to really do any kind of justice to a topic as complex as .NET development in just one issue, particularly since Clarion# developers have the opportunity to write not just desktop, but web and mobile apps as well. It's all quite distracting: as I explore Clarion development on .NET I find myself frequently sidetracked by interesting possibilities, such as writing GPS-aware apps for my Motorola Q9h mobile phone or implementing bookmarking XML schemas for Clarion Magazine.

As interesting as Clarion# is, even without an AppGen, C6 is still where most Clarion developers earn their coin, and this month the focus is squarely back on the current product, where it will stay for some time. But you can expect to see continuing coverage on the .NET side of things. In particular I've been doing some web development work with Clarion#, and if that continues to go well I should have a new series up in the near future.

I wish you all a happy, healthy, and prosperous New Year.

Dave Harms, Publisher

]]> http://www.clarionmag.com:8080/blog/20071221MerryChristmas.html A Merry Christmas to all of you who celebrate the season! Although we often travel west to be with family at Christmas, this year we're staying home and spending time with friends, many of whom are like family to us. And as usual there's snow on the ground in Winnipeg for Christmas, with another storm forecast to hit tonight!

The publishing year isn't over, however - there are still two more articles due in our December Clarion.NET/Clarion# special issue. The first is a short introduction to writing applications for mobile devices, and the second is a piece on creating libraries and writing test suites with NUNit. I'm fascinated by both of these topics. Automated unit testing is pretty cool stuff, and it's very easy to implement; I like the idea of building applications out of verifiable components. And mobile development is a brand new area for many Clarion developers, one that will get a lot of attention in the coming year.

Besides new stuff in ClarionMag, you can look forward to a new release from SoftVelocity. The folks in Pomano Beach are hoping to deliver an update to Clarion# this week. Personally, I'd be just as happy to get it after Christmas. My brain needs a rest!

The Clarion Magazine will be closed on Dec 25th, and open intermittently thereafter until January 2, 2008. I'll check email periodically but don't be surprised if it takes an extra day or so to get a reply.

Enjoy the season, and I wish all of you a very happy New Year!

Dave Harms,
Publisher, Clarion Magazine

]]> http://www.clarionmag.com:8080/blog/20071117ClarionNETbetaimpresses.html SoftVelocity released the long-awaited beta of Clarion.NET today. It's been a loooooong wait for this baby, and I'm very happy to have it installed on my computer at last. As expected, this release does not include the AppGen (that will come later) but it does include a C6 template utility that lets you generate a functioning browse/form application from the data dictionary of your choosing. You load up an app in C6, run the utility, and then look for the Clarion.NET solution in a newly created subdirectory under your app directory.

The Clarion# code that utility templates generates is instructive on a few levels, and I'll get back to that in a minute.

This beta isn't just about desktop (that is, WinForms) applications. You can also use Clarion.NET to create compact framework (mobile) apps, as well as ASP.NET web applications. Basic examples of both are provided, along with a bunch of other stuff. See the just-updated Clarion.NET FAQ for more. And Clarion.NET is a multi-language IDE, which makes sense since it's a marriage of SV's IDE code and the SharpDevelop IDE. So you can write apps in C# and VB.NET as well, and you can mix languages within a solution.

While the lack of templates/AppGen means large scale development is a ways off for most of us, there is a whole lot you can do right now with Clarion.NET.

Now, about that source code. It isn't ABC, that's for certain. There are a lot of classes in the namespace Clarion.Windows.Forms, but there are also some familiar constructs like views, and source code that manipulates views for display in list controls, and stuff that otherwise looks like Clarion code. And there are event handlers that functionally are pretty similar to virtual methods that contain ABC embed points. In other words, while the code isn't ABC, it's not entirely unfamiliar either, and it's not that hard to see how the concepts behind the ABC template set can be adapted to this new Clarion#/WinForms code.

I hope some of that makes sense - I'll have more to say in upcoming mag articles when I've had a chance to absorb all this a little better.

]]> http://www.clarionmag.com:8080/blog/20071113ClarionNETRuntimeVerifiable.html You've probably noticed the new SV web site, complete with information on Clarion.NET. One item in particular jumped out at me:

The Clarion Runtime Library has been ported to 100% verifiable .Net code

That may not matter to most Clarion.NET developers. After all, there's a good chance there's still some Win32 code in the file driver system (although I could be wrong about that). But a 100% .NET runtime is great news for anyone considering writing Clarion.NET applications for Mono, since any dependence on Win32 code would be a huge problem on a non-Windows platform.

]]> http://www.clarionmag.com:8080/blog/20071012MVCwebappsMicrosoftandClarionNET.html In yesterday's article on .NET application architecture I alluded to web application design issues and indicated I'd be covering that topic in a future article. I will say now that I've long been a fan of the Model-View-Controller (MVC) approach. In fact, the Clarion Magazine web server, which I wrote in Java, is built on an MVC design, and for some time now I've been interested in porting it over to .NET. ASP.NET isn't really an MVC framework (although if you beat it with a hammer you can get it roughly into shape) so I've been considering the Castle Project's Monorail, a Ruby-on-Rails-inspired framework for .NET. Now Microsoft has jumped on the MVC web app bandwagon with a project it expects to release around the end of the year, in beta. Microsoft's Scott Guthrie gave a presentation earlier this month at the Alt.net conference in Austin, TX. Ruby fans take note - this project is getting some good buzz. And apparently the Monorail folks aren't too worried as MS is building the MVC framework, while Monorail has that and more. The MS MVC code could be integrated into Monorail.

You can watch Scott's presentation online, but be warned; this is hand held camera work and it's none too steady. Toward the end of the presentation I found myself just about ready to hurl, which was a little ironic because for a change I think MS is on to something good with this project.

]]> http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/podcast.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/podcast.html http://www.clarionmag.com:8080/cmag/podcast.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/podcast.html http://www.clarionmag.com:8080/cmag/ebooks.html http://www.clarionmag.com:8080/cmag/podcast.html http://www.clarionmag.com:8080/cmag/podcast.html http://www.clarionmag.com:8080/cmag/podcast.html http://www.clarionmag.com:8080/cmag/podcast.html http://www.clarionmag.com:8080/cmag/podcast.html http://www.clarionmag.com:8080/cmag/podcast.html