Black Falcon Software Presents: Localizing Your Web Applications

Black Falcon — Tue, 01 Dec 2009 21:17:33 +0000

Many solutions have been offered providing localization solutions to web applications. However, when it comes to large amounts of content some of these solutions that rely on resource files may not be sufficient. Instead, database storage is required to incorporate large amounts of text that have to be displayed on a web page in various languages.

The design of a relatively robust solution to this issue is somewhat easier than expected and with the following code can provide not only a simplistic solution for all such localization requirements but a rather efficient one as well. Surprisingly, the database calls needed to extract the content in a selected language do not slow responsiveness down noticeably even on a shared hosting server.

To implement this solution, simply follow the suggestions below…

The Database

The database requires only a single file than can be indexed in both the form name and the control name. The basic database structure then looks as follows:

           FORM_NAME         char(30)
           CONTROL_NAME      char(40)
           COUNTRY_CODE      char(3)
           LOCALIZED_TEXT    varchar(max)

This simple table will allow you to insert data for any form, for any control that displays text, on a per language basis, which is usually denoted by a country code. Of course, you have to get the data in their, which for the first three columns is quite easy. It is the last one that will take time.

The content that is placed in the “LOCALIZED_TEXT” field should not be simple conversions of English to another language using either free online translation software or a purchased translation application. Such software is only good for short phrases. Using it for translations of substantial text will only provide the reader with a very poor representation of the original English. This is because translation software cannot provide the nuances that credible translators can. As a result, using such a methodology will only be a detriment to your web application. Thus, if you plan on presenting a site with multi-language capability, take the time to make sure that all your translations are done correctly and thoroughly.

The Web Page

With Microsoft’s master-page framework you can now easily place your language controls in a single page that will be inherited by your child web-pages. The most common way of informing a visitor to your site that you offer multiple languages is with a strip of country flags such as shown below.

In this case we are showing the flag for the United States for English and the Austrian flag for German.

Each one of these images can be implemented as an ASP.NET image-button with some basic code in the code-behind page for every country flag image as follows:

   private void imgbtnUSA_Click(object sender, System.Web.UI.ImageClickEventArgs e)
   {
     Session.Remove("country");
     Session.Add("country", "usa");
     Localization_BySelectedCountry();
   }

The use of the “session” variable using the default implementation (inproc) for web development is not recommended if you plan to host your web application in any type of clustered server solution. If this will be your hosting architecture you must set up your session state with either a state server or a database.

What is being shown here is the most basic of code and it will not necessarily fit your specific requirements. However, you have to store the selected country code some where that is global to the entire application so that any page being displayed can determine what language any text is to be displayed in.

Extracting Localized Text From The Database

In addition to flipping the displayed language when a language selection has been changed, upon the “Page_Load” process for any web page in the application the following code should then be implemented for each and every control on your web page that requires text display.

   private void Localization_BySelectedCountry()
   {
      string               lsCountryId = Session["country"].ToString().Trim();
      clsLocalizations  loLocalizations = new clsLocalizations();

      imgbtnHome.ImageUrl = loLocalizations.Localize_Text("frmHome", "imgbtnHome", lsCountryId);
      imgbtnAbout.ImageUrl = loLocalizations.Localize_Text("frmHome", "imgbtnAbout", lsCountryId);
      imgbtnProducts.ImageUrl = loLocalizations.Localize_Text("frmHome", "imgbtnProducts", lsCountryId);
      imgbtnOpenSource.ImageUrl = loLocalizations.Localize_Text("frmHome", "imgbtnOpenSource", lsCountryId);
      imgbtnLinks.ImageUrl = loLocalizations.Localize_Text("frmHome", "imgbtnLinks", lsCountryId);
      imgbtnContact.ImageUrl = loLocalizations.Localize_Text("frmHome", "imgbtnContact", lsCountryId);
      imgbtnMyAccount.ImageUrl = loLocalizations.Localize_Text("frmHome", "imgbtnMyAccount", lsCountryId);
      imgbtnTechNews.ImageUrl = loLocalizations.Localize_Text("frmHome", "imgbtnTechNews", lsCountryId);
      lblPageDesignation.Text = loLocalizations.Localize_Text("frmHome", "lblPageDesignation", lsCountryId);
      lblProductNote.Text = loLocalizations.Localize_Text("frmHome", "lblProductNote", lsCountryId);
      lblImageButtonInfo1.InnerText = loLocalizations.Localize_Text("frmHome", "lblImageButtonInfo1", lsCountryId);
      lblImageButtonInfo2.InnerText = loLocalizations.Localize_Text("frmHome", "lblImageButtonInfo2", lsCountryId);
      litText.Text = loLocalizations.Localize_Text("frmHome", "litText", lsCountryId).Replace("''", "'");
      lblImageButtonInfo3.InnerText = loLocalizations.Localize_Text("frmHome","lblImageButtonInfo3", lsCountryId);
      litText1.Text = loLocalizations.Localize_Text("frmHome", "litText1", lsCountryId).Replace("''", "'");
   }

Notice that the code above will call the database for each control you need to display text for and extract the currently selected language.

This by no means is a very efficient way of doing things if you have a site that is going to be visited heavily. In this case, you should cache your language data into the application level cache for much more efficient access. Otherwise, for lightly visited sites, despite the protestations by some, the database IO required will not be an issue.

Now, the actual call to the middle-tier code that gets your text for you was designed to be very simple. However, it can be made far more efficient, whereby you require only a single call to the database thereby returning all of the needed text to the web-page’s code-behind module where it can then be loaded into the various controls. However for starters let’s just take the original code as designed.

The call in the previous code-segment makes a call to a localization object, which is user defined, for the following method code…

   public string Localize_Text(string psWebformName, string psControlName, string psCountryCode)
   {
      ArrayList                                                 loArrayList = new ArrayList();
      BlackFalconSoftware.Structs.strLocalization  loLocalization = new BlackFalconSoftware.Structs.strLocalization();

      loArrayList = Get_LocalizationData(psWebformName, psControlName, psCountryCode);

      if ((loArrayList == null) || (loArrayList.Count == 0))
      {
        return (null);
      }

      loLocalization = (BlackFalconSoftware.Structs.strLocalization) loArrayList[0];

      return (loLocalization.BFS_LOCALIZED_TEXT.Trim());
   }

And the method above in turn calls the following method, which actually extracts the data…

   private ArrayList Get_LocalizationData(string psWebformName, string psControlName, string psCountryCode)
   {
      string          lsSQLConnectionString =  ConfigurationManager.AppSettings.Get("SQLConnectionString");
      ArrayList       loArrayList = new ArrayList();
      StringBuilder   loStringBuilder = new StringBuilder();
      SqlDataReader   loSqlDataReader;
      SQLHelper       loSQLHelper = new SQLHelper("snaidamast", false);

      loStringBuilder.Append("select *");
      loStringBuilder.Append("  from LOCALIZATION");
      loStringBuilder.Append("  where FORM_NAME = " + "'" + psWebformName + "'");
      loStringBuilder.Append("     and CONTROL_NAME = " + "'" + psControlName + "'");
      loStringBuilder.Append("     and COUNTRY_CODE = " + "'" + psCountryCode + "'");

      try
      {
         loSQLHelper.ExecuteDataReader(lsSQLConnectionString, loStringBuilder.ToString().Trim(), out loSqlDataReader);
      }
      catch (Exception loException)
      {
         return (null);
      }

      try
      {
         while (loSqlDataReader.Read())
         {
            BlackFalconSoftware.Structs.strLocalization  loLocalization = new BlackFalconSoftware.Structs.strLocalization();

            loLocalization.FORM_NAME = loSqlDataReader.GetString(0).Trim();
            loLocalization.CONTROL_NAME = loSqlDataReader.GetString(1).Trim();
            loLocalization.COUNTRY_CODE = loSqlDataReader.GetString(2).Trim();
            loLocalization.LOCALIZED_TEXT = oSqlDataReader.GetString(3).Trim();
            loArrayList.Add(loLocalization);
         }
      }
      catch (Exception loException)
      {
         loSqlDataReader.Close();
         loSqlDataReader = null;
         loStringBuilder = null;
         loSQLHelper = null;

         return (null);
      }

      loSqlDataReader.Close();
      loSqlDataReader = null;
      loStringBuilder = null;
      loSQLHelper = null;

      return (loArrayList);
   }

Note: There is no need to null out local objects. The CLR will take care of them during garbage collection.

Admittedly, the code in the previous method does not serve efficiency very well. It merely returns a single structure of data in an array-list for each call from the “Localization_BySelectedCountry” method, which was the first method introduced in this section. As was mentioned previously, this code was designed very simplistically. And the code works quite well.

However, to implement efficiency we simply enhance the code to return all of the data for all controls in the database query, thus extracting the data simply based upon the “FORM_NAME” instead of both the “FORM-NAME” and the “CONTROL_NAME”. This would then return an array-list of all relevant structures from a single query to the database. These structures can then in turn be used to supply the data for each control by merely looping through the associated array-list and load the controls based on their names.

As a result the “Localize_Text” method, also shown above, would then return the array-list of structures back to the primary calling method, “Localization_BySelectedCountry”. Then instead of using individual database calls to extract the data, replace these calls with a call to a loop process that would extract the data from the structures in the array-list, an array-list, which by the way, can be cached in the application cache.

Using Structures Over Datasets\DataReaders

Using a structure (or a class, whichever is preferable) to represent your data within an array-list is probably one of the most effective ways of transferring the data between tiers while at the same time keeping its use highly intuitive since you do not have to worry about the more arcane methods of accessing it with either Datasets or DataReaders. structures then are the basis for Object Relational Mapping (ORM) systems that also tout such intuitiveness as its strongest feature.

The problem with using structures is that they are tied to the underlying data and if anything substantial is changed in that data structure so too must be the structure or class be changed, changes which also ripple right up to the front-end in most instances. This is where ORMs fall flat on their faces as well as the use of structures even in the case demonstrated here.

However, in this case we are talking about an underlying data structure that has very little chance of being changed over time since it is designed to serve a single purpose, provide data for display. What will change of course is the actual data but this is a part of the text column and his little to do with the mechanics of displaying it.

Structures and\or classes are a very good way of keeping your data intuitive and at the same time adhere to the OO concepts of data encapsulation. What more perfect OO concept can there be but data as an object?

In this framework, a simple structure is used and it is loaded at the lowest level in the calling process which is exactly where it should be loaded. The structure here is as follows…

  public struct strLocalization
  {
     private string  ssFormName;
     private string  ssControlName;
     private string  ssCountryCode;
     private string  ssLocalizedText;

     public string FORM_NAME
     {
       get
          {
            return (ssFormName);
          }

       set
         {
           ssFormName = value;
         }
     }

     public string BFS_CONTROL_NAME
     {
        get
           {
              return (ssControlName);
           }

        set
           {
             ssControlName = value;
           }
     }

     public string BFS_COUNTRY_CODE
     {
        get
           {
             return (ssCountryCode);
           }

        set
           {
             ssCountryCode = value;
           }
     }

     public string BFS_LOCALIZED_TEXT
     {
        get
           {
              return (ssLocalizedText);
           }

        set
           {
             ssLocalizedText = value;
           }
     }
   }

As you can see it is very simple and quite light when compared to a Dataset or a DataReader. And it serves the purposes here perfectly.

Thinking In Terms of Efficiency

A number of readers may consider that there may be a better way than what has been just demonstrated. However, when you think about it, exactly what would be better? You have to store the language text some place so in that respect it doesn’t matter whether you store it in a database or a resource file; you are going to have some level of data IO. Next, you have to appropriate such data on a per control basis. And it doesn’t matter whether you do this yourself in this way or through a third-party tool that does it in a way proclaimed to be highly efficient. In either case the data has to be matched to the control and then loaded into it.

The most readily available way to make such processes efficient is to use the application cache since in this case the data is completely static. And this was already discussed.

However, when we talk in terms of efficiency we have to also denote exactly what we are talking about. Efficiency in present day conceptualization appears to concern itself with the speed at which instructions are being processed if we are talking about code or query optimizations if we are discussing database access.

In both cases, the argument is rather moot since what is being contended with are speeds that are so fast that there is very little one can do to make code more efficient than what the compilers and optimizers will already do for you. Both the .NET CLR and the database optimizers are very difficult to beat even if you were to implement just average code. It is all taken and manipulated for the best effect. And you would have to write some seriously bad code to produce less optimized results.

All of this can be demonstrated very easily with code profilers and query plans. You will find that if you test out different coding scenarios you will save nothing more than a few milliseconds for each of the processes submitted. In some cases you will find that quite a few milliseconds are saved and for very intensive database access such optimizing may be called for. However, for the most part It is hardly worth refining your code on this basis.

True efficiency in the Information Technology field has very little to do with the speed of your code or your data queries. This is a myth that has been propagated by newly graduated computer science students and academics from across the globe where they have been taught or teach the details of compilers and development related to such concepts. In fact, the overriding software engineering criteria for distributed application development is in fact not speed but concurrency. Given the fact that the Internet is a massively used distributed application, the concept of performance in terms of speed is nearly impossible to realize since the majority of impediments to acceptable response rates is not code-based but physically based. In other words, the physical architecture of where your application is residing is the overriding determinant to the level of performance that can be expected. True, there have been numerous “tricks” that have been added to enhance such performance, such as AJAX, but a server request is still being made, even if less data is being returned.

Real efficiency is where the software that is developed saves the company monies on its investment in its development. So for real world considerations software efficiency then falls into those areas that Software Engineering holds as important milestones in software creation.

For example…

Does the final product have a low defect rate?
Is the code legible in terms of neatness and commenting?
Is the code easy to read and understand for even a junior level technician?
If the code is a large system, is the design intuitive in terms of understanding it?
Does the installed application run without producing any issues?

If you can provide affirmative answers to the questions above for a particular piece of software that you have developed than you can safely say that you have produced an efficient piece of software. It not only does the job but it does so in a manner that is easily understood, maintained, and thus enhanced. This then is true efficiency and it is this level of ease that went into the design of the code presented. It has no defect level, it works well, it can be tuned for greater efficiency in terms of access, and it can be done so quite easily…

Black Falcon

The code presented here can be downloaded from the following link… Download Article Source Code

This code also uses Black Falcon Software’s “SQLHelper” component, which can be downloaded here… Download “SQLHelper”

OSGi and Web Applications

servicetesting — Tue, 01 Dec 2009 15:23:30 +0000

To improve my information application I decided to change the user interface from a swing-GUI to a web-based system.

Here are the most important web links that helped to realize OSGi web application development:

Hello, OSGi, Part 3: Take it to the server side

Immediately after starting, you will need the HttpService. Because I use the Felix implementation of OSGi, I needed the Apache Felix Http Service, as well as a Jetty bundle.

After installing all required bundles and configuring the OSGi environment as well as Jetty, a quick start-off with Java Servlet Programming does not hurt.

Java Servlet Programming O’Reilly

For the busy once, a Story of a Servlet: An Instant Tutorial, will be quicker.

A hands-on, refreshing your mind example servlet is given here or a short course from Sun.

To elaborate the basic skills, the “Developing Scalable, Reliable, Business Applications with Servlets” article can help.

Developing Scalable, Reliable, Business Applications with Servlets

We call it OPA

yoric — Sat, 28 Nov 2009 19:15:55 +0000

Web applications are nice. They’re useful, they’re cross-platform, users need no installation, no upgrades, no maintenance, not even the computing or storage power to which they are used. As weird as it may sound, I’ve even seen announcements for web applications supposed to run your games on distant high-end computers so that you can actually play on low-end computers. Go web application!

Of course, there are a few downsides to web applications. Firstly, they require a web connexion. Secondly, they are largely composed of plumbing. Finally, ensuring their security is a constant fight.

How many pipes do you need?

If you have ever developed a web application, you know what I mean by plumbing: just writing an online TODO list — the equivalent of maybe twenty minutes of work in Visual Basic, in Python, Java or Objective-C — requires mixing an insane amount of languages, to define your user interface (HTML, JavaScript, CSS), to define your storage (DDL, DML, DCL, plus possibly an ORM language), to get your server and your client to communicate (XML, more JavaScript, PHP or one of its competitors, as well as some HTTP and a little MIME configuration), to launch your application (whichever configuration languages are used by your server). Of course, if your application is a bit more complex and requires something like compatibility with smartphones, or like distant storage, or distributed computing, or backups, or modularity (in the world of the web, it’s called “web services”)… well, you will probably require a few additional languages.

All of this is just plumbing. Only once you have written it can you concentrate on the core of the application. And once the application is written, the pain is just starting, because chances are that your application can be attacked by hijacking the link between your user interface and the core (cross-site scripting) or between the core and the storage (SQL injection) or by keeping the user interface and replacing the application core (man-in-the-middle attacks) or by replacing the user interface by a malicious client or by taking the place of a currently connected user to steal some of its credentials (rebinding) or by taking advantage of low-level bugs (buffer over/underflows), etc.

None of this is a show-stopper, of course — just take a look at the web and you will see thousands of web applications. Just like the complexity of Software Development Kits in the early days of Windows, MacOS or X didn’t stop adventurous hackers from developing desktop applications. But of course, if twenty-five years of desktop application development have taught us one thing, it is that the life of developers can be made easier. Nowadays, a few generations of SDKs later, Windows developers have .Net, C# and Visual Studio, Macintosh developers have Cocoa, Objective-C and XCode, while X-based developers have the libraries of Gnome/KDE, Python and a variety of programming environments. The growing popularity (and libraries) of Haskell, F#, OCaml, Scala and other functional programming languages could mean that one of the next generations of SDKs will increase safety and security.

The web hasn’t quite reached that stage yet. Even the state-of-the-art in web frameworks only provides features slightly more advanced than early Windows/Mac/X SDKs: low-level bindings for low-level mechanisms, designed to ensure low-level properties. Or, rephrased differently, in the current state of web development, GMail, Google Maps or Facebook are still considered complicated applications, although they are conceptually quite simple and should therefore be equally simple to implement.

We can do better. How? By removing the need for plumbing. By providing automated mechanisms for ensuring high-level security properties. By providing language support for common patterns.

Enter OPA

Let me introduce OPA. OPA, or One Pot Application, is a complete development platform for web applications and web services. Development in OPA requires no plumbing. Applications developed with OPA are automatically checked for safety and security before they are executed. Applications developed with OPA are automatically (and provably) immune to cross-site scripting, to SQL injections and to most existing forms of attacks. And OPA provides language support for storage, communication between client and server (Ajax and Comet), concurrency, distribution, mobility, etc.

With OPA, we intend to skip several generations of SDKs and provide right now a high-level and modern programming platform. OPA has been 6 years in the making: 4 years of sketches, mockups and prototypes as part of academic research projects and 2 years of actual implementation at MLstate. A few days ago, OPA has officially entered demonstrable status. Not quite ready for prime time, but definitely usable for development. Do you want to write an online note-taking application? That’s about 20 lines of code, from scratch. A minimal chat? About 30 lines. A multi-channel, distributed chat? About 80 lines. A minesweeper? About 100. We’re using it to develop utilities, content management systems, tools for administrations and games.

Pre-alpha builds of OPA have been distributed to selected partners. A public version will be made available within a few weeks, as well as commercial applications developed with OPA. In the meantime, we are busy improving the syntax, completing the standard library, making error messages intelligible, fixing the bugs and extending the range of safety and security checks.

Interested? Well, few details are public at this time. However, you can take a look at a video recorded during ICFP presenting OPA and MLstate.

Stay tuned.

Web Application Deployment Descriptors web.xml

numberformat — Sat, 28 Nov 2009 16:37:29 +0000

This page is about how the web.xml header should look like for various versions of Java Enterprise Applications.

The following URL contains information about deployment descriptors for the Java Enterprise Applications.

web.xml for a Java EE 6 application

<web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

     <display-name>Sample Web Application</display-name>
</web-app>

Java EE 5 application

http://java.sun.com/xml/ns/javaee/index.html

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">
<display-name>Sample Web Application</display-name>
</web-app>

For J2EE 1.4

http://java.sun.com/xml/ns/j2ee/

Enhancements

Built in support for JSTL

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4">

    <display-name>Sample Web Application</display-name>
</web-app>

For J2EE 1.3

http://java.sun.com/dtd/

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
<display-name>Sample Web Application</display-name>
</web-app>

Decos Case Studies

Decos Software Development — Tue, 24 Nov 2009 09:08:35 +0000

BizTalk Custom Pipeline Components

Business Case:

A Sweden based ICT Company were facing a problem in archiving of invoice message (TIFF files). They had to do many manual processes for the archiving which required automation.

Requirement:

The requirement of the client was to create a custom pipeline component in BizTalk to support archiving of invoice message (TIFF files). The proposed solution has to interact over secure FTP (SFTP). The invoices have to be transferred to the second party and acknowledgement of the receipt is to be recorded. If there is any error in the process then it has to be notified by email. A strict requirement was that the invoice and accompanying files should be transferred as a single set. If there is any error then the sending of invoice should be cancelled and notified by email.

Decos Solution:

BizTalk Pipelines allow you to customize the processing of XML documents received or sent via the various BizTalk adapters. Custom Pipeline components extend the behavior of Pipelines to include processing data of virtually any format. They can be a powerful solution if you support legacy systems that require integration with other products, but your legacy data format does not follow standards. It may contain carriage returns in odd places or records spanning any number of lines of text, for example. The only stipulation is that the data emerging from the Custom Pipeline must be some form of XML document.

The client’s requirement was to build custom pipeline component in BizTalk to support archiving of invoice message. The invoices which were TIFF files were generated at the client’s side. First step taken by Decos Team was creation of windows services to interact with SFTP server at source and destination sides. And then the Enhancements to third-party nSoftware component were done to search/create directories recursively. To complete a Pipeline, one or more Pipeline components from within Visual Studio .NET were needed to be selected and then they can be added to the Pipeline. None of the existing BizTalk Pipeline components satisfied the client requirements, so Decos had to build a custom pipeline component. A custom pipeline component for archiving the invoices was created. After creating the custom Pipeline component, the pipeline was deployed to the C:\Program Files\Microsoft BizTalk Server 2006\Pipeline Components directory so the custom Pipeline component can be added to the Pipeline in the BizTalk 2006 project. After deploying the custom Pipeline component, the component was added to the Pipeline component toolbar. The logic in BizTalk Orchestrations was implemented to ensure that files are received as a single set and error conditions are detected and notified. Technologies being used for this solution: BizTalk Server 2006 R2, nSoftware SFTP adapter, SSH library

The Result:

Decos team delivered this solution in 20 days and is currently working on the development of additional features. Client was delighted to have an advanced solution based on Biztalk Server 2006 to get relief from their pain area of archiving the invoice messages.

GET A FREE QUOTE

more: www.decos.in

Why web apps are the future of business

Christian Burger — Tue, 24 Nov 2009 06:10:49 +0000

More details about what's in OneNote 2010

marcuslovesonenote — Tue, 24 Nov 2009 01:20:50 +0000

Ok, so I didn’t have to bribe, beg, borrow or steal to get this breaking information about what we can expect in OneNote 2010.

Dave Rasmussen from the OneNote team posted this yesterday:

Be sure to tell us which new features you are the most excited about in the comments area below. Personally, I can’t wait to get my hands on the full version.

OneNote 2010 Investments Overview

1. Universal Access

We repeatedly hear that access to your notes and the ability to take them anywhere is very important, whether you’re at work, home or on the go. OneNote 2007 already provides offline availability and seamless sync, and a basic OneNote application for Windows Mobile. But we knew that was just the beginning. With OneNote 2010 we’ve added:

Sync to Cloud (Windows Live): Your notebooks sync and are available anywhere from any machine. Of course this is in addition to all the existing ways you can sync notebooks (file shares, SharePoint, USB drives etc.)
OneNote Web App: You can access and edit your entire notebook from a browser. Even on a machine that doesn’t have OneNote installed.
OneNote Mobile: A more complete OneNote version for Windows Mobile phones. Syncs whole notebooks. Syncs directly to the cloud. No need to tether your device. Richer editing support.

Note: The above are not yet available in the Tech Preview unfortunately. We’re still finishing some integration work for sync to Windows Live.

2. Sharing and Collaboration

With OneNote 2007 we pioneered simultaneous multi-user editing of notebooks. OneNote 2007 auto-magically merges the edits, even simultaneous edits on the same page. This is valuable for single users (you can edit on desktop and laptop and not have one machine lock the file), but it’s even more valuable for teams sharing a notebook for plans, ideas, meetings and so on. Or perhaps a family notebook shared with your significant other. We’ve heard lots of positive feedback about this, and it has completely transformed the way many teams work and collaborate. We’ve also heard about many families that use it for sharing home renovation plans, gardening info, recipes, wedding planning and so on.

In OneNote 2010 we’ve added a number of features to make the experience of sharing with others more productive and intuitive. These include:

What’s new (aka Unread) highlighting: New content that someone else added or changed since you last looked at a page is highlighted so you can see what’s new on that page. Also, the notebook name, section tabs and page tabs are shown in bold so you can quickly navigate to pages with new content.
Author indicator: Content written by anyone other than you has a small color coded bar to the right with their initials. At a glance you can tell who wrote something.
Versioning: Quickly show past versions of any given page, who wrote it and when, with changes relative to previous versions highlighted.
Fast sync on same page: When multiple people are working on the same page we speed up the sync of that page so you can see other peoples edits in near real time.
We also added capabilities to be able to quickly search for recently added content (last day, week, month etc.) or get an overview of what given people changed on what days.
Merge two sections: This feature is more of a detail but it fits here. Sometimes people share notebooks using Live Mesh or Dropbox or other file sharing solutions. And you can end up with two forked copies of a section if you happened to make changes on two machines at once (you can read earlier posts for context, but OneNote cannot auto-magically merge simultaneous edits when working on these systems that copy files around underneath OneNote). So we’ve added the ability to manually merge any two sections if you ever get into this situation. Just tell OneNote which two sections you want merged and OneNote will take care of it.

3. Better ways to Organize and Find your Notes

Capturing, organizing and finding your information has always been at the heart of what OneNote does. We’ve made several enhancements in this core area. Some of these will be more understandable once we have detailed blog posts with screenshots.

Section and page tab improvements: making notebook navigation work better with a larger number of sections and pages, easier to create new sections, better page tab hierarchy visualization, collapse sub page groups, just drag left and right to create sub pages and organize your pages, insert new pages directly anywhere in your page tabs.
Fast “word wheel” search for navigation: the goal of this is to make search a super-fast way to get to your regularly used notes. Historically search has been more of a “last resort” feature when you couldn’t find something. We’ve completely revamped this experience so it is now designed to make it the fastest way to get to any page including pages you visit regularly like your To Do list.
Wiki linking: you can easily create a link to an existing page or to a new page for a topic. You can do this by just typing the Wiki link syntax (e.g. just type [[The Page Title I Want]] ), or use our new page search experience from within the link dialog. This enables you to easily create Wiki like notebooks with lots of cross links across pages.
Quick filing: there are many ways to send content to OneNote (Print to OneNote, send mails from Outlook, send pages from Internet Explorer and so on). Our new Quick Filing experience pops up to let you pick where in your notebook you want to send it. It remembers the last places you sent things. You can search in Quick Filing to find a specific section or page if you want it somewhere else.

4. Research and taking notes linked to documents, web pages

OneNote is often used as a companion while researching topics and collecting information (e.g. a market analysis study, a class paper, a home renovation, a car purchase and so on). This often involves looking at web pages or documents and taking notes. You could also be reviewing a document or class lecture slides and taking notes as you’re looking through them. We’ve enhanced a number of things to make this experience better.

Docked OneNote: you can dock OneNote to the side of your screen. It docks alongside other windows (e.g. browser, Word, PowerPoint). OneNote minimizes UI and just shows the notes page alongside your document/browser.
Linked Note Taking: while in this mode, OneNote automatically links the notes you take to what you’re looking at – the web page URL, the selection point in Word, the current slide in PowerPoint. Later in OneNote you can hover on that link and you’ll see a thumbnail preview of the original document, you can click on it and it will open and take you back to what you were looking at when you wrote the note.
Auto text wrapping: this goes well with Docked OneNote but is useful in other cases too. OneNote now wraps text outlines to fit the windows size if there is only one outline on the page. This makes it easy to see all your notes even when OneNote is docked to a relatively narrow window on the side.
IRM protected printouts: this is mainly for enterprise and training scenarios. The idea is that companies can distribute things like product manuals or class notes in OneNote that are protected intellectual property. The recipient can view these in OneNote and take their own personal notes on top of these materials and beside them. If for some reason the materials were viewed by an unauthorized person they would not see any of the protected material.
64 bit print driver: Yes, OneNote 2010 has a new native print driver that fully supports 64 bit. It’s based on the XPS technology from Windows. It also has other virtues like better rendering quality when scaled.

5. Editing improvements

There are a number of basic editing improvements in OneNote. Below are some more prominent ones.

Basic styles: OneNote 2010 adds very basic styles like Heading 1,2,3. This does not have the power of Words styling features. OneNote is not designed for that level of document formatting. But it does give you a way to quickly have your meeting notes have a little structure.
Bullets improvements: this is a simple one but oft requested. First level bullets now indent from previous text.
Equations: OneNote 2010 now supports the ability to add math equations. Great for students or people who need to input math into their notebooks. OneNote will also support the ability to recognize hand written math equations and convert them when running on Windows 7.
Translation tooltips: OneNote can now show you a tooltip with a translation into your native language when your mouse hovers over a foreign language word. Great for language students, or if you’re working in a bi-lingual situation and need help understanding a word in a shared notebook or that you clipped from the web.

6. Touch support

With the rapidly increasing availability of touch enabled PCs and the enhanced touch experience in Windows 7, this was a natural thing for OneNote to support.

Finger panning and auto-switch: you can use your finger to scroll and pan around any page in OneNote. OneNote auto switches between pen, pan, and selection depending on your input device. So for example you can pan around a drawing with your left finger and draw with a tablet pen in your right hand. This makes for a very natural two handed interaction model.
Pinch zoom: we enabled pinch zooming within OneNote centered on the fingers.
Navigation controls improved for touch: we’ve made some small optimizations to make the UI easier to use with touch.

7. Fluent UI

OneNote now adopts the Fluent UI along with the other Office applications.

Ribbon: OneNote now has the Ribbon. We’ve designed this to optimize for the key OneNote scenarios and make them easier to use. This is also what enables us to more easily add features like math equation editing (the common controls for that use the Ribbon), and potential future features.
Office Backstage: This is new for Office 2010. OneNote will be taking advantage of it to make tasks like creating new notebooks, and new shared notebooks on the web easier (we’re still doing work on this).

Linked Open Data Caching - Establishing a Baseline with HTTP

woddiscovery — Mon, 23 Nov 2009 16:28:43 +0000

The other day I was pondering on Linked Open Data Source Dynamics and as a starting point I wanted to learn more about the caching characteristics of LOD data sources. Now, in order to establish a baseline, one should have a look at what HTTP, one of the pillars of Linked Data, offers (see also RFC2616, Caching in HTTP).

So, I hacked a little PHP script that takes 17 sample resources from the LOD cloud (from representative datasets ranging from DBpedia over GeoSpecies to W3C Wordnet). The results of the LOD caching evaluation are somewhat deflating: more than half of the samples do not support cache control and less than 20% support Last-Modified or ETag headers.

I know, I know, this is just a very limited experiment. And yes, very likely there are not yet that many applications out there consuming Linked Data and hence using up the whole bandwidth. However, given that one of the arguments for the scalability on the Web is the built-in HTTP caching mechanism, LOD dataset publisher might want to consider having a closer look into what the server or platform at hand is able to offer concerning caching support.

Come sviluppare siti web e web application di successo

adverman — Mon, 23 Nov 2009 15:19:04 +0000

I moderni siti web sono ben lontani dagli anonimi blocchi di testo statico o dai pesanti showcase in flash di una decade fa. Oggi praticamente tutti i siti web di successo, siano essi portali di e-commerce, sistemi di lead management, analisi, promozione di eventi, sistemi di ticketing, social network, siti di intrattenimento, implementano una web based application, cioé un’applicazione progettata per essere fruita attraverso la rete.

Le applicazioni dedicate al web sono sotanzialmente dei programmi. Questi programmi consentono ai visitatori di inviare o cercare dati a o dentro un database sfruttando il protocollo della rete inetrnet ed il proprio web browser preferito. I dati sono quindi presentati all’utente nel browser nel modo in cui l’applicazione genera dinamicamente le pagine dei contenuti attraverso il web server.

Lo sviluppo di siti web che sfruttano i servizi di web application non è un processo semplice. Volendolo schematizzare, il processo è costituito da 5 fasi principali che, se debitamente portate a compimento, aumentano drasticamente le possibilità di successo.

Il ciclo di sviluppo software a 5 fasi

Il ciclo di sviluppo di una web application può essere assimilato ai processi di sviluppo standard di un software che possono essere attuati e gestiti da un team di sviluppatori esperto. Come per il software le web application sono quindi sviluppate secondo metodologie ben precise. Diamo uno sguardo alle principali fasi del processo che solitamente rispondono al 90% delle esigenze progettuali.

1. Analisi delle esigenze

Dato che il sito web andrà, in questo caso, a fare parte di un sistema software integrato, esso ha bisogno di un’analisi specifica completa a partire dalle domande: come la web application aiuterà e migliorerà l’attuale sistema e come il sito stesso andrà a supportare le attività di business. Inoltre l’analisi dovrebbe coprire tutti gli aspetti prestazionali chiedendosi quali sono i benchmark attesi dal prodotto realizzato. Un altro momento fondamentale dell’analisi è quello di identificare e comprendere la target audience dal punto di vista sociale, culturale, anagrafico, ecc.

2. Identificare le specifiche della web application

Dopo l’analisi, le specifiche progettuali devono essere enucleate tenendo conto di tutti i requisiti strutturali ed operativi emersi. L’obiettivo di questa fase è quello di realizzare un documento di specifiche a cui il team di sviluppo possa fare riferimento come un master plan, al fine di assicurare uno sviluppo chiaro ed omogeneo del prodotto, concentrando tutto l’effort di sviluppo nel conseguimento dei goal.

3. Design dell’interfaccia grafica (UI)

In questa fase rientra la creazione del layout di tutte le pagine che implementeranno le varie features dell’applicazione. Il layout deve essere progettato nella prospettiva di implementare anche quelle funzionalità che non sono ancora state sviluppate dal team di programmazione. Se state sviluppando l’applicazione per un vostro cliente è molto probabile che vi sarà richiesta la presentazione di proposte alternative di layout. Nella prospettiva di una gestione ottimale del ciclo di sviluppo, i feedback del cliente devono essere condivisi fra tutti i team impegnati per le loro rispettive competenze nello sviluppo del progetto. E’ fondamentale corrdinare il reparto di produzione con gli account che seguono il cliente e gli presentano i prodotti realizzati.

4. Sviluppo del modello/controllo dei dati

In parallelo con il team di graphic designer, il team di sivluppo software dovrà costruire l’applicazione che ruoterà nel 99% dei casi intorno ad un database o a servizi di database distribuiti su web. Diversamente dal design di applicazioni tradizionale, lo sviluppatore del codice deve avere una stretta familiarità con il layout grafico del progetto perché l’applicazione non deve alterare le caratteristiche grafiche del layout, bensì armonizzarsi perfettamente con esso e presentare i suoi output nel formato prestabilito dal team grafico. E’ quindi fondamentale che il team di programmazione e quello grafico interagiscano in maniera stretta e collaborativa in questa fase.

5. Test di pre-commercializzazione

Come i comuni applicativi software, le web applications hanno bisogno di una attenta fase di test perché un applicazione di questo dipo è progettata per operare in un sistema multi-utente che presenta sempre limiti pratici e teorici di banda. Oltre ai test che comunemente vengono effettuati su un’applicativo, le web application richiedono dei test particolari: test di integrazione, test di stress, test di caricamento, test di risoluzione grafica e di compatibilità cross-browser. In entrambi i casi sarà possibile effettuare test manuali o test automatici portati avanti da specifici robot software che interagiscono con la UI dell’pplicazione come farebbe un essere umano. Una volta ultimata la fase di test preliminari, la web application dovrebbe iniziare ad essere distribuita sul web in forma di versione Beta, prima di essere commercializzata (nel caso si tratti di un servizio a pagamento) o semplicemente diffusa su larga scala (le caso si tratti di un’applicazione gratuita).

Le web application che hanno avuto un reale successo sul mercato hanno sempre condotto un ciclo di sviluppo in maniera intelligente e razionalizzata nella prospettiva di massimizzare il ROI e promuovere il core business.

Chi necessita del servizio di un team di sviluppatori di web application deve scegliere con molta attenzione il soggetto a cui affidare il lavoro. Grandi team di sviluppo potrebbero avere infatti costi di lavorazione estremamente elevati che potrebbero ritardare il time to market del servizio (o renderlo addirittura impossibile). Viceversa, team di sviluppo costituiti da piccole società specializzate potrebbero contribuire a contenere notevolmente il budget di spesa, ma a fronte di un rischio nella qualità in una delle fasi sopra elencate.

Cercate quindi di affidare i vostri lavori a soggetti che abbiano una buona reputazione, un team di sviluppo esperto ed un portfolio ben popolato.

FaxHQ.com pre-launch

Christian Burger — Mon, 23 Nov 2009 06:56:31 +0000

One of our products currently in development has recently kicked off its pre-launch campaign and the response is quite encouraging.

FaxHQ’s objective to solve the problems with fax and specifically fax2email. Visit the site for some more tidbits

Google Wave - First Look

Umair Mohsin — Sun, 22 Nov 2009 14:02:21 +0000

Published Dawn Scitech, November 22nd, 2009 What Is Google Wave? Announced by Google at the Google I

Shape Collage

dsmith77 — Fri, 20 Nov 2009 16:25:12 +0000

http://www.shapecollage.com/

This is a very cool new web application. Very cool indeed. You supply the photos and it creates a collage of them in any shape you like – solid shapes, outlines, text, whatever.

If you ever played Nintendo games then click on the Nintendo Logo Collage above for the full version and reminesce! For other example collages visit the Shape Collage Gallery.

The Essential Guide to Flex 3

cnapagoda — Fri, 20 Nov 2009 11:04:00 +0000

Flex 3 is the next generation of a technology that revolutionized web applications. It is the next evolutionary step of Flash, which has grown from a web animation medium to a powerful enterprise web design and development platform. With nearly 98% of all web browsers, and a growing number of mobile devices, running Flash Player, a knowledge of Flex is indispensible for any serious web developer.

The Essential Guide to Flex 3|Pages : 569|Size :16Mb

Download

PDC09 Announcements – Day 2 Keynote

colinizer — Wed, 18 Nov 2009 16:31:53 +0000

Blogged live – now completed.

Check out further PDC coverage

Background

Everything is about 3 screens (desktop, phone and TV) and the cloud.
Day 1 focus – Backend, i.e. Azure.
Day 2 focus – Office, Silverlight & Windows focus on Day 2.
Microsoft emphasis will be on IE + Silverlight for all 3 screens – desktop, phone and TV.

Announcements

Not going to announce Windows 8 stuff in the interests of being ‘responsible’ and ensuring that what is disclosed is actionable – not ready for that yet.
FREE Windows 7 ‘PDC laptop’ (Acer machine with Microsoft’s preferred software image, resistive multi-touch, accelerometer) available to all paying PDC attendees (!!!). Conditions apply . Is this Oprah?
‘3 weeks’ into IE 9 development – Standards progress (HTML 5); performance improvements in JavaScript; Hardware-accelerated DirectWrite/Direct2D Graphics & Text
IE9 already on 32/100 on Acid3 test, up from 20/100 on IE8
Channel9 videos on IE9 being posted today
Silverlight will be used this Winter for Victoria’s Secret Fashion Show and Winter Olympics
Silverlight will be used by Bloomberg, National Instruments, Siemens (medical diagnostic imaging)
Silverlight now on 45% of the world’s internet-connected devices (up from 33% in the summer)
Silverlight 4 – Media, Business Applications, Beyond the Browser
Silverlight 4: Webcam & Microphone on the machine (including raw access); multi-cast streaming; offline DRM support
Silverlight 3 media framework on codeplex this week
Next version for IIS Media Services will support IPhone clients as streaming client – see iis.net/iphone.
Silverlight 4 introduces support for: printing; rich text; clipboard access; right click; mouse wheel; implicit styles; drag/drop; bidi & rtl; html hosting (including content as brush); commanding/mvvm; additional controls (including rich text)
Silverlight 4 includes: compile once, use in both SL and .NET 4; UDP multicast (p2p); rest protocol enhancements; improved WCF support (inc. TCP channel support); RIA Services; works better with OData (Astoria)
Visual Studio 2010 Silverlight support: WYSIWYG Design Surface (not news), XAML IntelliSense Improvements; Improvements for Data Binding, Layout & Styles; WCF RIA Services Integration
Silverlight 4 offline includes: Windowing APIs; Notification popups; HTML hosting; Drop Target
Silverlight 4 offline ‘elevated’ includes: Custom Windows Chrome, Local File System, Cross-Site Network; Keyboard in Full Screen Mode; Hardware Device Access; COM Automation of local objects (and location APIs).
Silverlight 4: Twice as fast; 30% faster startup; new profiling support
Silverlight 4 supported on Google Chrome.
Silverlight 4 still under 5MB to install.
Will ship the Silverlight 4 Facebook-integration demo as reference sample
70% of voted-for Silverlight 4 features (including 9 of top 10) included
Silverlight 4 Beta – announced as NOW AVAILABLE!!!!!!! at http://silverlight.net/getstarted/silverlight-4-beta/ and see http://channel9.msdn.com/learn include (what’s new)
Silverlight 4 RC – No Date
Silverlight 4 Final Release – No Date (I think perhaps March 22nd with VS 2010)
Office 2010 Beta and SharePoint 2010 Beta general availably announced – http://www.microsoft.com/office/2010/en/default.aspx – no new announcements yet though
Silverlight can use client-side object model to talk to SharePoint 2010
Office 2010 Mobile available on Windows Market Place for Mobile on 6.5 devices
Outlook Social Connector (part of Office 2010 Beta): Get social networking in Outlook with people info, history, activities; SharePoint 2010 Provider, Windows Live Provider in 2010; Linkedin Provider in 2010; has general SDK for making providers

Demos/Information

Silly video from Windows Management Team about collecting feedback/error report information – new non-lethal torture methods? – complete with entertainment-only disclaimer
Lots of telemetry data from the Windows development cycle – they even monitored stuff like number of presses on Start button and Aero Snap/Shake uses.
They analyzed the audio of the audience at the last PDC – best reaction was to the new Windows 7 slider control for UAC levels.
Various usability study videos cut out from live feed to protect IP.
Various demos of W7 new hardware-supporting features – touch, sensors, hardware-accelerated encoding, directx 11, etc.
Using yesterday’s IE9 build: Acid3 test results’; GDI vs. Direct2D smooth text rendering and animation; Bing maps jittery in software vs. smooth in hardware (60fps)
Recap video of SketchFlow in Expression Blend 3.
Silverlight 4 demos: video/image capture from local webcam; live preview of effects on webcam capture (incl. chromakey, bulge effect based on sound level, alien effect) using pixelshader effects; opensource barcode scanning with demo of scan of barcode goes to amazon page.
Silverlight 3 Demo (not shown on live stream) of PVR functions including pause and slow motion on live and pre-recorded events.
Silverlight 4 Demo of rich text control (including direct copy from grid selection in Excel)
Silverlight 4 Demo of Bing, Flash and even Silverlight hosted inside Silverlight including using it as a live brush (!!!).
Demo of VS2010 features for Silverlight 4: RIA data services; OData in data sources (and drag/drop to design surface); datagrid; implicit styles; new resource picker; new databinding picker; client-side validation from entity attributes
SnapFlow Silverlight app that allows building of online business applications hosted on Azure: DirectBuy example; HR example
Silverlight 4 Demo of elevated app integrated with Facebook including: local automation of Office; webcam photo upload; supper thumbnail listing performance; drag and drop of pictures; direct device photo import (!!!)
Demo of SharePoint 2010 Development with race track engineering/telemetry app: SharePoint on Vista/Win7; Sandbox solutions; VS Debugging; Read data from Azure; SP 2010 & Excel 2010 Client Object Models in Silverlight; show telemetry against video playback

â character in Zend_Currency

Christian Burger — Wed, 18 Nov 2009 14:52:55 +0000

ini_set(‘default_charset’, ‘UTF-8′);

http://www.sitepoint.com/blogs/2006/03/15/do-you-know-your-character-encodings/

ZendFramework-1.9.5-minimal/library/Zend/Locale/Data

PDC09 Announcements – Day 1 Keynote

colinizer — Tue, 17 Nov 2009 16:33:42 +0000

Blogged live – now complete – curiously Bob Muglia’s closing remarks were cut off on the live feed. Very much looking forward to the Silverlight stuff tomorrow.

Check out further PDC coverage

Background

Everything is about 3 screens (desktop, phone and TV) and the cloud.
Day 1 focus – Backend, i.e. Azure.
Day 2 focus – Office, Silverlight & Windows focus on Day 2.
Microsoft emphasis will be on IE + Silverlight for all 3 screens – desktop, phone and TV.
Ray Ozzie wants you to bet on Windows 7, IE8, Silverlight, Windows Azure, SQL Azure, 3 screens and a cloud
Bob Muglia talks at length about moving existing applications to the cloud (‘move, enhance, transform’) – partnering with Avanade & Accenture
Cloud application aspects being covered at PDC Self-Service, Elastic, Service-Orientated, Federated, Scale-Out, Staged Productions, Always Available, Multi-Tenant, Failure Resilient

Microsoft Announcements

Azure platform going live Jan 1 2010, but no charging until Feb 1 2010 – this is not news btw
Azure projects are available in Visual Studio 2010
Windows Azure has RESTful service APIs to manage configuration
Windows Azure Pricing: $0.12ph (1×1.6GHz/1.75MB); $0.24ph (2×1.6GHz/3.5GB); $0.48ph (4×1.6GHz/7.0GB); $0.96ph (8×1.6GHz/14GB)
Windows Azure now supports fast CGI support, PHP, MySQL
Azure – auto geo-replication in pairs – 3 pairs (NA, EU, Asia) going live in Jan 2010
Azure Storage Updating features – entity group transactions, snapshot, copy
Azure Storage Accessing features – block blobs, page blobs, leases
Azure Storage Serving features – shared access signatures, custom domain names, content delivery network (CDN)
Azure Storage – X-Drives – NTFS-like drive access to cloud storage
SQL Azure – Fuller DB, T-SQL, Stored Procedures, ADO.NET, works against Excel, support from SQL Server Management Studio (2008 R2)
Some customers will be able to go live today including WordPress
Microsoft PinPoint – catalogue of products and services targeting developers and IT (showing in Azure portal and partner network, and later into online portal for IT)
Codename “Dallas” (completely on Windows Azure and SQL Azure) open catalogue for data (public and commercial) with uniform discovery, trial and licensing – touted as a game-changer
ADO.NET Data Services (Astoria) also now known as OData.
Project “Sydney” – connects Azure platform to existing private data-centre services together
Windows Azure creatable images (with admin access) coming in 2010 (Windows base, customise, snapshot, deploy)
AppFabric (Windows Server Beta 1 available now & Windows Azure Beta 1 in 2010) – create high availability, scale-out, multi-tenant, manageable apps (especially using WCF and WF) covering caching, Workflow hosting, monitoring, service bus, service hosting, access control – formerly called “Dublin”?
Windows Identify Foundation RTM
Go-live license for Visual Studio 2010 Beta 2 & .NET Framework 4 beta 2 – this is not news
Oslo now SQL Server Modeling Services
The stack is now: Applications – Exchange/SharePoint; Dev Tools – VS; Programming Model – .NET Framework; App Services, Windows Server/Azure AppFabric; DB – SQL Server/Azure; OS – Windows Server/Azure; Management – System Center
System Center Cloud Beta in 2010
SQL Server 2008 R2 RTM in 2010
Visual Studio 2010 & .NET 4.0 RTM March 22nd 2009 – this is not news

Demos

Seesmic.com demo of Twitter client using Silverlight and for Windows with WPF – will become a platform soon
WordPress (who hosts 10 million blogs) demo on Azure and how it can scale easily
OddlySpecific.com (from creators of ICanHasCheeseburger, FailBlog & PunditKitchen) launched today on Windows Azure & SQL Azure – also can use CDN
Codename “Dallas” – Showing discovery (by catalogue); explore data with REST, AtomPub, etc. and Excel 2010 PowerPivot; demo of service proxy it can build for you; 3D (!!) demo of mars image exploration – underwhelming reaction from audience
US Federal Chief Information Officer – talking about democratising information (like GPS and NASA Pathfinder); http://beamartian.jpl.nasa.gov; Career finder application on mobile device (via data.gov) – yawn (despite the profound implications)
Silly fictional video about the cloud starring Bob Muglia – groan
Azure Low-level access (Don Box & Chris Anderson) – Windows Azure application in low-level simple C++ (and assembler!); Azure SQL accepting T-SQL from SMSS to create pdc ‘talks’ table and insert rows; Show OData javascript app (using o-auth wrap to .NET Services Access Control Service) on ‘talks’ table
Kelly Blue Book (kbb.com – 14M unique per month in 2 data centres) Silverlight App (showing filtering and zooming) – showing flexible cost model with Windows Azure; less than 1% code-base change plus Azure config file; also using SQL Azure (using same mechanisms as before) and showing SQL Azure Data Sync – most scripted/stiff demo of the keynote.
Video of how customers can use Azure platform: Dominoes (peaks on Superbowl and Friday nights); Siemens; RiskMetrics
Project “Sydney” demo – connection of Azure application to private data-centre SQL database
Increasing functional of the Tailspin travel app (.NET 3.5) with .NET 4.0 and VS 2010 tools: showing VS 2010 multi-monitor; using ASP.NET MVC diagram; adding single sign-on quickly with Windows Identity Foundation (uses AD token service); new find-in-files window; client-side validation with ASP.NET MVC 2; Intellitrace shows trace (e.g. ADO.NET) and allow navigation back to code that produced the trace; add AppFabric to use distributed memory cache feature; automated web-app UI test(!) which shows that the memory cache improved performance; new Windows Workflow 4 designer; AppFabric exposes WF 4 through a web service automatically with tracking UI shown in IIS Manager; MSDeploy integrated with Visual Studio for each single-file publish/deploy (to staging/live)
Moving Tailsping travel app (as enhanced above) seamlessly to Azure; creating an app model with designer in VS 2010 by adding web role, AppFabric role and database role and associating with projects; published to Azure (using Windows Identity Foundation to allow federation of AD identity); use System Center Operations Manager (SCOM) to monitor Azure application and help check for SLA violations

e-tipi: The Collaborative Idea Machine

Darrell Etherington — Sun, 15 Nov 2009 14:00:08 +0000

e-tipi sounds like a weird name for a web-based service, and when you find out it stands for “Espresso Thinking Platform,” things don’t become much clearer. But once you find out what the app’s developers think “Espresso Thinking” is, then you start to get the idea:

“We believe that sharing an espresso in a nice café creates a particular atmosphere that frees minds and promotes promising ideas to expressly appear. This is what we call Espresso Thinking.”

It’s a nice thought, but is that really something that can be captured in a web-based environment? I recently talked about the same kind of collaboration (lack of coffee products notwithstanding) in an article about my beloved sketchbook, so I was eager to find out if I could recreate the experience digitally using e-tipi.

e-tipi incorporates elements of Twitter, Digg, wikis and blogs to create a workspace in which ideas can be born and explored. Each user page is called a tipi, and it contains various ideas submitted by the tipi’s users. All of the ideas center around a central “challenge,” which the main problem or purpose of the tipi. Think of a challenge like a big picture problem that requires a multi-parted and multi-staged solution.

Along with your tipi page, you also get a unique email address that contributors can send their ideas to directly, for quickly adding to the tipi’s repository. You can also follow your tipi on Twitter, the stream for which is automatically updated with information of your choosing. I like both of these tie-ins, because they make e-tipi feel more connected with other networks, making it much more accessible, which is something I like in idea generation tools.

You can also export your data at any time as either XML or HTML, which makes it easy to plug into other tools, including database management software. It’s a nice way to help you organize the raw information you produce using e-tipi’s tools. A messy free-for-all is a good way to generate creative thought, but it may not be the best storage solution for more polished ideas.

Ideas are listed on their own separate page, and you can sort them by activity and date. Each idea listed shows votes for or against, total views, and the number of comments users have posted about each. You also get the idea’s title, its creator, any tags that may have been applied, and the status, if the idea has one. For each idea, an administrator can set the status to tell others how far along the process intis, using labels like “Accepted,” “Started,” etc. You can also filter your ideas list by keyword to narrow your search.

Each idea page looks a little like a Digg article page, complete with the text of the idea in question and comments made by other users underneath. You also get to see potentially related ideas listed at the bottom of the description page.

Other nice features of e-tipi include a tag cloud, and a member display, in which you can view a user’s profile information, and access information like how many ideas they’ve contributed to, including comments and voting, and how many documents they’ve contributed. You can also highlight certain areas in a Spotlight menu for quick access.

Overall, e-tipi is a very rough-cut tool, when measured against others I’ve tried in the past. It’s not exactly easy on the eyes, and at times it can even seem disorganized. Despite that sense of mess, or perhaps because of it, e-tipi does feel like something that could well operate as fertile ground for the generation and refinement of ideas. I like the sense of freedom inherent in the site, and the potential for unstructured, loose collaboration with a wide number of viewers.

Do you use a web app for idea generation and refinement? Which one?

cirrogram - web design company

jeganfk1 — Fri, 16 Oct 2009 16:58:03 +0000

Cirrogram is one of the erp providers in india and they are providing web design and web service too

web-application « WordPress.com Tag Feed

Install multiple versions of IE on your PC