However, let me state, that I do want to see Flex Builder 3 ported to Linux. I could then ditch my Windows Virtual Machine and run things natively, but that is my only complaint at this moment.

So why do I love Flex?
Flex is just easy to use, the components built it are amazing and you have the ability to build components on your own too! Much like Server Controls in .NET, .NET gives you a TON to begin with and you can create your own as well. However, this is for Flash! That is extremely important to acknowledge, as I do not have to have Macromedia Flash MX or whatever the latest version is on my PC to build a Flash application now.

Not only do I love being able to build a Flash application without Macromedia Flash, but I also love how it can work with an infinite number of backends without a lot of effort. Got a web service you want to plugin to? No problem, how about an RSS feed? Again, No problem. Well how about just a plain HTTP stream with a custom format? No Problem! I mean literally, you can plugin to any service that can send back a response. If it is a custom type of response, then you can write a routine to read your custom format. However, if you are using a Web Service, be in written in .NET and it returns an XML stream, then you literally have to do nothing! It will read it without any custom code from you, the developer. And that my friends is the “cream of the crop”.

So where do we go from here?
I am going to be doing a lot of things with Flex fromt his point on. I was just totally amazed by the simplicity and yet the complexity you can have within it. I still have a lot to test. Updating the grid’s data when it has changed, and similar events. But time will tell and so far Adobe has bought me back with this wonderful technology. Just bring it to Linux and I will move right next to your head-quarters Adobe!

To keep a long story short, the architecture I used was not followed in this piece and now I am paying the price for something I didn’t do. The original code was developed so the code would do 50-70% of the work for me dynamically. Yes, this has performance cost implications but they were minimal (1-2 seconds at best), but the time it saves is nearly 60-75% of development time.

Now the particular piece I am referring to does a lot of output work. It takes the data inputted by the user and develops a results page to the user describing the information the user typed. Now, to make my life easier, I build a hash table of the user’s values and associate them with a code. The code is related to a table that defines the text to display regarding that entry.

By creating code to associate the hash table data with the database table, the results page can be generated dynamically saving me the countless time of programming each possibility the user can come up with.

Thus, sometimes it is smarter to go a dynamic route at the cost of performance, than it is to develop the most efficient masterpiece you can imagine.

That is my food for thought.

If you do this, you are guaranteed the following:

1. It is easy to maintain and understand the code you wrote months later
2. Chances are your application will not be the quickest in response
3. You will make use of techniques you fully understand than trying to adapt ones that you are unfamiliar with and may implement wrong

So how does JSON differ from returning XML in your AJAX requests? Lets first look at the advantages of XML.

1. Standardized and easily serialized into via .NET
2. The XML is easy to read all within itself
3. You can make use of XSLT, DTDs, etc

How about disadvantages of XML?

1. It is slow in comparison to JSON
2. It can be clumsy when not designed properly

Now for the advantages of JSON:

1. It is faster than XML to parse in JavaScript
2. There are addin’s you can install in .NET or a library in PHP to serialize a JSON string from an object
3. It is hard to make this clumsy as it is based on the Object Design

And the disadvantages of JSON:

1. It is harder to read the serialized output
2. You can’t use XSLT, DTDs, or something of the sort to validate or style the request

As for myself, I am a JSON person. I didn’t used to be though. My original AJAX applications were focused around XML primarily because I could make use of an XSLT and I always validated against a schema. However, JSON has won me over due to speed. JSON’s speed is just ridiculously fast and it showed when I converted a major application over to it. I saved nearly a third of the time it took to do a fairly simple task.

However, pick the poison that you understand most, otherwise, it could have detrimental affects.

Kiosk, uses Ajax in interesting ways to provide a better experience, but with that, the Ajax applications were built as each page was assembled. This caused functionality across pages to get a bit messy or functionality shared across pages to get thrown into individual files. Well the problem with individual files, is that is yet another file for the browser to download.

So before I get any further, let me discuss refactoring and how it can solve many performance binds your application may be experiencing.

To start off, refactoring is taking common code, or code that is used across pages or frequently and moving it to a more global location so it can be called easier and the code only has to be written once.

So where can this help?

• First of all, by refactoring code into a single global file, you can limit the number of HTTP requests if that file is accessible via the web. Since your common code is in a single file, the browser only has to fetch that code once, and will then likely cache that file for each page after, giving you even better performance.
• Secondly, by placing the common code in a global method/function, you are writing less code. As now when you need to call that code on your second page, it is already written, so just call the function. Otherwise, you would need to write the code all over again.
• Thirdly, less code equals smaller files. By refactoring your code, you can have smaller file sizes and in turn that is quicker to download, quicker to parse, and quicker to execute.

Now in my situation, I took about 4 JavaScript files and combined them into a single file adequately named “general.js”. The file contained code to automatically log the user out after a set amount of inactivity in the UI (User Interface). Secondly, it contained the version checking mechanism calls that see if they are running the latest version of the software. Unfortunately, those are the only two things it does right now, but as the project progresses, I am sure more utilities will get added in this file.

My next task is to refactor the Data Grid functionality so it is 1) XHTML, 2) easy to build complex columns with complex rows, 3) customizable by identifying StyleSheet classes for the columns and rows. Hopefully, I can get my head around this idea and get it working with little trouble to the programmer.

So what can you think of that you need to refactor? What performance gains do you suspect you will achieve with the refactoring you do? Any performance markers?

Since everything in the quote is a server control, it was just drag and drop the controls onto the Custom Default page and it would act 100% like it does in the quote. It could not have gone any faster, I probably only spent close to 5 minutes setting up the design and flow and 30 minutes getting the code behind functionality to work.

Thus, harness the power of Server Controls as they can be reused across numerous applications with little trouble and little programming.

The problem gets worse when you try to submit the form to another page by overriding the form’s action. This throws an “ViewState is corrupt or invalid for this page.” error. We finally got around it by hacking a JavaScript event to empty the “__VIEWSTATE” hidden field so it had nothing in it before the form actually submitted the page. But is that the only way to get rid of ViewState?

Code to cause ViewState corruption:

<script type="text/javascript">
    window.onload = function()
    {
        document.getElementById('Form1').onsubmit = function()
        {
            document.getElementById('Form1').action = '/another_project/another_page.aspx';
        }
    }
</script>

How, we got around it:

<script type="text/javascript">
    window.onload = function()
    {
        document.getElementById('Form1').onsubmit = function()
        {
            var inputFields = document.getElementsByTagName('input');
            for (var i = 0; i < inputFields.length; i++)
            {
                if (inputFields[i].name.toUpperCase() == "__VIEWSTATE")
                {
                    inputFields[i].value = ""; // Empty the ViewState hidden field to stop it from carrying on to the next page
                    break;
                }
            }

            document.getElementById('Form1').action = '/another_project/another_page.aspx';
        }
    }
</script>

Anyone else have a problem like this? ]]> http://cpradio.org/work/viewstate-is-it-working-properly/feed/ 0 http://cpradio.org/work/consolidate-or-to-not-consolidate-your-projects/ http://cpradio.org/work/consolidate-or-to-not-consolidate-your-projects/#comments Mon, 06 Aug 2007 21:39:40 +0000 cpradio http://cpradio.org/work/consolidate-or-to-not-consolidate-your-projects/ Today we had a meeting going over a few future projects and it was brought up we could integrate the new project into an existing project that had 80% the same functionality. However, there comes a lot more complication with this short of merge.

For example, what happens if two people are working in the same project on two different pieces. The first person is finished with their piece and checks it in happy as can be, while the second person finishes later and his change needs to go in ASAP, while the first person’s change can’t go in till the end of the month. Now what?

Now in a perfect world, one would state that the first person shouldn’t check in their code till it can go in, or person two would get the previous version of the first person’s code.

At work we decided to keep the projects separate and not consolidate them even though it would share 80% of the functionality for the UI. But in the end, it allows us to not step on each others toes.

So my question is, how do you handle this?

Take this for example. Let’s say you want to collect a person’s name and possibility two people’s names. How would you do it? If it were me, I would have a text field for the first name, one for the middle initial, and another for the last name. Thus I know if their first name is two words, their last name is two words, or maybe it is just normal and its “John H. Doe”. Nonetheless, I would know which words correspond to each part of their name.

The software, of whose communication I am bridging does not do this! No, they have a single text field that is free form. So you could type “J Howard Doe” or “John H Doe” or “John Howard Van Nilsen” or “John Nilsen and Cindy Nilsen” and it would accept it. What I am supposed to do with this? Notice the last example! This is how they are supposed to enter two names… Am I just totally crazy or is this the weirdest UI you have ever heard of?

Now, I have done a fairly good job at figuring out the names, and it works probably 98% of the time, and can’t really account for the other 2% because of the crazy way the names were entered. Now, the biggest idiosyncrasy of this whole ordeal, is there is another part of the UI that has a ‘name’ entry too. You would think the software would handle that ‘name’ entry the same as the first part of the UI. BUT YOU WOULD BE WRONG! No, it handles it entirely differently and just throws my world in a whirlwind as I try to figure out what to do with this data. For example, if the user entered in “J Howard Doe” on the first screen and “J Howard Doe” on the second, my piece receives the following: Data from First Screen: “J Howard Doe”, Data from Second Screen: “J H Doe”. WTF!! Why the hell was it handled differently?

Welcome to my week.

Now, I know what you are thinking. You have too many of its features enabled. Duh, it will be slow, it comes with nearly everything in it enabled. But you are wrong. I have disabled nearly everything! I disabled the Smart Copy/Paste, the Smart Return, the Templates, the Hints, EVERYTHING except the Flow indicators and the line counting per method (that is just a nice feature). However, whenever I do a copy paste, it acts like the Smart Copy/Paste is enabled and it takes 2-3 seconds before I can move the cursor again!

So just to warn everyone, CodeRush can cause you to actually be less efficient. You will sit and wait for you to be able to move the cursor again for countless seconds. Take it from me, it isn’t worth it and its definitely not worth $250.00!

The bridge I had been working on for months, has had three known issues all that were complicated in various ways, or at least that is what my brain told me. For the past few days, I have been working on a different project and thus my mental focus was not even close to this bridge application. Today, I started to work on the remaining issues and things just snapped. I knew exactly where to look to find the communication issues and I knew exactly what was necessary to solve them. I got through one of my biggest issues (which had 5 minor issues attached to it) throughout the morning. Come afternoon, I was working on the second and third problem (of which I had a meeting about with two other developers) and I got really close to solve the second issue, but then my brain was back to playing tricks. It just decided it couldn’t figure out the issue entirely.

That was fine by me. Within the first 30 minutes of our meeting, one of the developers had it solved and I had the code written and proven to work. Another 40 minutes later, the final issue was resolved. This is TIP #2. A look from a second or third developer will eventually leave you with less headaches, as they will see what your brain has decided not to see. It has been proven that your brain can play tricks on you. The code you are seeing with your eyes might not really exist, but your brain knows that is what you were expecting to see, so that is what it presents.

I forget the technical term for this behavior, but you can easily read about it in any psychology book. Most of the examples use patterns, with missing pieces and your brain magically fills in the piece that was missing. Finally, Tip #3, is do not forget Tips #1 and #2! I cannot stress that enough. Without the first two tips, you will eventually break down. As a programmer, cope with asking others to look at your code and determine what is wrong. It does not mean you are a bad programmer.