Thoughts and Technology

Web Development

2011-06-11T10:18:00.011+03:00

I recently started developing applications for the Chrome browser. This is as simple as developing any other web application, except I had no experience developing web application before.

In this post I will share my impressions of web development and finally share my ideas of next generation web development.

I had to learn JavaScript to a level that would allow me to write complex, object-oriented pieces of code. I didn't really bother with HTML5 and CSS3 - whenever I needed something I could easily find it somewhere on the web (mostly in www.w3schools.com). But scripting is different. You can't just not remember the basics, so I had to learn it on the go.

My impressions of JavaScript is that it is not as good as most compiled languages (like C, C++, C# and even Java). It is not type-safe, and it's object-oriented syntax is horrifying. In addition it lacks data structures like lists and hashtables (or dictionaries), so you need to use alternatives.
By alternatives I don't mean creating your own data structures. You can achieve a mapping between a key to a value using an Object: add a member and give it the value. JSON is all about that... Except JSON comes to represent an object, not a list.

And there is no such thing as a Class. There are only Functions. You want some function to behave as a class? Add sub-functions. You want to be able to override functions in an inherited "class"? Add prototype-level function.

It's not that you can't get used to it. Well actually you can't, but still you write it automatically after a while. What I want to say is that there are so many options to write object oriented code even in scripted languages (see Ruby, for instance) that the way JavaScript is designed is simple horrible (especially with a name that suggests some relation to Java)

Everybody's talking about web development as the next thing. All big software companies push HTML5, CSS3 and JavaScript, each company with its own unique reasons. Microsoft even said writing applets and gadgets to Windows 8 would be in JavaScript (they said that it is much lighter. I don't see how ANY script can be lighter than a compiled code).

I understand the hype. I also starting to realize that web applications is the way to go for most of everyday's uses. But why JavaScript? or any other type-unsafe script for that matter? There are many applications written in Flash. While this is an improvement for the user who downloads compiled code, Flash was originally designed for web vector animation clips, so writing applications in it is really abusing it. Could be done much easier with, say, Silverlight (and C# is a much saner choice over ActionScript, which, AFAIK, is very similar to JavaScript).

Why wouldn't new browsers support precompiled code that can access DOM elements? suppose I could write in C# some code that interacts with elements in a webpage, compile it to a DLL, and link to that DLL from an HTML file. Don't worry about security issues now, those can be taken care of in a variety of ways. Think of the result - faster download times, you don't get it as plain, readable text (I know most scripts are scrambled and their variables are shortened so it's not really readable, and I know you can easily decompile a .Net DLL into readable text), and the most important thing - the browser doesn't need to compile the script on the fly. It is ready to go!

Thinking about it some more - there should be a way to compile an entire webpage. But for now perhaps the best way it to compact it (along with its resources) in a zip file (much like new document formats are doing today).

To sum things up - from a developer point of view, moving to web applications is welcome, but browsers need to support nicer scripts, and perhaps even precompiled DLLs that can access DOM elements.

Thinking of moving to Linux

2011-06-10T09:00:00.163+03:00

Well this thought has been around for a very long time now.
I started to learn to work with Linux a long while ago, in my first professional job. Then was also the time I got to know the world of open source software.
I've been following the development in the Linux world, and every now and then downloaded the latest ISO of some distributions for a test drive. In the end I never gave up Windows. I felt that Linux just could not give me all the tools I need for my everyday tasks.

When I started using a Media Center in the living room, I chose XBMC over Ubuntu Linux. It did a pretty good job and was enough for what I needed.

The Ubuntu distribution was a good Linux choice for a long time, but only now, in version 11.04 it feels like there is nothing I want to do with it and can't.

I always prefer open source software over closed source software and commercial software, with the exception of my Home Windows (Vista 64) which I bought with me PC almost 4 years ago, and Office 2007 Home and Student that I bought for my girlfriend while she was a student (in a great student discount).
Every now and then I review all of the installed programs I have and see which have a Linux version of a descent Linux alternative.

Currently, most of my program have a Linux version and the rest have Linux alternatives:

Image Manipulation:

Gimp - originally a native Linux program that was ported to Windows.
Paint.net - might run under Mono, and if not there is Pinta.

Vector Editing:

Inkscape - originally a native Linux program that was ported to Windows.

Internet:

Chrome
Firefox
JDownloader
Plenty of Bittorernt clients
FTP Client - FileZilla

Programming:

I'm developing mostly in C#, so MonoDevelop is my native choice. Used it quite a lot a long time ago. In my current job I'm using Visual Studio. While Mono and MonoDevelop lacks the features of WPF development, I don't think I'll be doing any WPF development at home. I'll try to focus on Internet related development.

Source Control:

Subversion
GIT

Media Players:

Banshee - while there is a Windows version now, I never tried it. But it works fine on Linux.
Totem - another media player for Linux.

Text Editing:

I'm using notepad++ on Windows. There are plenty of alternatives on Linux. This is also my main development tool for Internet scripts (JS, HTML, PHP...)

Office Suites:

No real replacement for MS Office, but then again, I'm rarely using it. I'm using Google Docs to write most documents. If I really need an office suite, Libre Office (a sane fork of Open Office) is available.

Video Editing: (I didn't edit video clips for a long while now, but want to make sure it is possible)

Kdenlive - seems to have all the features one possibly wants.
Cinelerra - a more professional video editing software, in case Kdenlive won't suffice.

3D Modeling and Animation:

This is a sensitive issue. No free software that even compares to 3D Studio Max. I've started using Google Sketchup lately, but no Linux version for that either. There is Blender, which I've tried using several times, but it lacks the native, streaming UI that 3DSMax and Sketchup have (Although the latest version does present an improvement). There are some other alternatives but not as strong, and not as easy to use. I can always run Skethup with Wine, or start a new open source project that will mimic 3DSMax experience :-)

Sweet Home 3D - I was using it to plan my apartment. Written in Java it have a Linux version and also an online-in-browser version.
Google Earth

In the 3D CAD area there is almost nothing, as the market leaders AutoCAD and SolidWorks are for Windows only. Yet I was able to find VariCAD that claims to have a Linux version and seems powerful. Never tried it, though, as the prices are quite high.
LinuxCAD also promises to be AutoCAD compatible, but I just can't understand anything from their website and I actually had to search (using Ctrl+F) for the download link.
Open CASCADE is a free, open source and cross platform CAD software that focuses on mathematical models, and allows you among other things to test the strength of structures.
In the 2D CAD area there are several options, such as QCAD.

Audio Editing:

Audacity - when ever I needed to record or edit audio this have been my natural choice.

Antivirus:

AVG - it seems that they have a Linux version too.

Backup:

I switch from Mozy to CrashPlan due to Mozy's new pricing and service terms. Anyway, both have a Linux version.

Ability to Fallback:

Wine - allows installing and running native Windows applications. Works quite well too, and with its graphics acceleration support (DirectX implemented over OpenGL, I believe) it can also run games.

VirtualBox - currently I'm using VirtualBox on Windows to run Linux environments. This can also be done the other way...

RDesktop - seems like the most used program that allows connecting to a Windows machine using the Remote Desktop feature from Linux. Good to know it is possible.
GnomeRDP - another program that suppose to allow remote desktop connection to Windows. Could not find any screen shots that proves it, though.

With such a long list, I think my switch is closer than ever :-)

Mozy’s underhanded opportunism

2011-06-06T08:30:00.003+03:00

I’m using Mozy as a backup service.

To be more precise, I was using Mozy for a year before they raised their prices and downgraded their service. Except I’m still using it now even that I don’t want to.

You see, Mozy has two renewal plans on their site once you paid. One – keep with the same plan you’ve paid for (or in my case – pay more and get less). Two – upgraded plan (still gives me less than what I originally signed) that gives you extra storage (I originally signed for unlimited. How it became limited is beyond me).

Note that the is no “Three – no renewal”. There’s just no such thing. You don’t want to continue? That’s fine. You have the option to CANCEL your account (no refund,AFAIK).

What happened the other day was that I got this email:

Thanks for using MozyHome!

Your credit card ending in **** was charged $65.89 today for a yearly subscription to MozyHome 50 GB.
Your card will be automatically charged again on July 04, 2012 in order to keep your MozyHome 50 GB subscription current.

Please visit your account page at https://mozy.com/login to make changes to your MozyHome 50 GB subscription.

Thank you!

- The MozyHome Team

You see, not only they never notified me that my subscription is about to end, and never gave me the option not to renew it, they simply took my money without my permission.

When I opened a support call regarding that issue, this was the response:

When you signed up for service, the plan requires an auto renewal for the plan. ! After you sign up, we will automatically re-bill your credit card every year in order to keep your subscription current, unless you cancel.

The only way to un-enroll is to cancel the account. If you wish to cancel your account I have provided step by step instructions to cancel [...clipped...]

Please do yourself a favor and keep away from Mozy as you would from fire. I was burnt already.

Performance – My biggest success so far

2011-02-01T21:45:00.005+02:00

In my last post I shared the story of improving performance while using .Net and COM.

While improving from a few minutes to a few seconds seems like a great success (if counting such great times ratios*), I haven’t yet beat myself.
The greatest time I’ve improved was from several hours to a few seconds.

Background

In my first workplace there was a C4I application that showed a vector map. No standards where used as it was first develop 15 years ago, before any standards have evolved. In order for the map to run efficiently, its data was split into tiles. First the tiles in view were presented, and then, in background, the other tiles were loaded.

I want to talk about the tool that cut the one big map into tiles.
That tool was given a map, number of tiles along and across, output folder and several hours to run.

The Problem

It was only used when the map was replaced, which was very rare, so no one took the time to improve it. However, this had changed, and I hated waiting those hours.
I looked at the code and found it was going in a simple XY loop over the map, slicing a tile at a time, saving it to a file. For every dead tile with nothing in it, it had to go over all the vector data in the map and testing it against the four walls of the tile.

The Solution

I decided to replace that mechanism with a smarter one. I figured that instead of running over all the data for every tile, I would slice the data recursively, leaving less and less work for next rounds until we get to a single tile size, and then store this tile to disk.

What do you know – it worked! Only a few seconds after years of waiting for hours, leaving the tool running during launch or at night, hoping no mistake was made, and that no power loss will destroy the chance for result.

Conclusion

This story shows that sometimes a replacement of the wrapping algorithm (in this case – from a simple XY loop to a bit more complicated recursion) is enough to gain major results.

*endnote

Optimizing code should be about reducing a method runtime from milliseconds to microseconds. Not from hours and minutes to seconds. If something takes that long, obviously something is very wrong with it that must be taken care of right away. Acceptable initial runtimes is the basis for real optimization.

Performance - Using .Net and COM

2011-02-01T21:10:00.003+02:00

Yesterday I was given a task to help improve the performance of a feature. I was told that the feature was written in a very straight forward way, nearly no optimizations taken. The problem was that it took several minutes (yes, minutes) to run, rather than a few seconds or better than that.

The story is quite long, so if you have time and patience read its whole. If not or you are just too lazy, skip to the summary at the end

Identifying The Problem

The code computed visible area from a given geographic point and DTM. The GIS package used was the one of ESRI. While ESRI tools must have that feature hidden somewhere, for several reasons, including performance, it was not used. However, the result - performance wise – was no better.

Using Sysinternals Suite ProcExp I wanted to see just how much CPU the process is using. I saw that the process was using a total of about 70%. That’s a lot, but the interesting part was that about half of it was actually Kernel Time. This usually means a lot of IO.

So I launched ProcMon to see what happens during the progress. It seemed that for every height sample of the DTM in a given coordinate, the ESRI package accessed the actual DTM file (DTM GeoTiff in that case).

Solving The Problem – Phase 1

I looked deep into the ESRI API to figure out how to prevent that from happening. Since I couldn’t find any descent way of getting ESRI to do it for me, I just used another ESRI API that reads all the data to the memory. While this requires me to build a big memory manager (I didn’t, by the way, just loaded everything to memory. The files are currently small enough to fit. But I’ll get to it…) it is better than accessing the disk for every request.

Joyful and happy that I’ve eliminated the constant file access, I ran the program again. A very minor improvement was shown, and still - too much kernel time.

Solving The Problem – Phase 2

Taking another look on ProcMon, showed a lot of registry access. By asking around (well, asking my supervisor…) I was told that this is due to COM object access. “Strange”, I thought, “I thought I got rid of all COM objects access…”

So the next step was to really get rid of all COM object access during that process. I tracked down several points that it was easy – the value never changes, so just put it in a primitive type member and we’re done. The hard part was to replace the calls to methods that computed something. However, those computations weren’t so hard to do after all. The converted map coordinates to pixel location value in the DTM. Using some linear algebra at its lowest level gave me a satisfying result. Now the program takes seconds instead of minutes.

To sum things up:

If using COM objects, try to minimize or even eliminate calls to them when doing something that requires performance, especially if in a tight loop.
Don’t be afraid to “re-invent the wheel” if your current package is too slow. Either find a faster package, or write simple tasks yourself.
After doing this, make sure the results are satisfactory. Not only performance wise, but also in value. You don’t want to screw things up just to gain more speed.

And in a more general note – improving performance (also true for efficiency) is all about getting the same effect with less work. In this case (and most of the other cases you would bump into), this can be done by a couple of simple replacements of one CPU killer method with another one, less costly. Only rarely the entire algorithm would need to be replaced. Knowing the common pitfalls (or hogs) is a good place to start.

Happy optimizing!

Year 2048

2010-03-04T23:22:00.001+02:00

In just less than 38 years from now, year 2048. I’ll be 65 years old. The world will be filled with slogans like “The real Y2K” spread by techies.

This wasn’t possible on Y1K. Actually, it only became possible in the last several decades. A century, if considering some really old inventions.

I said “the world will be filled with slogans”, because I’m not sure that saying “the internet will be filled with slogans” will be correct. The internet had evolved a lot in the last decade. From slow dial-up (yes, it was like that in late 90’s and early 2000) to 100mib constant connection, from home PCs to our cellular phones and PDAs. From simple websites with slowly loading GIFs, line by line, to advanced, interactive sites, filled with animation and streaming video.

This all made me think what it would all look like in 38 years. I sometimes feel that when looking ahead in the short term, to the next year or two, it is very hard to think that great revolutions might occur. Thinking of bureaucracy of different authorities, things always seem to get delayed. But in the long term, things does happen very fast indeed. Dazzling fast.

I know there are people working on shaping the next generation of the internet. I just wonder how far we can really imagine in such an exponential world.

XAML exporter for Sketchup - Round 2

2009-12-17T01:24:00.005+02:00

I just finished fixing some issues with the Google Sketchup Xaml Exporter.
The updated file can be downloaded here:

https://docs.google.com/leaf?id=0BxinGAr39Pd0ODQ2Y2IyZDUtZWNkYi00YTU2LTk3MmMtNDg4NmMzZDhlZjVh&hl=en

The new version fixes:

Different materials with the same base texture filename caused only one texture file to be created, thus wrong texture to appear.
Group transformations were ignored.
Back facing materials now supported.

Enjoy!

UPDATE:
I re-uploaded the file, this time under a bit different name. It seems that Vista shows me one version of the file, and even loads it correctly, while it shows a totally different file to the world.
I was told that the file I uploaded is not the correct file, and when checking locally, I saw that the size is really different. Strange, even rebooting didn't help. Oh well, saving as (and even copying!) to another local folder solved it, but I still don't understand why it happened.

Google SketchUp Xaml exporter

2009-09-27T16:07:00.006+02:00

I wanted to build a WPF 3D application, that will present models. I didn't want to include code that loads different formats and creates WPF models at runtime, and I wanted an easy-to-use, free modeler.
Blender is free, but I find it very cumbersome. Google SketchUp is very easy to use, but was lacking a way to export to XAML.
Fortunately, SketchUp has a very easy-to-use Ruby API that I could use to build an exporter.
It currently exports the meshes separated by materials, and grouped together in geometry groups according to the same hierarchy structure of the model. Materials include front faces only (i.e. no BackMaterials) and support solid color and textures. If no material is given, a solid white material is used.
While it's not perfect, it does a pretty good job. Feel free to use and please send feedback,
http://cid-8fbcae0caa96d592.skydrive.live.com/self.aspx/.Public/xamlExporter.rb

UPDATE:
I updated the plugin. Check out the follow-up post: XAML exporter for Sketchup - Round 2.

Writing Quality Software - Code

2009-08-07T12:19:00.006+03:00

Coding is bringing the architecture and design to life. Making the idea work. Correct coding is more than just writing code that runs and do what it supposed to do. Correct coding is about making sure the architectural principles are applied, the code is readable and maintainable, self explanatory and self debuggable. Keep in mind that code is meant to be read much more than it is meant to be written.

Debuggable Code

What exactly is “debuggable code”? Well, I would say a debuggable code is a code that helps you find where the errors are as you run into them. This can be done by:

Emitting enough logs where applicable.
Not “swallowing” exceptions.
Placing a method result in a local variable and returning it, rather than return a computation.
Preferring a full if/else when needed for populating a variable over the shorter form of x?a:b.
Breaking lines between different statements, such as
if (something) return;
which is not debuggable, since you can’t place a breakpoint on the ‘return’.

Generally, if you try to debug a section in your code and think it is too hard to debug because the debugger is not enough feature rich, think again how you can change your code to fit the debugger limitations.

Correct Casting

Scott Peterson posted this post about casting best practices. There are several things I would like to add upon.
First, when you expect a specific object type, prefer static cast, even in the case of a publicly visible method. The reason is that you would like the CLR to check the type for you and throw the relevant exception. Why? The alternative is you doing it yourself and responding correctly. Most people would simply “swallow” that error, which will yield bizarre errors elsewhere (most common ones are a null reference exception much deeper in the code, and it would be a very tedious work figuring out what went wrong).

Readable Code

For each project, select a standard and stick with it. Keep in mind that in some cases you might need to read the code you’ve written outside the IDE. This means you won’t have all the cool features like tooltips specifying a member type, go to member, find member references, etc. You want to write code that will be easier to understand without jumping up and down the file.
While it sounds like the Hungarian Notation might sound like a good idea (you can know the type and scope just by looking at the member name), it is a very unreadable notation. I like the naming that adds “m_” and “s_” prefixes to class members and static members respectively, but I hate the addition of “p_” prefix to parameters as I’ve seen in several places. So basically, it is all about readability. Whatever you choose, make sure it is easy to read outside an IDE (using notepad is a good test case), and stick with it.
Another aspect of readable code relates to indentation. Indentation is not an option, my friends. It’s a must, and its better be done right. Select your favorite method of indentation (most common methods include 4 characters wide, 8 characters wide and “smart”), and make sure all indentations are using the same method (spaces or tabs). I personally believe that spaces are the best way to go (along with monospaced font), since the overall code “design” is kept in all editors. Liran Chen has a post about an indentation issue in Visual Studio (in Hebrew).

Spelling

Don’t underestimate correct spelling. And prefer English in your code and comments over any other language. This will be used as a standard that will ease the process of joining new developers to the project. Minimize the use abbreviations and slang. It doesn’t come out nice, and tend to look unprofessional.

These are my two cents of how to write better code, and there’s much more to write on that subject. Maybe in one of my next posts.

Update

Just found this post regarding programming:

http://sites.google.com/site/yacoset/Home/signs-that-you-re-a-bad-programmer

I find it true, helpful and funny.

Installation Cancelled

2009-08-05T19:07:00.001+03:00

The image speaks for itself.

Writing Quality Software – Quality Assurance

2009-07-26T23:09:00.006+03:00

One must not underestimate the necessity of the QA team.

Quality Assurance (QA), the guys that test the software designed by the engineers and written by the developers. Their mission is to make sure that the software does what it needs to do, and do it well. They are also the first users of the software so they have the best review and criticism about the visual design and usability.

A developer needs to learn to listen to the QA team notes. The QA team, on the other hand, must learn how to note.

In order to really understand this, lets check things more thoroughly:
First of all, the role of the QA team versus the role of the development team in terms of software operability:

No QA team – Bad software; No development team – No software.

That said, we now need understand that the two teams must work together in order to create good software.

Alas, those two teams are meant to work as rivals, as the QA must constantly critic the products of the developers, in order to find flaws, and the developers must fix the flaws and prevent new flaws from being introduced.

This is a real fight between the two teams, and not once you hear both sides places the blame on the other doing a bad job, wasting everybody’s else time, etc. While this is not true, this is often the feeling, especially if the organization isn’t done right.

First, developers tend to fix problems presented to them when these are clear enough, and reject or ignore them when these are unclear. Also, a repeated claim, especially if not clear enough, rejects the average developer even more.
This is why a tester must learn how to file a bug report. This is the key to good tester-developer relationship.

THE BUG MUST BE REPRODUCABLE UNDER ANY TERMS. This means that a bug that could not be reproduced, actually does not exist.

Reproducing a bug is an art by itself. Finding the minimal set of operations that yields a bug to reveal. You think you had found it? Think again. Try to do things differently, see if it still happens. Omit steps. If you can’t make an educated guess, make some uneducated guesses. After that – call a developer who might know how things work on the inside, and direct you to a more simple way to reproduce it.

Since developers are the only people who have anything to do with bug reports (the most important product of the QA team), I believe (and some would not agree, for some unclear reason) that the QA team should be placed next to the development team, under the development manager.

Yes, that’s right. There is no reason for a QA team to stand by itself, as the developers are those who need to use the QA products in order to fix their software. The managers can’t fix it. The client can’t fix it. Only the developers can fix it.

According to the size of the organization and the nature of the project, the QA-DEV relationship nature should be defined. Small company, with small development team and small QA team – consult each other a lot by speaking to each other. Don’t go and file bug reports just like that, and don’t go and write the same pieces of code after given a bad critic. Consult. For bigger companies – bug reports are the only way to go, but make sure everything is written correctly, everything can be understood by the relevant developer (or by anyone, for that matter), everything reproduces. Write the relevant version number in the bug report. Don’t attach error logs – these should be reproduced next time that bug occurs anyhow, so instead, make sure all the steps are clear, and that there are no redundant steps.

This is my two cents philosophy of quality assurance. Please try to put it to good use.

Writing Quality Software - Architecture

2009-07-10T16:24:00.007+03:00

Designing the architecture of software is very important phase is the software lifecycle.

Rules of thumb:

A good piece of software would follow several rules of thumb:

Reusability – The piece of software should be as reusable as possible (unless it is applicative), and reuse other components as much as possible.
Extensibility – The piece of software should be as extensible as possible – i.e. have enough places which other developers (or the original developer in a later time) can use to add more functionality.
Functionality – The piece of software should make the life of its user easier. The 80-20 rule would fit here (at least 80% of the time…)
Order – The piece of software should be organized for easy finding of each piece of code, and easy thinking of a good place for a new piece of code.
Traceability – The piece of software should log its actions in details, preferably in different levels of detail. Usage of extensible logging libraries (such as log4net) are welcome.
Security – The piece of software should not reveal security leaks, that would allow malicious code to abuse (I am talking about things like code injection, unauthorized privileges modification, system denial of service, etc.)
Portability – The piece of software should be as portable as possible. Not necessarily between operating systems, but generally between computers. Zero installation (aka -xcopy deployment) is always welcome.

Reusability

When writing software, the reusability factor is crucial, especially when you have deadlines. Splitting your code into several well-defined libraries, that each can be used in other projects, would usually yield lower cost factor in terms of time,effort and money when several projects are involved.

If you only have one project, you would still want to reuse. You should still split reusable code to a library of its own (or at least isolate it, so it could be split into a library at a later time). You might also would like to look for libraries that are already out there.

When not to reuse

One case where reuse is not welcome is a very specific case of the NIH - “Not Invented Here” syndrome. This is the case where the potentially reusable code from an external source does what your business is all about. Joel Spolsky has a blog post about it.

Another case, where reuse should be postponed, is the lack of understanding and/or foreseeing of the correct way to build the reusable code. This would usually be after the relevant code was only written once or twice. I’ll explain: You write a piece of software that does a certain task, and you feel this task might repeat itself in the future. You go and export it to a library. Then, after a while, you want to use it again, somewhere else, but you see that it is not extensible enough, portable enough, answer your functionality requirements, etc. You still have to write your own code. Or you have to fix the library to fit the two projects, then go and fix the old project that already uses it. Fixing the library at this point would be hard, since the new project’s requirements were not taken into consideration in the original design. When a 3rd project would need it, this might repeat itself again.

It is usually a good idea to wait until you have requirements from at least three different projects before you decide to make a piece of code a reusable library.

Extensibility

Extensibility allows adding new functionality in the future. There are several types of extensibility: External extensibility points, and internal extensibility points.

External extensibility points are the most important. The developer of a reusable piece of code should take into account the need of another developer to add functionality, or do things a little different from his own point of view.

For an example, suppose you have a class that contains a user control, and that user control is visible to the end-user. You could wrap it completely, only supplying the functionality you think relevant. But in some cases, a developer might want to tweak that control, and you might have not given him the option to do his little tweak (say, change the font or color). Exposing the wrapped control itself would allow the programmer to tweak it.

Extensibility Best Practices

Another extensibility rule of thumb would be to always expose functionality through interfaces, and if you want the user to be able to implement them in introduce the created objects to your library, use the factory pattern, and allow the user to register his own types. This allows you to replace the code behind the interface as much as you want without the user needs to wary about it, and also allows the user to introduce his own types.

Generally, prefer to introduce interfaces rather than base classes. If the user need to integrate your code into a current project, a base class might prevent him from doing so, as he might need to add functionality to a current class he already has, that already inherits another base class. With interfaces, this is always possible.

If you have a method that returns a result, prefer creating a specialized result class and fill it with the relevant data. If you’d like to add data in the future, this would be as easy as add fields to the already existing result class. In .Net this is also true for EventArgs – create your own even if they are empty. They might get filled later on.

Functionality

When writing software, make sure each portion of the software does what it needs to do, and does not do what it doesn’t need to do.

When thinking where to place each method that implement some of the functionality required, try to group together methods that have related functions. Try to avoid duplicating functionalities, just because of small differences. If you must, do it in smart way, reducing code duplication to the minimum necessary. Use helper class or helper methods as possible, and make them static, to reduce class state artifacts.

The exposed functionality should fit the user needs. In reusable code, don’t try to cover 100% of the cases. At least 10% of them are so rare you won’t even get to think about. Make a good, thorough research and find the 80% case that is relevant to you. Don’t look at other unrelated businesses research. They do things differently since they have different audience. Look inside your own market. Even in your own business. You’ll find plenty of information there. If you don’t – it only means this might be a functionality you don’t need to reuse. Make it applicative, and save others the burden of understanding why this is needed.

Don’t use intrusive technologies in your code, and if you do, document them and the reason you use them. For instance, don’t do communication for traceability. The containing project might be affected by it. If you must, make sure everything is configurable, including the traceability feature itself.

Order

When building your project tree structure (in terms of code files), make meaningful separation by logic, not by physical terms. Think where a new-comer would look for a certain file. If you can’t – ask a new-comer to find that file for you just by looking at the tree structure.

The same goes for using the “region” directives. I see endless “public methods” and “private properties” regions. Where would I find the method that performs the layout? or the methods that respond to user input events? I don’t know. In either of them. Better regions would be based on functionality groups. Region such as “User Interaction”, “Layout Logic”, “Construction and Initialization” are better.

Traceability

The software should log its actions and its errors. This logs are later used to analyze software usage for performance, errors, misbehavior, etc.

Use a common logging method for all parts of the application. A highly configurable and extensible logging method is preferred, because in the horrible case of mismatching with another logging facility used by some 3rd party component, it can be configured or extended to match it, so everything behaves like one logging method.

Security

Security is a very important issue, especially when the software is exposed to a large user base. You don’t know which of them might want to harm you, or your client.

When making database queries, make sure to sanitize the queries to prevent malicious SQL injection, that can result in loss of critical data.

When asking for input of any kind from any source (and this one is especially relevant in native environments, like C and C++), make sure you have enough room for it, to prevent code injection.

Portability

A portable software is much better that a software you need to install. Copying the files to place is the easiest thing to do, and it doesn’t mess up the registry. In .NET all you need to do is make sure all the required DLLs are there, near the main executable.

You might want to use tools like ILMerge to reduce the number of DLLs in your distribution.

When writing .NET software that should run on Linux, use MoMA to make sure your application and dependencies are portable.

When writing a portable application that need to be run from a portable memory device (such as a disk-on-key), make sure to write the relevant data next to the application itself.

Summary

That’s it for now about writing quality software, a quick review of architectural design. I’ll try to add more about that subject later on, and write about other aspects of writing quality software, such as user interface design, testing your application and modules, etc.

How can Wikipedia improve its content reliability

2009-05-28T13:01:00.001+03:00

Wikipedia is a very common online encyclopedia, built and managed in the form of a wiki, which means anyone can modify its values.

While this promises many writers, editors and critics, thus up-to-date content all the time, it also introduces great unreliability, as you can’t trust anyone who had written anything.

While even “Wikipedia founder admits there are serious quality problems”, I figured something can be done to improved the reliability and quality of the content.

So here is my idea: Wikipedia should introduce a “Content Reliability Factor” that will be visible, sticking out on the top of each page. This factor will be on a scale (say, from 1 to 10), and will allow the reader to know how reliable the information on this page is.

In order to calculate the reliability factor, Wikipedia should introduce “Fact Markup”, to specify “Fact Fields”. Items that represent clear, hard facts, preferably numbers, will be marked using this markup.

There will be different types of fact fields: Absolute numeric fact fields (usually used for scientific articles), Usually climbing numeric fact fields (say, number of children of someone), Citations, etc.

Readers that come across fact fields would then be able to rate the correctness of each fact field, and/or the entire article. Some users will be granted higher reliability factor for some values or categories, and their vote will have higher influence of the calculated result. (Of course, some articles will be blocked for such changes, for the same reasons some articles are blocked for public editing today).

Now to the really good part: When ever someone that is not trusted in a certain value or category, changes a fact field, the reliability factor for that fact field decreases. The amount of decrease depends on the type of that fact field – say, for usually climbing numbers, a decrease of that number would result in a very large decrease of that field’s reliability factor, while an increase would result in a smaller decrease of that reliability factor.

In the article history, the reliability factor will be stated next to each version. In addition, the highest ever reliability factor will be stated next to the current reliability factor on the top of the page, and will link to the relevant version of the article.

So all in all, while this idea does not solve the problem completely, and surely does not free us from the need of human approval for the content, it will allow to make better decisions regarding the given content.

P.S., There are many other methods that can be integrated into such a system that will assist with its automation. Maybe I will discuss those some other time.

What can the government of Israel do to solve the water crisis

2009-04-28T17:20:00.008+03:00

Israel suffers greatly from lack of water.

This is the case for many years now, and from one year to another the government is doing more and more to solve it. By "doing more and more" I mean pass on the blame and the responsibility to the citizens.

Now they have a big campaign featuring all greatest Israeli celebrities, telling us to save water; telling that we must stop watering our gardens; asking to shower less. Before we'll know it they'll limit our tap water drinking.

This is, of course, useless and idiotic. It won't help even a tiny bit. This is the same as doing micro-optimization to a monkey-sort algorithm. This is because the reason to this water crisis lies mainly on the fact that the population growing while the amount of water in our reservoirs stays the same (in the good case) or lowers (in the bad, current, case).

Now, what can really be done to solve that crisis? Understanding the reasons, quite a few things:

Fixing Pipes - As what I've read, many of the main water pipes in Israel are leaking. In the announcements they tell us to close and fix leaking taps. A leaking tap costs us about three or four liter of water a day. A leaking main pipe costs us much more than that. I roughly assume between ten times more for a small pipe and a thousand times more for a big, central one.
Desalination - This is the most important one of all. Different versions of it will appear in some other suggestions. This one is the only action that can be taken that actually creates new drinking water out of bad water. Actually, there are some desalination devices used in Israel, but not enough. It seems like the bureaucracy is killing every new attempt to build new desalination devices. It is claimed that it takes about five years to build one, so the required authorizations are rarely granted, given the government is replaced every four years in the good case.
Recycling - Yes, water can be recycled. Actually, today, much of the water for agriculture are recycled water. The idea is that instead of sending all used water to the draining system, we clean them a bit (so they're not good for drinking) then re-use them to water fields. The same thing is also done in some water-smart buildings, where used water are re-used to fill toilet tanks. I say the government should demand that every new building would be built with such a system installed.
Mineral Water - There are three main companies that produce bottled mineral water in Israel. These are very good water, that most of the citizens can only buy for a great cost in bottles. I think the government should limit the amount of bottles produced every year, higher the cost of local production by taxing that companies per liter, and encourage importing of bottled water, by lowering import tax for water. In addition, state in law that every place that sells bottled water must sell at least one brand of imported water. Oh, and forbid exporting of local water products.
Collecting Rain - Well, here we get a bit into micro-optimization, except this one is actually feasible. We can collect rain water not only in special reservoirs dug for that purpose, but using the roads and roofs draining system. Come to think about it, there is rarely anything bad in water dripping on roofs and roads. This is usually rain water, and there is always a special draining system built for each roof and on each road. Those draining system go usually to the sewer, but it is possible to collect it to reservoirs. Those doesn't have to be open reservoirs. They can be closed and underground. Still they are reservoirs, and they will get filled in the few rains we have each winter.

Well, these are my ideas for solving the water crisis. Not all are original, but I figured I'd put them all in one place, and maybe something will be done about it someday.

Please feel free to comment and to suggest new ideas.

BiDi – What is it, why we need it

2009-04-25T15:41:00.003+03:00

BiDi stands for Bi-Directional text. Yes, specifically text. In some places (such as the Word text editor) this is referred to as Complex Scripts.

So what exactly is it? It is the case where several languages of different writing directions are mixed in a single sentence. More than that, in some cases, this is the case where a Right-To-Left language (Hebrew, Arabic and Persian) needs to be rendered to screen.

Why is this a problem? This is a problem because there is a dilemma of how to store textual data that contains both directions of writing; On the one hand, it can be stored visually, just like it appears on the screen. It will make it much easier to render, and save us from all the burden and improve performance of the rendering phase. On the other hand, however, it will make our writing phase much harder, and will require us to write some of the text reversed. Actually this is exactly what people where doing before the age of Logical Text and the BiDi algorithm.

The BiDi algorithm brought a new age of Logical Text, and by that we mean the way the text is stored in memory. Instead of storing it the way it is rendered, we store it the way it is being read and written. When we read text that contains several text directions (Hebrew and English mixed, for example), we change our reading direction every time the language is changed. When we write text that contains several directions, we still write the first letters first, and last letters last, even when the language changes. We don’t reverse the order of characters for that task.

Storing the text logically makes much more sense, and makes it easier to develop software that handles text. The software behaves with text in the same way we think about it. However, in order to draw the characters on the screen in their correct position, we first need to reorder them.

Rendering text is not an easy task. Rendering each line requires all the letters (and other characters) to appear in their correct positions, since we usually want the renderer to make one pass due to efficiency reasons. Before that, if we want our break our lines to fit in a given width, we need to calculate the widths of the characters and select where to break the line logically, as doing it visually might yield an unreadable result.

The reordering is done in the line level, after the text has been broken to lines. The BiDi algorithm takes each line and returns a new line with all the characters reordered, ready to be rendered.

The process of reordering can be controlled by inserting special Control Characters to the text. The most common ones define literally the direction of the text, even if the characters themselves implies differently. You can try it yourself: try to launch notepad, write some text, then click the right mouse button, in the context menu go to “Insert Unicode control character”, and select one of the control characters available. Experiment with it a little, see how it effects the text from that point on.

The BiDi algorithm is a one way algorithm. There is no reversed algorithm, and it is not guaranteed that running the same algorithm on visually ordered text would give the correct logically ordered text, since the visually ordered text could be the result of control characters usage, that might have been lost after the conversion. Thinking deeply about it, you don’t really need to convert back. If you do, think again, you’ve got something wrong in your overall design (this is always true, except for the case where you have INPUTS from a legacy device that can’t be altered, and those inputs are ordered VISUALLY. I will try to deal with this case in another post, if requested).

For further reading, the official Unicode website contains all Unicode information needed, including the BiDi algorithm.

You can find my implementation for that algorithm,called “NBiDi”, written in C#, targeting .Net and currently being used to implement Right-To-Left Silverlight controls.

A quick review of different UI frameworks

2009-04-25T15:19:00.003+03:00

In this post I'll review several frameworks used for creating graphical user interfaces. I've decided to create such a review after noticing many programmers take a specific GUI framework for granted, as it is their automatic-choice-by-tool (i.e., they use what they're IDE let them, barely understanding the layers required to develop such a framework, and that there are alternatives they might have chosen if they had knew about).

I will review the following frameworks:

Windows.Forms
WPF (+Silverlight)
GTK
QT
wxWidgets
AWT
Swing
SWT
X/XT/Motif

Windows.Forms

Naturally the automatic choice for anyone who builds a GUI in .Net. The first version was there from the very first .Net release, and supported by all versions of Visual Studio, the main IDE for .Net development.

When you ask most .Net developers what are they are using to build forms for their applications, they will most likely say "The default thing that comes with Visual Studio" or "... with .Net". Most won't even know other UI frameworks exist.

And for some technicalities: Windows.Forms in its original implementation wraps the underlying Windows native controls. In its second version, some controls where added that doesn't wrap any base controls, but rather implemented the entire logic and graphics internally in C#.

As most .Net frameworks, their immediate audience is the Windows users (or in this case - developers). However, the Mono project had implemented all the Windows.Forms controls entirely in C#, not wrapping anything at all, while maintaining complete API compatibility (including message loop interference). Due to the nature of .Net binaries, this allows migration of compiled applications from .Net to Mono, hence from Windows to Linux.

WPF (+Silverlight)

The newest technology reviewed in this list. Has not yet become a natural choice of any developer (mainly due to the lack of tools and IDE integration), but it is getting there. Unlike any other framework listed here, this framework does not base on the underlying windowing system at all. The only use it has for the windowing system is to open and register a top-level window. From now on it is all DirectX (at least in the WPF implementation).

Using XAML as the main form of defining UI, and tools that resemble artistic programs more than IDEs, WPF really allows developers and designers to work together, letting each one focus on what he can do best, providing better separation between the two worlds. Also, it allows to create applications that are much more appealing visually than most common applications.

WPF stands for “Windows Presentation Foundation” and was introduced with .Net framework 3.0.

Silverlight is a subset of WPF, targeting the web. Allowing roughly the same features as WPF, in the same development model, using the same tools, it bridges the gap for developers and designers to move from desktop to web environment and vice-versa, allowing knowledge and components to be persisted and reused.

Moonlight is an open-source implementation of Silverlight, part of the Mono project, aims to bring Silverlight to the Linux world.

GTK

The automatic choice for anyone who develops applications for the Gnome Linux desktop. Written in C, and have many language bindings, including C#.

GTK was originally developed to support the development of The GIMP (the GNU Image Manipulation Program), thus was named “GIMP Tool Kit” – or GTK for short. Later on it became the main toolkit for the entire Gnome Linux desktop project.

This is an open-source (LGPL) library, developed and maintained by the community.
GTK is a source-code-compatible, cross-platform toolkit, that has binary distributions for Linux, Windows, and Mac OS, and has some support for mobile devices as well (it runs on some Nokia smart phones, and used to build the OLPC project and the OpenMoko project user interfaces).

It supports several levels of themes (Skins and Theme Engines), and has default themes for each operating system, especially for the Windows and Mac OS, that have very specific themes. This allows GTK applications to merge in the look and feel of those operating systems.

QT

Originally developed by TrollTech, now owned by Nokia and supported by the community. Written in C++ and utilizing a Meta-Object-Compiler - a special precompiler that adds several features to the C++ language, mainly used for easier data binding. Some language bindings are available, including a community binding for C#, named Qyoto.

QT is a cross platform framework targeting both Desktop and Mobile applications.
In its open-source license (GPL, LGPL) it is used to develop the KDE Linux desktop environment, while in its commercial license it is used by commercial software and hardware vendors to build the GUI of their products.

QT has a very good support for themes, allowing it to merge in the look and feel of just about any environment, including Windows, Mac OS, and even the Gnome Linux desktop (by reading the Gnome theme configuration file).

wxWidgets

wxWidgets is a cross-platform framework designed to use each system’s native controls to the max, while preserving common API and rich set of controls. Written in C++ and has several language bindings including C#.

There are no common tools that support visual design for it, but there are several visual designers for it out there, such as “DialogBlocks”.

AWT

The Java most basic set of UI controls. AWT stands for “Abstract Windowing Toolkit”, and works in the same manner as .Net's Windows.Forms, but implemented differently on each JVM (i.e., wraps each system's native controls - The native Windows controls on Windows, usually GTK on Linux, and Cocoa on the Mac.)

Swing

Swing is Java’s themable UI framework, written completely in Java, using AWT’s most basic controls only, and built from scratch on top of than.

While this allows much nicer look and feels, Swing came too early and suffered from bad performance caused by the need to draw heavy graphics using a virtual machine on computers not strong enough at the time. This caused many developers to look for alternatives, and SWT was the most common one.

SWT

This one can be compared to the second version of Windows.Forms, or to wxWidgets, if you'd like. Based on each JVM implementation of AWT, makes a so called "Mix and Match" to create a better set of controls, that can run on each operating system and gains its native look and feel, while bringing large set of controls and maintaining performance by using the operating systems native controls.

X/XT/Motif

The 'X' Windowing System is the service that bring graphics and windowing operations to the Unix world. Like most windowing systems, this system is also based on a message loop and message dispatching, where each control is usually a window.

The X-Toolkit (XT) is a library helping to develop controls. It separates the control logic and design from the need to handle all the events passed to it from 'X', thus allowing vendors to focus on developing the controls themselves. Over time this approach has failed to persist, as no new control sets where created after Motif, and newer GUI frameworks (toolkits) had chosen to handle all events themselves, which also helped building cross-platform GUI frameworks.

Motif is the most commonly used set of controls that was build for the X-Toolkit framework, allowing large variety of controls for different aspects of GUI development.

Runtime testing and casting objects of generic types

2009-04-15T16:29:00.011+03:00

How can you tell, in runtime, if an object you have is of a specific generic type? For instance, if it implements the generic interface ICollection ?

You might say, "lets get all interfaces implemented by that object, first by getting its type (using GetType()), then by calling GetInterface(string name), passing in the type name in its mangled form".
This will work, however, this yields to error prone, non-type-safe code, plus, making us required to know how to build the relevant mangled string.

We would like something better. We would like to be able to get the generic type itself. Fortunately this can be easily done the following way:

Type genericCollectionInterfaceType = typeof(ICollection<>);

This will return the generic collection interface type. Now, what can we do with it? We wanted to test if a certain object implements this interface. However, a list of, say, strings, will NOT implement that interface. It will implement the ICollection interface, which is not the same as ICollection<>.

What can we do? We need to build, in runtime, a generic interface type that corresponds to the interface signature of our object:

Type testedObjectType = testedObject.GetType();
Type genericType = typeof(ICollection<>).MakeGenericType(testedObjectType.GetGenericArguments());

Then we can use that type to test for assignability:

collectionType.IsAssignableFrom(testedObjectType);

Calling MakeGenericType creates a new Type object that represents the type we are looking for. We pass it a list of types, in this case taken from the object itself (using GetGenericArguments). Then we can check for assignability between the two.

Lasers and experiments

2009-04-11T20:00:00.005+03:00

I tried to activate a laser diode today, that I disassembled from an old DVD player.
I used a cellphone recharger (outputs 5V) and connected the wires.
It worked for about half a second. I think it is now dead. R.I.P.
Anyone got old DVD/Bluray players they don't need?

The dead laser diode (on the right), and its original housing and controller.

The disassembled DVD player.

Creating customizable WPF drop-down menus (7)

2009-04-09T11:50:00.018+03:00

Step 7: Using the new binding correctly

Remember that we overridden OnDragEnter so the menu will open upon hovering? Well, we will have to make a slight change to that code, to (also) use our new property:

protected override void OnDragEnter(DragEventArgs e)
{
    IsSubmenuOpen = true;
    IsSubmenuOpenInternal = true;
    e.Handled = true;
}

Great! Except now the menu never closes. Well, the first occasion we want it to close is when we're done dropping. So we will add the following snippet to our OnDrop code, just before the e.Handle = true code:

if (parentMenuItem != null)
    parentMenuItem.IsSubmenuOpenInternal = false;

Another case when we want it to close is whenever a neighbor menu opens, or in case we stopped using the menu at all (like, clicking any other place). But the thing is, we really don't want to write such code, as it is already written. We need a way to find when the original property would change to false and do the same.
Luckily, there is a routed event just for that: SubmenuClosed.
We will register to that event, and change our new property to false likewise. Except, we do it with a minor change: we need to make sure we are not in the middle of a drag operation, or right in the drop handling code. We will register to that event in the constructor, and implement it:

public DraggableMenuItem()
{
    AllowDrop = true;
    SubmenuClosed += new RoutedEventHandler(DraggableMenuItem_SubmenuClosed);
}

void DraggableMenuItem_SubmenuClosed(object sender, RoutedEventArgs e)
{
    if (Mouse.LeftButton == MouseButtonState.Pressed || !IsDragging)
        IsSubmenuOpenInternal = false;
}

And that's it! The menu is now Drag-and-Drop customizable! Note that the code brought here in this article is for explanatory purposes only, and is far from perfect. Its goal is to explain the main issues and problems encountered while developing such a control, so use it as a reference only.

Hope you have found it useful, and please let me know if you did, and I'll be glad to hear about successful (preferably complete) implementations.

Creating customizable WPF drop-down menus (6)

2009-04-09T10:57:00.019+03:00

Why dropping doesn't work on sub-menus?

This question is actually the heart of the entire process. All we did until now was quite straight-forward.
So, why doesn't it work? To solve that I tried several debugging methods, but the one that really got me somewhere was to enable Reference Code Debugging.
So I found myself debugging deep into the WPF code, finding that during the drop operation, the result of the hit-test being performed is actually 'null'(!). More than that, it seemed like the native window holding the sub-menu wasn't even there (!!). How can that be?
Well, I couldn't debug much deeper than that, but thinking about how drop-down menus work, and how drag-and-drop mechanisms work, I figured that the problem must be that the sub-menu popup was closing before the drop operation hit test takes place.

This means that if I want to be able to drop things on a sub-menu, I need to build a new mechanism that will keep it open until AFTER the drop.

Step 6: Keeping the sub-menu open

Now it is going to get clear why I insisted on inheriting MenuItem (and be sure it will get worse, as we will need to change the default control template).

We will need to introduce a new Dependency Property that will enable us to better control whenever the sub-menu is open. Let's call this property IsSubmenuOpenInternal:

public static readonly DependencyProperty IsSubmenuOpenInternalProperty =
   DependencyProperty.Register("IsSubmenuOpenInternal",
                               typeof(bool), typeof(DraggableMenuItem),
                               new FrameworkPropertyMetadata(false));

public bool IsSubmenuOpenInternal
{
   get { return(bool)GetValue(IsSubmenuOpenInternalProperty); }
   set { SetValue(IsSubmenuOpenInternalProperty, value); }
}

In the XAML code, we will change the default style (this can be easily done using "Expression Blend") so the sub-menu opening state will now bind to our new property, rather than the default one.

I will not place here the entire XAML for the new menu item class, since it is just too long.
What you will need to do is to use Expression Blend to copy the default MenuItem style, then make the following changes:

Change the TargetType attribute to our new class type. Remember to add the relevant namespace declaration in the XAML declaration.
Locate the Popup element block, and change its IsOpen binding from IsSubmenuOpen to our new IsSubmenuOpenInternal dependency property.

Important Note:
If I could, I would of course rather override the default `IsSubmenuOpen` property, leaving the XAML as it is. However, this is impossible (at least in accepted methods, without using reflection), so adding this property really seems like the only way to go.

Now that the new bindings are in place, we can move on to the next post :-)

Creating customizable WPF drop-down menus (4,5)

2009-04-06T15:56:00.017+03:00

Step 4: Responding to drag hovering

Important Note:
In this part of the tutorial, we implement the draggable menu items that are static, and still in the menu, rather then the one being dragged. Keep that in mind, this is important.

We want our menus open whenever an item is dragged over them. The simplest solution would be to override the OnDragEnter method, and set the IsSubmenuOpen property to true.
This will work for now, but we will have to change that later, when we get to the drop-handling part.
Anyway, for now:

protected override void OnDragEnter(DragEventArgs e)
{
    IsSubmenuOpen = true;
    e.Handled = true;
}

Step 5: Handling drops

First we must accept drops. Lets implement the constructor:

public DraggableMenuItem()
{
    AllowDrop = true;
}

This code snippet set our draggable menu item to accept drops. Without this, it wouldn't be possible to drop anything on it, so we wouldn't be able to customize our menu.
Next we need to catch the drop operation, and perform the item movement logic. Of course we shall override and implement OnDrop. Note that we will need to extract the item being dragged from the DragEventArgs, and if it is a DraggableMenuItem, remove it from its current position, and place it just before the drop target:

protected override void OnDrop(DragEventArgs e)
{
    DraggableMenuItem draggedItem = (DraggableMenuItem)e.Data.GetData(typeof(DraggableMenuItem));
    DraggableMenuItem parentMenuItem = Parent as DraggableMenuItem;
    Menu parentMenu = Parent as Menu;
    ItemsControl itemsControl = Parent as ItemsControl;
    if (draggedItem != null && (parentMenuItem != null || parentMenu != null)) 
    {
        int i = itemsControl.Items.IndexOf(this);
        ItemsControl draggedItemParent = draggedItem.Parent as ItemsControl;
        if (draggedItemParent != null) 
        {
            draggedItemParent.Items.Remove(draggedItem);
        }
        itemsControl.Items.Insert(i, draggedItem);
        e.Handled = true;
    }
    base.OnDrop(e);
}

First attempt to test it all

Generally, while things don't look as nice as they can be, and might still be somewhat buggy, it looks like things should work.
Testing it reveals that dropping items on the menu bar level does work. However, dropping things on open sub-menus doesn't!
I will review the reason for that on the next post.

Creating customizable WPF drop-down menus (3)

2009-04-06T14:49:00.015+03:00

Step 3: Dragging items around

Once we have figured out how to detect the drag, we need to perform the actual dragging. Moreover, we want the menu to respond while we move around - hovering over a menu should cause it sub menu (if any) to open.

We will use the System.Windows.DragDrop helper class to perform the actual dragging.
The main method in the DragDrop class is DoDragDrop. This method is used to initialize a drag-and-drop session, perform the actual drag-and-drop operations, and returns the effect.

Initializing a drag-and-drop session

The DoDragDrop method takes 3 parameters:

A drag source (which will be our draggable menu item),
A data object, and
The allowed effects.

So as I mentioned, the drag source will be our draggable menu item. Since the code will be written as part of that menu item, we will just place there 'this'.
Our data source, while can be anything at all (as it is of type object), should be of type System.Windows.IDataObject, since otherwise it will be wrapped with a DataObject.
The best thing to do in this case would be to create a DataObject, and give it a unique name (or type), and the data itself. In our case, the data is the draggable menu item we'll be dragging, so the best unique id would be its type.
The only allowed effect, in our case, is the move effect, as this is what we want to do (at least for now) - move menu items from one place to another.

So if we implement the DoDragging method we left empty before:

private void DoDragging()
{
IsDragging = true;
DataObject dataObj = new DataObject(typeof(DraggableMenuItem), this);
DragDrop.DoDragDrop(this, dataObj, DragDropEffects.Move);
IsDragging = false;
}

Note that I raise the IsDragging flag before the dragging process begins, and lower it immediately afterwards. One reason for that is to prevent dragging to begin on other draggable menu items. Other reasons will become clear in the following posts.

Creating customizable WPF drop-down menus (2)

2009-04-06T14:43:00.007+03:00

Step 2: Detecting drag

Drag will start when the user had pressed the mouse button on an item and moved it enough distance in pixels while being pressed.
So, we need to know where the mouse was pressed, then track it all time it is pressed until it moves far enough:

public class DraggableMenuItem : MenuItem
{
private Point m_dragStartPoint;

public static  bool IsDragging { get; set; }

protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
{
m_dragStartPoint = e.GetPosition(this);
base.OnMouseLeftButtonDown(e);
}

protected override void OnMouseMove(MouseEventArgs e)
{
if (e.LeftButton != MouseButtonState.Pressed || IsDragging)
return;

Point p = e.GetPosition(this);
if (Point.Subtract(m_dragStartPoint, p).LengthSquared < 16)
{
e.Handled = true;
return;
}

DoDragging();
}

protected override void OnMouseLeftButtonUp(MouseButtonEventArgs e)
{
IsDragging = false;
base.OnMouseLeftButtonUp(e);
}

private void DoDragging()
{
}
}

Note that the IsDragging flag is a static flag, thus shared among all instances of the DraggableMenuItem. In the code sample above we do not yet assign it. This will be done in the next steps, in addition to some other places we will need to use its value to achieve the correct behavior.

Code Snippets (2)

2009-04-02T22:43:00.004+03:00

After I couldn't find a decent way to implement nice, colorful code snippets inside blogger (which holds me back from posing code related articles) as I mentioned in my last post, and after checking "CopySourceAsHtml" as suggested by Asher in his comment to my last post (and didn't like it - it creates HTML I really don't want to use), I decided to go on with writing my own converter.
I used the GOLD parsing system, along with the Calitha gold parser engine to parse source code of a given grammar (grammars for GOLD can be found here), added some metadata to that grammar (currently I've only done a proof-of-concept, so everything is hard-coded) that defines how to indent and colorize (HTMLize) it, and wrote this application:

(click to enlarge)

Next will probably be adding another language (C# - currently only tried it with XML), extracting metadata to external files (should see if I can merge it with the GOLD parser grammar files, and read it from there somehow), and making things look nicer, for starters.

The code is currently not available for download, but I'll probably start a project on sourceforge for that soon. I'll post an update when I will.

Code Snippets

2009-03-29T22:46:00.003+03:00

It seems like blogger does not support code snippets, and that its not as easy as I thought it will be to find some converters that will be able to convert my code into nice, colorful HTML syntax I can paste.

Time to write something that does just that, I guess.

Will probably build something generic, and base on the GOLD parser. It have good base code generators for various languages, including C#, so it seems like a good place to start.