June 22, 2009

Simplification of the puzzle prototype

Posted in Web tagged , , , , , , , at 11:36 pm by sagito

As mentioned before, I have been looking for a way of simplifying the puzzle architecture and encapsulate its functionality inside the Piece class. So now, in order to use this architecture, only two things are needed:

  1. Inherit the Piece class
  2. Call the Piece constructor with the Piece name. For example (from within a constructor): public _Default() : base(โ€Main Page Pieceโ€) {}

Only two steps are required now! The data is automagically filled in by calling the update() function, which searches the whole page for the sections of code, whose name matches the one on the file. For example, if I have an entry “news” in the configuration file and a div called “news” in the .aspx file, then the information will be automatically filled in. The code was largely reduced by using this new technique!


Prototype Puzzle Site

Posted in Uncategorized tagged , , , , , , , at 11:18 pm by sagito

After some (somehow simple) work, I managed to get my first prototype working. The site can be easily parameterized through the new piece’s configuration file. To ease my work, I prefered to avoid using XML and created a rather simple syntax, somewhat similar to a scene graph which describes the data to be transfered to the page.

On to the results, the basic page looks like this:

Basic site

This page’s class inherits directly from the Piece class, which searches for configuration files on every page_load and saves the new data internally. So, I created a small configuration file, as follows:

<li><a href=”#”>Puzzle system is now working!</a></li>

When I refresh the page, the content is automatically updated, and it is now as follows:


So, I decided to try out something different and also customize the top menu, and so, I fed the piece a new configuration file with the following:

| <a href=”http://www.google.com”>Google!</a&gt; |
<a href=”https://sagito.wordpress.com”>Tiago’s Blog</a>
<li><a href=”#”>Puzzle system is now working!</a></li>

Ready, we have a different menu on-the-fly, as shown below:


Thought this could be useful for when a piece wants it’s place in the top menu! ๐Ÿ˜‰ So, what must a normal page do in order to implement this architecture, so far? Very simple:

  1. Inherit the Piece class
  2. Call the Piece constructor with the Piece name. For example (from within a constructor): public _Default() : base(“Main Page Piece”) {}
  3. Get the desired information through getInfoNodeByName(string node). For example: InfoNode news = getInfoNodeByName(“news”);
  4. Fill the desired fields with this information. ๐Ÿ™‚

And it is ready to use! However, many os these steps are very complicated and should be automatic. Also, a piece must also generate automagically the configuration/data files, which are still created manually.

So, expect further updates very soon! ๐Ÿ˜€

June 21, 2009

ASP.NET Unit Testing

Posted in Web tagged , , , , , , , , , at 3:54 pm by sagito

Considering that the project that I mentioned in the previous post was developed for a real-world company (MDevices) and that it was developed for a discipline at the College of Engineering of the Oporto University (FEUP – Faculdade de Engenharia da Universidade do Porto), we had some rules that we had to obey. One of these rules, established by the professors requirements was to produce a test report for the application, which had to include Unit Tests.

However, we have faced a major problem. As we had used Server, Session, Request and Response objects, the Visual Studio 2008 unit testing platform just wouldn’t run. Why? Because apparently, although it was developed to perform unit testing on every kind of .NET projects, it didn’t run in a server context. What does that mean? We wouldn’t have access to server-specific stuff like Server, Session, Request, Response, Cookies and so on… I have searched throughout Google and MSDN just to find out that it just wasn’t possible. Some workarounds were available, which involved editing the web.config file, and I tried each one of them. Nothing worked. So, as the time disappeared, a differente solution had to be found. I tried using some other unit testing platforms, such as NUnit (which also did not contemplate web-based software) and NUnit-ASP which is now a dead project. Resharper looked like a good option at the start, but the very same problems appeared not long after the installation of this addin.

So, to solve this problem, I started studying the Visual Studio Expansibility API and developed a small Unit Testing Add-In for Visual Studio 2008. Based on some examples which I was able to find with the help of Google, this Add-In was quickly integrated with Visual Studio 2008. The big problem was to access the project and its contents. Google did not know too much about this, and it looked quite clearly that MSDN did not want us to know anything about that either. With some effort and a lot of time spent with trial-and-error, I discovered a way to access every solution item and through Reflection access its contents.

Ok, so I had the whole code available. What would I do with that? How could I test that in a server context? The idea was quite simple… My Add-In generated automated unit tests ย for each of the code files that the user chose and saved them in a new class file that was added to a new folder inside the solution. After that, it generated an .aspx and its code-behind files, which has a simple task: Call every test-class function, perform the tests and present the results.

So, when the project is launched, the Visual Studio’s Web Development Server would launch and we would have the server context that we needed. After that, it was just a matter of navigating to the generated folder and open the .aspx file contained within. It would show up in a new webpage the result of running all of the tests, because now it would run within server context! Of course that these automatically generated files could (and should) be edited, in order to suit the programmer and testers needs. But nevertheless, with this project, my team was able to save a large number of hours of work!

I will make this Unit Testing Add-In available, as soon as I make it prettier. It looks quite rough now, although it is totally functional! News about this project will become available in this blog very soon (I hope!), so keep visiting! ๐Ÿ˜€

June 20, 2009

The Puzzle Architecture

Posted in Web tagged , , , , at 11:42 am by sagito

Recently I had to develop a large and multidisciplinary web-based software system using ASP.NET and C# for an university course, which consisted in a Decision Support System. The development of this application was carefully planned in the very beginning of the project and was to be developed by a team of 12 students, in which I was included.

However, the application was composed of a large number of small parts which had to be integrated to work as one. As the project’s team leader I knew that the integration would not be as trivial as it should and we decided to start integrating some of the components right away. Truth be told that the integration was very positive because we put everything together from the very beginning. However, some of the features that should have been independent from the others turned out to be mixed in the end, in order to ease the integration of these parts. Although that did not seem to be a problem at the time, this now looks like a big mistake to me while doing the project’s post-mortem.

After reading the “Gang of Four” design pattern books and after having this experience, I decided to do a bit of investigation and try to develop a somehow different type of architecture. A large number of applications today use the concept of “plugins” as a way of extending themselves. Maybe the best example of this would be the Eclipse IDE or even the Mozilla Firefox Browser, which are largely extended by a huge ammount of plugins! However, to apply a plugin to the Eclipse IDE, I need to actually have the base Eclipse application. Same can be applied for Firefox. Plugins, as the name say, just fit into a bigger application and extend their functionality.

So, I intend to build an application that does not have a base. That is, it is composed of completely independent pieces which can be removed or added at any moment. This idea reminds me of a puzzle where a piece fits into some other pieces, but there is not a main piece! Every piece is just like every other piece with the difference that it adds a little bit of colour to the whole thing. Also, it can be removed or added at any moment and when looking at the big picture it won’t affect the rest of the whole puzzle.

Considering that each puzzle piece is now a small piece of software, how would each of the pieces know of the existence of the others? I consider this to be the main problem in this architecture style. My current idea is to implement this communication by using some kind of “hand-shake” XML configuration file that each piece must have and deploy when it is installed. Then, every other piece will attempt to read the file and try to see if it fits within its features and configurations. For example, the main page for a site could integrate a “News” section. This section would be implemented as another piece of the puzzle. So, the “News” piece would give the main page some configuration file, indicating how and where the data could be obtained from in the database (or some other data source, like an external file or some other site).

But now you could think: “Wouldn’t that imply that the main page would already have a space for a news spot?”. Although we could try to make the creation of this space dynamic, my answer is still “Yes, it would”. Because in a puzzle you still need to have a hole in one piece, so that the dent of some other piece can fit in, right? ;P

I will try to develop a system like this in ASP.NET, using C# as the code-behind language. Keep you posted… ๐Ÿ˜‰