Twitter Feed: @definition6

DEFINING INSIGHTS

We Got LUCK-Y!

Monday, January 30, 2012 by Darcey Topham
Over the last few months, I have been privileged to work with a talented group of people onHBO Luck Chips a new project for HBO Luck. Working together with the HBO Marketing team, Civic Entertainment Group and Live Stream, we created an application for Facebook that allowed people to become involved in the dark, seedy world of horseracing by practicing making bets on old races before accessing the real betting experience that would lead to a 6-race live Race Day event. An event that would not only be Facebook’s first live racing event, but only the second live sporting event aired over streaming video through their site.

And just saying that we all worked hard is a complete understatement. When you’re dealing with any event that has a live component, there is a definite element of the unknown to contend with. So many “what-ifs” to consider that you have to have a back-up plan for your back-up plan. (Or a “what if our lead developer gets kidnapped by aliens” plan, right PH?) But when you’re dealing with a live event that involves multiple remote locations, having that video fed into a streaming player, that aired on Facebook, and then the data sent through separately to be updated in a quick-turn fashion, you almost feel like you can never be prepared enough.

Luck
When it all comes together, however, it is exhilarating. And when you are lucky enough to have your favorite bar host a viewing/monitoring party to celebrate it, it doesn’t get any better. Unless you’re this guy who got really excited when “Mucho Macho Man” won in the fifth race.

Edited by Ryan Kantor to fit the new blog template 5/4/2011

Big thanks to Justin and all the folks at Diesel Filling Station for their hospitality, support, and participation – seeing people enjoy something we created makes the hard work worth it.

Darcey and Dana at Diesel

d6ers at diesel

Stop! Is that poop on your iPhone? [INFOGRAPHIC]

Tuesday, November 22, 2011 by Jon Accarrino
The next time you hear someone playing Angry Birds or checking-in using Greensquare from inside a bathroom stall, make a mental note with yourself to never borrow their phone. In fact, you might want to start avoiding all other phones from now on.

According to this infographic by Keeping It Kleen, 16% of all smartphones have poop on them. Yuck! And unfortunately it's not just phones that you have to worry about. All tech gadgets from keyboards and iPads to TV remote controls are covered with germs. It's enough to make Howie Mandel take another shower (he's an admitted germaphobe who showers 5 times or more a day).

Take a guess. What is dirtier: Your keyboard or a toilet seat? Toilet seat? WRONG. The average keyboard is 5x dirtier and has 60x more germs than your average toilet seat. Say hello to your new office mate. Her name is Bacteria. And the next time you stay in a hotel and want to worry about the bedspread, wake up and smell the poop. The TV remote is the dirtiest object in the room!!

If you want to make sure your phone isn't part of the 16% that's covered in poop molecules, then try to break out some Purell or rubbing alcohol on a regular basis and give it a good cleaning. And the next time you see a coworker or family member walk out of a bathroom with an iPad, make sure it wasn't yours.

Stop! Is that poop on your iPhone? [infographic]

Architectural Diary - Evolution Not Revolution of System Design

Saturday, April 9, 2011 by Ric Williams

Designing systems, interfaces, back end engines, databases and other system related items takes a blend of creative and technical acumen. IT professionals love to solve problems with their blended skill sets. When an algorithm is developed we sometimes even share those ideas and algorithms so it can help other systems. One case in point is my colleague Jon Taylor’s recent blog about the Observer pattern and .net event models. (Check it out of you haven’t yet-great information.) Design patterns in themselves are previous solutions that give us a solid base to develop a new algorithm from. But how many times and in how many ways have we overdesigned something?

I remember a bad decision I made at the beginning of my career in overdesign. A customer wanted a backward compatible query building wizard for their staff to use that had little technical knowledge or database understanding. However, the trick was the ‘management’ staff consistently wanted to ‘adjust’ database table and field names. The data in them wouldn’t change but the name needed to change. They were adamant about this. In coming up with a design we looked at using SQL Server ID numbers to store. This way we could recreate the same query with new names and we wouldn’t have backward compatibility issues. When built it worked great everyone had what they needed. Until a new version of SQL Server came out that instead of updating table names dropped them and re-created them. Slap the forehead time. I didn’t consider the impact or fragility change would have on the system. I focused on one direction to much.

Instead of looking to a simpler solution I went to a more complex one, or better said as an overdesigned one. I have never forgotten that lesson and I find all kinds of ways to apply it. Over the years this has turned into a philosophy and phrase ‘evolution not revolution’. Revolution is not limited to overdesigning the back end system it could be overdesigning any part of the system. In this context the concept of revolution for change is a bad one. Some of the aspects of revolution I am referring to are the destructive nature, the amount of change that has be absorbed, what can’t be changed back and the time to adjust to the changes. When your users are feeling the impact of a system revolution is this a good thing? What causes them to feel that?

 We aren’t talking about users feelings at the deployment of a system. We are talking about the users feelings over time. One example, I heard company say they couldn’t adjust the size of a banner frame for their customer because they had built it custom. It would take to many hours to change. That small issue was the start for the customer losing faith in the product and the team that created it. Eventually that team lost the business. Why? They created a revolutionary new banner frame that was great. But when the customer needed change they couldn’t accommodate efficiently and cost effectively.

When architecting we have to be able to break down a system to its critical components and work forward. We have to keep in mind that the parts of our systems need to evolve and grow. To best serve our customers we have to be diligent in evaluating if our design is evolutionary or revolutionary. Thinking of the quote ‘an ounce of prevention is worth a pound of cure’ what are some simple ways to prevent overdesign. Collaborate; working alone in a vacuum is not always a great way to a solution. One of the reasons collaboration is such a great tool for teams is someone is always looking for a simpler way. If you aren’t working with a team or before you review with the team, ask yourself am I designing to the requirements or am I trying to add value. Sometimes in trying to add value we get so excited about what the system could do we forget that the customer may have never wanted that.

Prevention begins early in the process. Understanding the workflows and business processes associated with a system is critical. Architects, testers, developers, and customers all need to be on the same page. In gathering requirements we have to dig to the deeper process to design a quality system. With an understanding of the business processes, the entire development process begins from requirements on down reflect the beginning is a base.

Realize that for many systems that have heavy interaction, users need time with the system. This is important because I am frequently surprised with the direction a customer will drive a solution over time. It is so important to consider this during design as well as critical to take the time to design. It surprises me that even today how many developers and team almost go straight to code.  Take the time to focus on the base and look for evolution. For architects and developers design patterns are great if it fits and gives your customer what they need. Consider that the only constant is change. Do you really need that whiz bang new pattern or will something simpler work better?  

Create a system that can evolve with the customers’ needs over time not revolutionize today forgetting about tomorrow.

Architectural Diary: Architecting with the End in Mind, OLAP and Analysis Systems

Monday, April 4, 2011 by Ric Williams

A common refrain in IT is to "begin with the end in mind." It is one of those refrains that has been repeated so many times that it quickly becomes ignored. For systems that collect data, "the end" may be very complicated. Some data collected can be presented in reports and that is sufficient. Reporting is such an easily understood term and used so frequently it often hides complexity. It’s in that complexity that frustration for system engineers and customers alike begins.  Because of that, complexity reporting is often not a cost effective means for exploring data. Complex reports can take a significant amount of time, (translate that to cost), in order to complete.  When users are looking at the data to see what trends or interesting anomalies appear, reports just aren’t efficient. We begin by recognizing that "the end" can be as complex a system as the front end collection system.

Architecting an analysis system can comprise many parts ans some of the most overlooked and underutilized are OLAP tools (Online Analytical Processing). As such, optimizing those tools and working with users to capture the areas the tool needs to work with are important.  It’s that OLAP part of an analysis system that we begin to explore in a bit more detail.

So to begin working with OLAP, two terms will immediately need to be understood--dimension and measure. Working off of a graph diagram is the best explanation to start with. Looking at Figure 1, notice the X–axis of the graph. In OLAP, that axis will be called a "dimension". The calculation that occurs at each notch in the access is called a "measure".  That in mind, figure 1 shows location as the dimension and debt amount as the measure.

 


Figure 1.
Grpahic

Using the same basic graph model, imagine that we add a new dimension debt type. So now the intersection that points between the dimensions debt type and location show our debt amount measure. The great thing about OLAP tools is that depending on the particular tool, they can look at many measures at the same time, can flatten a dimension out, and look at all of one and a particular point or notch on another dimension. So, why are they called cubes?

 Figure 2 shows the addition of the Calendar dimension, essentially time limited to the granularity level of day. With that dimension our graphical representation now resembles a cube, hence the name. While graphically we can only represent 3 dimensions clearly and easily, an OLAP system can represent hundreds of dimensions.

  

figure3

Figure 2.

OLAP tools provide different types of interfaces that allow users to simply drag, drop and click to explore data. Some tools like SAS Enterprise Guide can even graph dynamically while the user is exploring. Robust tools like this provide a good user experience and enhances the analysis system. Many systems like SQL Analysis Services connects directly to SQL Reporting services, allowing for reports to be built quickly and easily in addition to the normal canned reports. So, what does an architect need to consider with a basic understanding of what OLAP does for users?

An OLAP system basically represents hundreds or thousands, depending on the number of dimensions and measures, of queries working against the data simultaneously.  In processing, systems like SQL Analysis server offer different processing options to do as many pre-calculations as possible. These processing options are HOLAP, MOLAP, and ROLAP, but let’s not get into the weeds. What we need to know is that the system is going to perform some level of pre-processing and store that pre-processing. To do that pre-processing, and for that matter, processing, there are data structure designs that work more efficiently with OLAP. Some will refer to these models as Star and Snowflake patterns. What architects need to look at is that the data model for the collection may be differently optimized. Don’t get into discussions of normalization here, as it doesn’t apply. Both the data models can be normalized but still not be optimized for their working intent. Normalization does equal optimization for all cases.

Looking at figure 3, the data model shows a table labeled with the prefix "fact." The fact table in an OLAP model is where the values to calculate measures are usually stored. Keep in mind that a measure is an individual calculation and the facts are the values that enable those calculations. To help the OLAP system work, a group of foreign keys relate out to the tables with the prefix "dim." The dim tables may be single tables as represented with the debt type. Or they may be hierarchal as represented with the Calendar dimension.

Figure 3.Data model of OLAP example

What creating a database model like this allows for is the OLAP engine to process quicker. Creating this model may result in ETL routines being created, which is a benefit, as dimension data can be transformed from being collected one way to another in the OLAP data model. This provides even more flexibility towards what we can represent, as well as interjecting new considerations. How often do we move the data? Do we copy the data or do we move it? An analysis system has to consider all of these options.

OLAP can also be a data source for the front end interface and provide new dashboards and functionality to the collection interface as well. Visual Studio.net for example, has quite a few capabilities in this area that will be in another blog coming soon. Getting back, this allows analysis systems the capability of being an integrated system in new ways with the collection system.

If you see the value of OLAP, look at it as another tool for the analysis system. Yes, it can be a replacement for some reports. However, a solution will still include canned reports, as we are always going to need those.  A full analysis system is going to have more components to it and be fully thought out. With this end in mind, if you were to design the exploration, reporting, queries, and analysis you want a system to provide, how different would the collection system be?

Many systems are designed from the point of view of the collection system. After all, that’s what most users will see and work with. So we focus there. Only later to realize we want to analyze data and we have the wrong level of granularity or we are missing a variable. Many know that the cost and time increase significantly when changing a constructed system versus at design time. Have you considered what the cost is of building the systems in the wrong order? Is the tail wagging the dog?


Architectural Diary - The Future of Web Development

Monday, March 21, 2011 by Jonathan Taylor

Web application development is on the precipice of a revolution; through a confluence of independent practices and technologies, the way in which web applications are built and consumed is about to change radically.

What is happening is a fundamental shift away from the current state-heavy, page-based processing model to a loose collection of lightweight web-based services that an empowered client can consume to provide full functionality in a composite fashion. It started with AJAX, grew substantially with MVC, took shape with REST, and is now about to break wide open.

Web development up to this point has been tied very closely to processing HttpRequests on a page-by-page level. Remember classic ASP and ColdFusion with code intermixed with html on the page? [Honestly, was there ever a worse language to work with than VBScript? If…EndIf…Next? Please. Microsoft still owes the development community a sincere apology for making us suffer through the miserable excuse for a language that was VBScript – JT] Nightmare! ASP.NET brought the separation of code and markup, which was a huge advancement, but brought along with it a heavy page-processing model and cumbersome state management tied to the server, or worse, hashed and embedded in the page itself. [He’s using ViewState! Grab your torch and pitchforks! Raah!]

AJAX was the emancipation proclamation that freed web development from the confines of postback processing. Utilizing the substantially overlooked XMLHttpRequest object [Thank you Microsoft for developing the XmlHttpRequest in 2000 but not incorporating it into a browser until 2006], developers were suddenly free to call back into their server for processing without having to post an entire page’s content and wait for it to come back. In its entirety. Which took time. Like reading this. OK, you get the point. AJAX did more to enliven the web than any plugin had ever done previously, [sounding the death knell for Flash and similar technologies, R.I.P] and was the timely injection of functionality and responsiveness the web desperately needed. AJAX, however, despite its freedom from the page processing lifecycle, is still inherently tied to a page – its whole intent was to be able to refresh parts of a page without having to throw the whole page back to the server, so no matter how you implement it, Ajax is fundamentally tied to a page. Figure 1 is a good representation of the current state of web development, with different clients requiring dedicated applications to process information over the web

Figure 1 - The current state of web development

Web2
MVC changes how we even think about web processing by changing the url from pointing to a physical file sitting in a directory on a server somewhere to a call to a method in the code of our application. This is a huge change; the url doesn’t point to another page or image or even another site, it fires off functionality on demand.

Now, combine this url-based functionality with a robust client-side library such as jQuery, which is capable of consuming and populating services of various types, and you have the basis for a new processing model for web applications. Consider, free from the duty of page DOM processing, jQuery can intercept a click on the page and call any service we want instead. In this scenario, jQuery acts as a controller of our base page, synchronizing calls to a myriad of distributed lightweight service endpoints to deliver full functionality as a composite set. Incorporating the capabilities of HTML5, we’re free from supporting multiple plug-ins to support media, which we can also stream in from services as required.

So what’s really happening here is a combination of the extensibility of service oriented architecture (SOA) with AJAX-style web client processing for the purposes of delivering web applications as outlined in Figure 2.
 
Figure 2 - Composite Web Application Development

Web3

This model offers significant benefits over previous web development techniques including, but not limited to:

·         Extensibility: need a new feature? Build a new service and .js file to consume it. You’re done. And you can implement both to the live app without disruption of service.

·         Scalability: services can be provisioned collectively or separately to address performance concerns – which fits perfectly with modern virtualization practices.

·         Performance: by relieving the server from redundant page postback processing, and moving a large portion of processing onto the client, the server is free to dedicate more resources to handling dedicated lightweight service calls, significantly speeding overall responsiveness.

·         Maintainability: encapsulating functionality into independent services means if changes or added features are required by the application, only one service needs to be updated, not the entire application. And as it’s the service that will be altered in most cases, production environments will not have to be impacted by the service refresh.

·         Client Agnostic: Implementing this model frees processing from the page, meaning the same services which feed our web application can easily be consumed by a mobile or platform-specific client, extending the development effort in a parallel fashion.

Service based applications have been highly regarded for quite some time due to their clear separation of concerns and inherent benefits of such an implementation, but the challenge thus far in utilizing a Service Oriented Architecture with web applications has been the limitations of the page/postback processing model. Combining the capabilities of url-based method calls with AJAX-style lightweight service consumption, a composite web application model is emerging which will change the way web application development is considered and pursued. The revolution is coming.

The Architectural Diary: Understanding the Drivers for Search Architecture

Thursday, March 17, 2011 by Ric Williams

Many application development companies regadless of web development or windows development want or need to implement search functionality. However, it is a commonly underestimated function and it continues to evolve over time. Interestingly users want search to have minimal to no interaction while having a maximum result. With data and collection systems becoming more and more complex this becomes and increasingly difficult challenge. I remember a system I was architecting for a customer where the customer wanted to enter a DNA result that consisted of an 800 to 1600 character string into a web application and have it search a database using an algorithm providing scored search results. The customer was convinced that a basic desktop machine would act as a server and be able to conduct the search against a large database efficiently. The production architecture needed to support the customers’ performance requirements was a High Performance Computing hardware environment.  Like many customers they didn’t understand the complexity of certain functions. Thinking through this topic recently had me researching how functions in systems and their architectures evolved.

Architecting a system today has many facets, and search certainly is a prominent one. Searching for information is not a new concept but a heavily evolving one. Once computers evolved beyond just basic mathematics and started capturing, storing and manipulating other data the need for search began. Early systems collected data that was somewhat structured in files and databases. Search functions found data quickly within those structures. With the development of relational databases and more complex data capture search the tools for search had to grow. Also the acceptance and use of computers was growing and more and more.
Architecting search within a system has consistently had to recognize simultaneous evolutions. Database tools added the ability to index tables to help search perform better. Search appliances like Wizards emerged for more technically savvy users to pull data from a data source. Multiple levels of searching complexity were emerging. While these searches largely dealt with structured data stored in systems, at the same time this evolution was occurring what cannot be ignored is the emergence of the internet and its impact on search. 

Early on companies like Yahoo profited on the simple concept of locating content. While this wasn’t structure data as in databases internet standards of things like meta-tag’s and other items made it possible for users to find content early on. Searching on the internet allowed users to enter terms and content related to those terms would be returned. Later companies like Google would improve the algorithms and set that industries standard for a time. E-commerce companies were also integrating user shopper experiences with search as a means of driving revenue. So while a user shopped for shoes, related items and previous shopping items would appear in the links and advertising throughout the system. While the motives were different the capture of information and providing relevant data back is essentially an implied search. The evolution of the internet and its potential was impacting local systems.

Users’ expectations were changing as the interaction was to enter in a few terms and that brought back content they wanted to see. At the same time computers continued advancing in hardware and use. Pictures, Videos, art, music files evolved to become more common to be stored on systems. In fact digital has become so big that companies like Kodak have stopped producing film based cameras. Users have embraced and ran with the lower cost and portability of digital media. This new media has presented a new challenge and forced search to evolve in multiple ways again.

Architects and systems were faced with growing use for search.  Users were searching as an exploratory exercise as more complex data and more types of data were being captured. Allowing for the advancement of tools like Online Analytical Processing (OLAP) and reporting tools. Users weren’t looking for specific data as much as looking to see what trends might appear in the data. These tools while technically complex have easy to use interfaces that allow users to review and analyze data. The complexity lies in the architecture and backend. The emergence and development of these tools was a move from appliance parts of a system to search to a full blown system of its own.

Users now expect applications to be able to search both structured and unstructured data. They want to give as little information as possible and quickly find very relevant search results. Algorithms and techniques for searching continue to advance because they must--including incorporating e-commerce like changes in the system and having subtle changes help the customer get to the results they want more quickly. One of the many reasons unstructured data evolved was not only digital media but mobile devices.

This latest evolution has occurred simultaneously with the acceptance of mobile devices. Now users have a high level of portability and connectivity to data. These mobile tools work quickly using touch screen technology and other key changes that impact the user experience for working with data. This has resulted in a need for better performance and system architectures that incorporate different devices, connectivity, and desired results.

Today’s cutting edge searches involve grabbing information from a part of a picture and searching for related information. Searches that work from audio files or live audio and provide related information quickly on portable devices is another technology that has been developed. Users want more with less required of them, resulting in more complex algorithms and models for searching.

Successfully architecting a system means taking a lot of factors into consideration. A successful solution can't overlook what the implementation's search functionality has within an enterprise system. Architecting search as a part of a system today means taking many factors into account. Understanding the user’s expectations and desired results has become critical to the successful use of a system. What devices are targeted for use, what is the complexity of the data, what type of data, and other questions like these are all key to get answered to develop a successful search system. Working with customers to identify the business rules that lead to implicit and explicit searches is important as systems more and more are expected to show relevant data.


Architectural Diary - Build a better FTP Drop Box

Monday, March 14, 2011 by Jonathan Taylor

The other day I was discussing the finer points of flat file conversion in Application Development (or lack thereof) with one of my colleagues on the Definition 6 Architecture team, and we got into a rather interesting conversation regarding how much of today’s data still gets transmitted via data documents of some kind. Modern programming practice is to transfer data via on-demand services, it's faster, easier, and in most cases much more secure. The truth of the world we live in is that most older systems, and an uncomfortably large number of new systems still  transmit data to business partners across the world using plain old text files filled with data in whatever standard they were supporting when the system was built. How's that for communcation planning? [Note: this practice has a name – Electronic Data Interchange, or EDI, and Microsoft has an exceptional tool for optimizing and synhcronizing these efforts, Biztalk 2010, but that's another post entirely – JT]

Now, my colleague, who shall remain nameless, pointed out that these systems have been functioning without problem for years, so something must be said for the persistence of such file transfer processes. My carefully worded retort was that this perceived stability was the direct result of poor sods like myself working my tail off to keep them going. At this point I feel it is my duty to disclose that while it doesn’t seem to have affected him personally, my colleague was once a long-time employee for an organization many would lay the finger of blame at for the creation and continued use of this file-based data transfer silliness, even in the face of more reliable, efficient alternatives (I won’t disclose the name of this much maligned organization, but it rhymes closely with "aye, be them"). And conceding to my colleagues’ point, this is surely the reasoning why these processes still exist today. (A clearer case of ‘if it ain’t broke, don’t fix it’ you’ll never find)

Thus, like them or not, we as developers are stuck with these processes, and it is up to us to implement solutions that accommodate them as best as possible. Now, a simply staggering majority of these systems rely on FTP transfer to distribute their data files, and typically it is up to the receiving party to pick up these files from an ftp "dropbox" and process them in a timely manner. FTP transfer has its own peculiarities that do not help this process, however, the most prominent of which being unpredictable transfer times and the disparity between the file arriving at the destination dropbox and the file completely downloading in its entirety from its origin. Aha! Herein lays our opportunity.

The problem of uncertain FTP delivery schedules causes file recipients to either delay retrieving the files from the dropbox until a time when they are certain the file will be there, "nightly file transfers," etc., or resort to "polling" to periodically spin up a process to look for the file being in the dropbox, and if it is, begin processing of the received file or pass it along to another process for further manipulation. These practices are inherently flawed and incur extensive overhead in time and system resources while constantly checking to see if the file has arrived, then locking resouceswhile the file finishes downloading before the processing of the files data can finally take place.

With .Ne however, these problems can be solved easily enough – if we can’t change the process, at least we can make it better, right? Let’s get started.

The key to our solution is a little-known member of the .NET System.IO namespace, the FileSystemWatcher class. The FileSystemWatcher does exactly what its name implies – it’s a lightweight object that monitors a directory and raises events to any changes that occur. We’re going to build a small console application and use a FileSystemWatcher to monitor our ftp directory for any new files that get created. Code Segment 1 details our System.IO.FileSystemWatcher implementation.

Code Segment 1

class Program

    {

        static void Main(string[] args)

        {

            //This should be an actual ftp directory path,

     //preferably from an App.Config file      

            String ftpPath = "path-to-ftp-directory";

 

            //Our watcher! 

            FileSystemWatcher watcher = new FileSystemWatcher(ftpPath);

 

            // Add event handlers for file created event

            watcher.Created += new FileSystemEventHandler(OnCreated);

 

            //Begin watching.

     //you need to set this to enable the FileSystemWater to raise events

            watcher.EnableRaisingEvents = true;

 

            // Code to shutdown the console if the user hits 'q'

            Console.WriteLine("Press 'q' to quit the sample.");

            while (Console.Read() != 'q') ;

        }

 

 

Right, so pretty straight-forward so far, a simple console app in which we setup the directory to be watched, implement a new instance of the FileSystemWatcher class then enable it to raise events whenever anything occurs in that directory. Now, the event we’re clearly interested in here is the Created event, which will fire every time a new ftp transfer arrives in our directory. To react to this Created event we wire up an instance of the FileSystemEventHandler to the watcher’s created event and point it to our method OnCreated, which is outlined in Segment 2.

Code Segment 2

        // Define the event handler

        private static void OnCreated(object source, FileSystemEventArgs e)

        {

            // write file name and arrival time out to the console when new files arrive

            StringBuilder sb = new StringBuilder();

 

            sb.Append("File: ");

            sb.Append(e.FullPath);

            sb.Append(" arrived @");

            sb.Append(DateTime.Now.ToShortTimeString());

            sb.Append(". Processing...");

 

            Console.WriteLine(sb.ToString());

 

            //now route the file to where it needs to go.

            ProcessFile(e.FullPath);           

        }

 

Again, fairly straight-forward, the OnCreated method simply reacts to the watcher’s Created event, and allows us to kick off whatever further processing we need to, namely writing out to the console the name and arrival time of the new file, then handing the file off to another method for further processing. Notice the FileSystemEventArgs object in the OnCreated method’s signature – we need to implement this class in order to capture the event, but it also allows us to work with a number of key parameters regarding the watcher.Created event, in particular the e.FullPath property which we’ll use to programmatically work with the newly arrived ftp file. The ProcessFile method is outlined in Segment 3.

Code Segment 3

private static void ProcessFile(String filepath)

    {

        FileInfo file = new FileInfo(filepath);

       

        //Switch to handle different file types

        switch (file.Extension)

        {

            case "txt":                   

                //process text logic here

                break;

 

            case "xml":

                //process xml logic here

                break;

 

            case "csv":

                //process csv logic here

                break;

 

                default:

                    break;

 

            }

 

Ok, so this is the final piece of our solution; we want our console app to be running constantly on our ftp server to watch our ftp dropbox at all times, so we need to be sure it’s as lightweight as possible and doesn’t maintain any internal state whatsoever, otherwise we’re adding extra load to our ftp server, and that’s entirely against what we set out to do in the first place, isn't it?. So let’s not do that.

The ProcessFile method is our routing method to move the file or notify any further services down the line that the file has arrived [an exceptional opportunity to implement the .NET Event Pattern, discussed in my previous post - JT]. We declare a FileInfo class to derive the extension of the file and route the file to a final destination based on file type.  By doing so, our console app never opens the file, never reads it into memory or maintains anything that would drain resources away from our server’s memory or processing pool, so it can run quietly alongside the rest of the server’s workload catching every new file that arrives in our FTP directory, and routing them to their final destination.

Ooo, Aahh.

Now, as simple as this solution is, we need to recognize what this implementation saves us – every time a typical FTP polling process started up, it would need to first gain access to the FTP directory, declare the directory reference in memory, then enumerate all the child directories (even if there weren’t any) followed by enumerating all the files contained in the directory to check if the file the batch process is looking for is there, and because the file transfer cannot be guaranteed to arrive at a specified time, the process would have to execute repeatedly until the file was finally found. Our FileSystemWatcher class, on the other hand simply responds to events that occur within the FTP dropbox, consuming substantially less resources.

So the key for gracefully processing FTP files without having to wait for the entire file to arrive is to process the file asynchronously. Doing so allows the main program to continue receiving file processing requests without having to wait for the code that actually processes the file. .NET provides a number of different avenues to finish that thought with, particularly in .NET 4.0, but that’s a bigger topic I’ll save for a later post. (Oh yes I did)

So to recap, yes we still have to deal with flat file transfers, but at least we can do so in a better manner, can’t we? Oh yes we can.


Architectural Diary - The .NET Observer Pattern

Tuesday, March 8, 2011 by Jonathan Taylor

Web application development can get tricky. Not only are we, as developers, charged with constructing brilliant websites that address every requirement each project entails, we also have to be concerned with the things not explicitly listed in our requirements document - things like how do we secure it? How do we know it's working at peak performance? How can we make sure people are entering in the data they're supposed to? On top of all that, if we're doing business website development, be sure to stay abreast of current application development technologies, the best ways to improve search engine optimization and last but not least, be sure to address brand experience strategy in everything you do.

See? Tricky. Fortunately, developers are weird. We like the challenges each web application development project presents. Really. We're weird.

Now despite this apparent quirkiness, in any software project we're working on, if there's something someone's built before that can help speed the development process along, we're likely going to use it. Design patterns represent tried and true ways to accomplish certain tasks in code - they're structures that solve problems common to many different project types. Confronted by a massive project with a tight deadline? Spot a process that can be handled by a design pattern? Sign me up! Design patterns to the rescue.

One of the most common design patterns which has been implemented time and time again is the Observer pattern, which is basically a structure that allows you to setup one or more entities (the observers) that react to changes in another entity (the subject). Not an uncommon scenario, right? Think RSS news readers that display news items as they are posted on the remote server. The observer pattern has solid grounding in real-world scenarios too; think of the iconic "hot doughnuts now" sign from your doughnut shop of choice – they light it up, people come running. Ok, maybe not the best of examples, as people still have the choice to grab a doughnut or not, but hey, it’s a vice, what can I say?

Traditionally the Observer pattern is implemented by using a set of objects derived from a common set of interfaces, namely the IObserver interface for objects we want to be notified of changes in another object, and the ISubject interface for the object we want to be watched. Basically, the ISubject interface defines a set of public methods to manage observer signup and notifications as outlined in code segment 1:

Segment 1

    interface ISubject

    {

        public List<IObserver> RegisteredObservers { get; set; }

        public Boolean state { get; set; }

       

        public void RegisterObserver(IObserver observer)

        {

            RegisteredObservers.Add(observer);

        }

 

        public void RemoveObserver(IObserver observer)

        {

            RegisteredObservers.Remove(observer);

        }

 

        public void UpdateRegisteredObservers()

        {

            foreach(IObserver observer in RegisteredObservers)

            {

                observer.Update(state)

            }

        }

 

So a set of methods to add and remove any objects derived from the IObserver interface to an internal list of IObserver objects which is used in the Update method to notify the observers of any change to the ISubject object, in this case a simple Boolean field called state (ugh, brutally obvious, I realize, but prudent..) . The observer objects implement their own interface outlined in segment 2:

Segment 2

    interface IObserver

    {

        public void Update(Boolean state)

        {

            //update status to reflect change in subject

        }

    }

 

And as expected, IObserver contains just one method to update itself to reflect any change in the subject object.

Not so difficult, right? A handy mechanism to handle distributed subscriber-based notifications for a number of different circumstances; if you haven’t found yourself in a situation where you needed to distribute multiple updates based off one event, trust me you will, and you’ll be happy you know about your friendly neighborhood Observer Pattern

Now while you are more than welcome to implement the Observer pattern using this traditional dual-interface manner, in .NET, there really is a better way. (You knew I was getting to it at some point, didn’t you?) Because the Observer pattern is so heavily entrenched in object-oriented development these days, and since the maintenance of registered observers can get pretty tricky pretty quickly in a traditional Observer pattern implementation, Microsoft went ahead and built its own short-hand version directly into the C# language from the very first version (yup, C# 1.0, don’t see that much anymore do you?) through the simple use of events and delegates. Microsoft uses it so much in their own internal coding, they even went so far as to rename it the Event Pattern (Oooo, Aaahh..)

OK, so here’s how it’s done: we’re going to build a subject class to expose an event whenever it changes internally, then we’re going to define a delegate to handle that event, which we’ll use to link all our observers to the subject– and we’ll transmit the subject’s change in state through a custom EventArgs class. Now, if that sounds like a lot, don’t freak out just yet, if you’ve ever wired up code to an event in .net, you’re already well acquainted with how events and delegates work through the standard signature of an event handler – think of a button click event handler like the one outlined in code segment 3.

Segment 3

public void Button1_Click(Object sender, EventArgs e)
{
    //button event code goes here
}

See that EventArgs parameter? That’s how .Net passes parameter values to event processors. So the cornerstone of implementing our own .net observer is by overriding the default System.EventArgs class with our own version to hold the information we need to pass to our observers from our subject class. Sound like a plan? Let’s get started.

Code Segment 4 lists a custom event class which contains two readonly properties, oldvalue and newvalue – we’ll use this class to notify all our observer objects whenever there’s a change in our Subject’s values.

Segment 4

public class SubectChangedEventArgs : EventArgs

    {

        //these values will hold values our observers want to know about

        private readonly int oldvalue;

        private readonly int newvalue;

 

        //constructor that sets old & new values

        public SubectChangedEventArgs(int oldval, int newval)

        {

            oldvalue = oldval;

            newvalue = newval;

        }

 

        //readonly properties to return Subject values

        public int OldValue { get { return oldvalue; } }

        public int NewValue { get { return newvalue; } }

    }

 

Ok, so now that we have a custom EventArgs class, we need to declare the event handler which our observers will mimic to receive subject change events – our delegate:

Segment 5

 

public delegate void SubjectChangedEventHandler(Object sender, SubectChangedEventArgs e);

 

 

The SubjectChangedEvenHandler defines a method signature which all our observers will implement to receive notifications from our subject; two parameters are defined – an object and an instance of our SubjectChangedEventArgs. When declared as a method in one of our observer classes, the object parameter will be a reference to the Subject object the Observer is watching, and changes to its values will be held in our readonly SubjectChangedEventArgs class; code segment 6 lists a typical observer object implementation.

Segment 6

    public class SubjectObserver

    {

        //int to list change in value

        int change;

 

       //subject change even handler to match our delegate and use our custome EventArgs class

        public void SubjectChange(Object sender, SubectChangedEventArgs e)

        {

            change = e.NewValue - e.OldValue;

        }

       

        //constructor that requires a subject to observe

        public SubjectObserver(Subject s)

        {

            //Register our delegate-based method to the subject instance

            //This is how we link our observers to the subject

            s.SubjectChanged += this.SubjectChange;

        }

    }

 

So, the SubjectObserver class has one method that matches our delegate defined to handle any changes in the subject, and we wire up the observer to the subject by linking our delegate-based SubjectChange method to our subject’s ‘SubjectChanged’ event as an event handler. Nice, huh? .Net baked-in goodness. The final piece of our puzzle is the Subject class itself. The Subject class has two responsibilities – to expose an event for changes to its internal value (which we’ll use to hook all our observers to as event handlers), and to ensure it raises this event any time a change to its internal value occurs. Code Segment 7 lists how our Subject class is structured.

Segment 7

public class Subject

    {

        //private int to hold the current subject's value

        private int subjectValue = 0;

 

        //public property to set the subject value,

        //the set method is where we capture the value change and

        //notify all the registered observers of the change

        public int SubjectValue

        {

            get { return subjectValue; }

 

            set

            {

                // new eventargs class to pass the current subjectValue and the new value

                SubjectChangedEventArgs e = new SubjectChangedEventArgs(subjectValue, value);

 

                //update the subjectValue

                subjectValue = value;

 

                //Signal all the observers

                OnSubjectChanged(e);

            }

        }

 

        //declare the event using our SubjectChangedEventHandler delegate

// to handle changes to the subjectValue

        //we'll also use this to attach our list of delegate-based observers to.

        public event SubjectChangedEventHandler SubjectChanged;

 

        //method to trigger our subject change event

        //Note: events can only be triggered from within their respective types,

        // thus we marked the scope as virtual protected to allow the method

        //to be over-ridden while still being able to raise the default event

        virtual protected void OnSubjectChanged(SubjectChangedEventArgs e)

        {

            SubjectChanged(this, e);

        }

    }

 

So there we have it, a public property with its setter calling a protected function to raise its own event to notify all our registered eventhandler observers. Any time the subject changes, the SubjectChanged event gets raised, and all our observers can react to the new value enclosed in our own custom SubjectChangedEventArgs class.

Now, admittedly that seems like a lot of work compared to the traditional ‘I only need two interfaces’ Observer pattern implementation, but the payoff is in the use of the pattern, as shown in Segment 8 which outlines the process of using the classes we detailed previously to gain our .Net Observer pattern sweetness.

Segment 8

    Subject subj = new Subject();

 

    SubjectObserver observer = new SubjectObserver(subj);

    SubjectObserver anotherObserver = new SubjectObserver(subj);

 

    subj.SubjectValue = 33;

 

    //both observer and anotherObserver both update immediately

    int observerValue = observer.Change;

    int anotherObserverValue = anotherObserver.Change;

 

Ok, now seriously, how freakin’ cool is that? No messy ‘I’m an observer, add me to the list of registered observers’ calls, no ‘ok, I’ve changed, let’s loop through the list of registered observers and let them know’ routines, just wicked fast event-based programming. And did I mention the wicked-fast-ness of this .net Observer implementation? Oh yeah.

Again this is a .Net-specific implementation of a widely recognized and utilized design pattern of modern object-oriented programming, the Observer Pattern. Microsoft uses this pattern extensively in their own class structure for the .Net framework – so much so, they’ve come to call it the Event Pattern. 

Oooh, Aaah…

Regardless, if you haven’t had the need to implement a similar pattern in your own coding projects, you probably will run into it sometime in the future, and when you do, you are now armed with the powerful and pervasive .Net Event Pattern.

6 Takes from CES

Tuesday, January 11, 2011 by Michael Kogon


Las Vegas for CESI've traditionally never said anything about a trip to Las Vegas, but in the spirit of shared experiences, I wanted to highlight a few things from CES 2011 that I found worth noting #CES (hangover habit from the conference).  I think out of everything that I saw and heard, the following really stuck out to me: 1) Build a platform 2) Exports are key 3) Droid Tablets 4) Multi Screen TV watching 5) Mashable throws a hell of a party 6) Facilitate Networking to add value







 

1.       Build a Platform - In our unified marketing agency, we talk with customers about paid, earned, and owned media all the time.  We firmlyFord Synch at CES believethat a company should strive to have a robust owned media asset platform upon which to leverage and create additional earned media by adding value and asking others to contribute to their ecosystem.  In effect we want companies and brands to think about developing a platform for future development. # CES brought out many examples (App Stores by TV and Cable operators and Telco), but the one that I found very intriguing was the Ford Sync Developer Community.  The idea that a car company would be embedding within its vehicles a platform for third party developers to provide solutions inside the vehicle is just amazing.  We in America spend so much time in our cars, it is very exciting to see what tools and capabilities we will be handed over the next 24 months.  Personally, I would like the sound cancelation application for long family road trips as well as the "clean and closest bathroom app" – Note: I have two daughters. In a company and brand sense, if you can build a platform for others to add value to, then your customers, suppliers and you benefit and will enjoy a higher value than if you merely communicate with each other.  A platform mentality will encourage you to think about connecting with each other and that is what is required for the always on and always in motion society we live in today.

2.       Exports are key - the Innovations Power Panel was fantastic - I encourage you to take an hour and watch it.

 

The panel was fantastic and talked about many things:  education, tax policy, infrastructure, but the comments regarding Germany's economic strength and focus on Exports really caught my attention.  Applying the thoughts to business and brands; aligning ones company exclusively and daily around producing something those outside your business want and value is a very powerful idea.  I know that is what we should all think about because we are supposed to be customer centric, focused on adding value to others, etc. etc. But much of the time I hear folks talking about their challenges, it has a lot to do about internal stuff and not enough about the export we are making that others value. If we think in terms of being a country, do we want to be an import or export company?  It seems to me that focusing on being a trade surplus organization is better and creates more value for everyone over time.

 

3.      Droid Tablets - the year of the Tablet #CES 2011, that was probably the most tweeted phrase day one and in almost every release about the Android Tablets at CESshow. And it certainly was in many ways.  There must have been 1500 different tablet manufacturers and by end of 2012 everyone who wants a tablet in any country will be able to find one that fits their needs, budgets, and networks. But to me the thing that will have the biggest impact will be the Droid Tablet, the free OS and readily available app developers from the Droid phone will make the tablets richer and more robust than any first generation platform ever. Apple will still be "King of the World" and RIM's efforts should be rewarded by corporate users and Samsung has a wonderful new place in the market headed there way. But I predict the Droid Tablet will be much like the AK-47 - the world's workhorse in its category for years to come.

 

 

 

4.       Multi-Screen TV watching - I think that people like to lean back and watch TV and not lean forward point a device at a screen and try to navigate aMulti-screen Viewing at CES computer type experience from their couch. And I think people like to have a tablet or laptop on the couch so they can do more than one thing at a time.  So to me the smartest "Smart TV" was the Viera Connect from Panasonic - It took the remote, turned into a tablet and allows you to control the smart internet enabled TV from a computer interface 6 inches form your face and then watch the results on the big screen. It allows you to view content that is in parallel with each other on both screens (it should make Bad Girls Club and Fantasy Football fans more glued than every before); It opens up a whole new world to advertisers, marketers and programmers to be able to have access to both screens in the living room and to add value in new ways not yet "Seen on TV". I'm very excited about what we can do for brands, broadcasters, content creators and consumers with this new multi-screen interaction capability.



 

 

 

5.      Mashable throws on hell of a party - The Mashable Awards started with a great VIP event serving 21 year old McCallan and various meats on a stick, rolled right into a 1000+ person theater with a great DJ team, well produced videos and a great overview of all things social, digital and hip; Followed by an after party in the club and then, and then and then…..Thanks guys, looking forward to Orlando.

Mashable Party at CES 







 

6.       Facilitate Networking to add value -  every sentence for about 72 hours had a #CES when I typed and I found it interesting that on Friday I spent about 10 minutes just watching my TweetDeck column with #CES.  It barely could keep up and was moving about 3 tweets a second and in at least 5-7 different languages.  There was a good amount of PR content from manufactures, but mostly it was comments caught by participants during panels, keynotes, demo's and conversations that were being documented, shared, RT and discussed. I guess we had long format blogging a few times a day three years ago, and press releases and video before that.  The energy that a full community dialoguing continuously and in real time was amazing and empowering.  I sent a lot from @mkogon and my recommendation is that if you have a supplier show, customer event, user conference, sales rally or other major gathering, you incorporate a #hashtag, a social media DJ, large screens, readily available Wi-Fi and encourage your audience to participate via social media. It will make your networking event more valuable and your participants more connected to you and to each other.

 

So there you have it, I've got another post coming about "Who asked you to make my idiot box smart?" and a few others that came from the show.

 

 


The Top 10 Uses of Social Media in 2010

Wednesday, December 15, 2010 by Paul Hernacki

It’s December and the end of another year. We all know what that means. Christmas? Wrapping up the fiscal year? Coming up with New Year’s resolutions we won’t keep? No, my friend. No. Most importantly it’s the time of year for social media and the blogosphere to flood with Top [insert # here] of [insert random subject here] Lists! The Top 6 Most Googled Terms! The Top 10 Most Watched YouTube Videos! The Top 8 Most Popular Hashtags! The Top 12 Most Photographed Sandwiches! Gone are the days when Top 10 lists were the exclusive monopoly of the Ranking Dictator David Letterman! I don’t know aboutLate Show Top Ten you, but it’s hard to imagine what could be more exciting. So I decided to create my own contribution to this joyous annual ranking extravaganza. And I’ve based this list on highly extensive research that includes thousands of my own opinions, hundreds of my own anecdotal experiences, and dozens of my own biases.

I’m quite certain that if all Twitter and Facebook posts with content that falls in one of the below 10 categories suddenly ceased that the entire world of social media would either collapse upon itself like a black hole or it would would see about as much use as telegram services do today... lots of RT's with cricket sounds.

10. Top X of Y Lists. I’m pretty certain that practically anyone can take about 5 minutes and write a list of X number of Y things on a blog then post it to Twitter and get a large number of click-throughs and RT’s.  I mean… you’re reading this one and I’m totally just making it all up as I go along with zero actual or real research to back it up.

9. Posting links to funny videos on YouTube. This is hilarious. This is too funny. Totally LOL! What’s interesting to me is how many of us roll our eyes at our parents for their constant barrage of forwarded e-mail humor, but we think nothing of posting our own barrage of it to social media each and every day.

8. Posting cute pictures of your kids and funny things they said. My kids are adorable, dammit. And everyone must know this. And if you don’t comment or reply with things like “Adorable!” and “So cute!” I will shun you by refusing to comment on how yummy that picture of your arugula salad looks. Take that.

7. Individual content curation: The Human RSS. Who needs trained and experienced content editors that might actually have journalism degrees and do stupid things like verify sources and accuracy of information when you can rely upon that guy whose avatar is a close up of the upper left quarter of his face?

6. Celebrity Obituaries. What?! OMG! Another celebrity died? Quick! Pls RT! And don’t forget to add in your own personal tribute or reference memorable quotes.

5. Letting everyone know what new gadget you got. I mean, what good is having some new tech bling if you can’t show off your technical superiority to people you never talked to in high school or 736 of your Followers that you never met?

4. What you “Like”, where you are traveling to, what you are eating, what you are watching, what you are reading, what the weather is like where you are at, and who you are hanging out with. I unfortunately know more mundane details of the lives of people I never actually met, seldom see or barely ever spoke to then I really ever cared to know. It also scares me to realize that I now hear real-world conversations where people refer to themselves in the 3rd person stating they "Like this".

3. Apple rumors and anticipating Apple releases. If it wasn’t for debating what features might be in the next iPhone or complaining about the lack of Flash support on the iPad, Twitter could probably reduce its server capacity by about 10%. Never before have people spent so much effort complaining about products that they collectively and eagerly spend so much money on.

2. Opinions on the daily breaking news. Because all the talk shows, pundits, broadcast news commentators, and daily water cooler conversations really just didn’t give us enough of other people’s opinions on which to base our own.

1. Discussing social media. Seriously… has any other medium ever been used so reflexively to discuss itself? Imagine if the largest percent of your phone calls were to discuss phones and phone related technology or if most of your e-mails were focused on the subject of e-mail, e-mail clients, and e-mail servers. Pretty insane when you think about it.

Of course, I just realized I forgot to include a big one: complaining about products and services in general. But I only want 10 items in my list. #FAIL

All that said, please don't think this means I see social media as worthless or a waste of time. It is an incredibly powerful medium that really has changed the way people communicate and it has connected people with each other in a way that is truly staggering to consider. It can be an amazing way to gain insights, it has forever changed the nature and control of information flow, and it has empowered individuals and movements across the globe. It can connect consumers and brands in a more personal fashion than almost any preceeding medium. It has placed the pulse of the moment in any given place from any given person's perspective at the potential fingertips of billions. And IMO it's really just the beginning. So has anyone heard what the specs are on the rumored camera that's suppose to be in the next version of the iPad?

Happy New Year!

A Lesson on SEO from 1995

Friday, October 22, 2010 by Paul Hernacki

I woke up this morning to a pretty interesting e-mail that was sent to me by way of my Google profile from someone named David Anderson:Beer

I am making a blog for an online writing class I'm taking through UF, and for a module on search techniques I needed to find a non-mainstream website about my topic (sports bars).  I found your old site, the East Lansing Bar Review, and I loved it so I've written my post for this assignment about it.  I've only made five posts so far, but here is a link anyway: http://sportsbarjunkie.blogspot.com/

This is really crazy in so many ways. The site he is referring to is something I created back around 1995. I was attending Michigan State University and worked part-time in the MSU Network Center to make some extra cash. My official title there was Mainframe Consultant and mostly I helped professors and students to use things like Gopher, Banyan VINES, FTP, configure dial-up PPP access, and learn how to use our Unix-based ELM e-mail client. This was a time when most corporations hadn’t even heard of the web, it had fledgling use by Universities, it was being referred to as a fad, and I had just helped to get Michigan State’s own first web sites up.

I wanted to play around more with this new-fangled world wide web so using a vi editor in Unix, working in HTML 1.0 and armed with a copy of the predominant browser of the time NCSA Mosaic, I decided to create a site that offered a personal review of all the local bars and pubs in the East Lansing, Michigan area. I had a lot of fun creating the site. I had even more fun doing the critical research required to provide the reviews. But it really was bare bones ugly, used hand coded tables, some basic formatting tags, and the most advanced thing it included (which was hot at the time) was an image map that used a monstrosity I created with a copy of Photoshop 1.0.

But so it was born: the East Lansing Bar Review. For a couple of years I kept updating it and occasionally I got really interesting feedback or comments. It even got me a few free beers from local bar owners. When I left MSU my younger brother Mike took over the site and moved it (all 4 or 5 HTML files and all 5-6 images) from my student web account to his. He kept it updated for a couple of more years before he graduated. A couple of years later we got tired of being contacted about it from people asking for updates so Mike posted a note on the site explaining this and since then it’s gathered electronic dust but apparently it’s still there.

15 years from when I created the site, I’m now the CTO of Definition 6 where we create massive high-end brand experiences that include transactional sites with extensive back-end systems integration, hundreds of thousands of pages of content in enterprise-class Content Management Systems, on-line video experiences, mobile web sites, mobile applications and more in addition to spending a ton of time doing Search Engine Optimization, Search Engine Marketing, On-line Display Media, and Analytics.

In an effort for this blog post to have a point and not just be nostalgic rambling or reflection on how far we’ve come in terms of the web and on-line advancements, what really stands out to me is considering how high this site shows up in results for major search engines. If you search for East Lansing Bars it still comes up as one of the top several results on Google. And if you search as David describes he did in his blog post it’s number one. Keep in mind the site was originally written and posted before Google even existed and at a time when Yahoo! had just come onto the scene as a start-up. The very concept of organic search engine optimization didn’t even really exist let alone was it the means of livelihood for the legions of people that practice its art today. I’m sure there are some things to be said for how today’s algorithms treat a site with such a long tenure favorably as well as the tenure of links to that site. And I’m all but certain that the same site published today would not be treated so favorably. But it is probably worth noting that a site hosted at relatively bad URL by today’s SEO standards with no meta-data, no thought to Information Architecture, and bad file naming practices still shows up high for certain not uncommon searches when the content was meaningfully written and relevant to the subject matter of interest. I’ll leave the rest of the analysis to the real SEO experts out there (and my apologies to our Creative Department for even publishing a link to this relic of a site on our blog).

Thanks, David, for the trip down memory lane and for giving me some interesting things to think about this morning.

How Brands Can Benefit from Pegshot

Tuesday, July 13, 2010 by Ashley Reed
You’ve probably heard about location-based services like Foursquare and Gowalla, but have you tried Pegshot yet? Instead of answering the question “Where are you?”, Pegshot tells your friends “What’s happening where you are?” by enabling users to quickly share videos and photos with their social networks.  The application allows users to “peg” a shot from their location and post it to Twitter, Facebook, Flickr, Tumblr, Digg and Posterous in real-time.  

There are many ways in which brands can take advantage of Pegshot to increase awareness and engagement with their organization. Pegshot is especially well-suited for promoting events as it facilitates quick and easy sharing of photos and videos in real-time, allowing immediate visibility on the social web.  This means your audience can interact with your events while they are happening even if they cannot be there. 

Real-time sharing also increases pass along rates since, attendees are usually active on social networks at events and can quickly view your content and re-tweet it, “Like” or comment on it.  Not only can content be published on your social media accounts, but Pegshot even allows you to post photos and videos directly to your company’s website.  In most cases, companies allow only their employees to publish content to their website to ensure that all material is appropriate.   

To take advantage of Pegshot at your next event, follow these easy steps:

1. Create your event.


Add your event by filling out the details of your event including the name, date, your Twitter hashtag, and location.  Your event will appear on any user’s mobile device in the surrounding area.

2.  Create a branded landing page for your event.


You can create a custom branded landing page for you event or choose your Twitter background.




3. Promote your event and add contributors.


Pegshot offers a custom registration page so you can collect as many contributors as possible. You can use this custom landing page to promote your event across social networks as well as your website, email and print marketing initiatives. 






4. Capture your event as it’s happening. 


Now you’re ready to begin pegging photos and videos of your event in real-time.  Your contributors as well as any Pegshot users in the vicinity can share content of your event which will be displayed on your custom landing page in addition to social networks and your website (if permission is granted.)


 


Anticipating Key Developments in Web Design

Friday, April 9, 2010 by John Harne
It took a little over a week to get over my SXSW experiential (and literal) hangover and to sum up my thoughts on the 2010 Austin event. One word sums up my thoughts coming out of this year's festival..."Anticipation".

Remember the Heinz TV spots of the early 1990's, with Carly Simon singing for ketchup. This year it seemed like everyone was waiting for something, but it just didn't seem to show up. Since this was the venue that Twitter and FourSquare debuted in years past, I think the majority of the attendees were "anticipating" more. Instead there was a lot more marketing of Miller Lite beer, Chevy Volt and Monster energy drink, more parties, more free beer and a whole lot more people. Over 6,200 more folks in fact, all anticipating something, some next big thing at SXSW 2010.

Anticipation was also common Twitter theme and with so many birds of a feather together, the Twitter and FourSquare servers seemed to lag during certain keynotes and party hours. FourSquare had to invent a new badge for the experience called a super swarm. This designated that over 250 users checked in to a specific location, like the Frog Design party at MACC on Sunday evening. Everyone was gathering and waiting on something to happen.

Sometimes it pays to look the other way. While most of the crowd was attending keynotes given by the founders and thought leaders of social media, some big news was breaking in some smaller sessions and workshops.

This year three key developments signaled future implications for web interface design that will change the visual future of the web. CSS 3, HTML5 and Fluid Type are what I am talking about. The ability to leverage thousands of fonts will release web design from restrictions and separate creative talent from web generalists. HTML5 will do away with the use of proprietary plug-ins for basic rich media.
 
HTML5 adds video and audio capabilities to core markup languange with the intention of reducing the need for browser plug-in-based rich internet applications (RIA). And it is being employed now. Big entities like CBS are displaying their content video while Microsoft Silverlight and Adobe Flash are just beginning to do battle. The take-away is that open source code will have the ability to display media that the bulk of Flash and other RIA's are doing now. This spells the end for many plug-ins and the best part is HTML5 is here now and should reach W3C Recommendation by late this year.
 
CSS3 is still currently under development but many of the recommendations are working in existing browsers. The list of features continues to grow and the ability of designers to use these features to extend web design is exciting.

Consider what a designer might be able to do with just multiple backgrounds. This feature already works in Firefox, Chrome, Opera and Safari. Don't ask me about IE, but even IE has revealed better CSS controls are on the way.

Jason Cranford Teague might have given the most interesting presentation. I have known Jason personally for over ten years and I can testify that his vision of the future of web development has been uncanny. He was one of the very first to author a book on CSS, and in fact later served as an advisor to the CSS W3C group. Now he is an evangelist for web design and his passion is releasing the artform of typography to the web.

As any designer knows, fontography online is a shadow of what is capable in print, film and other fixed media because of browsers, usage laws and technology. But there are now alternatives to system fonts and type displayed as bitmapped images.

Jason's new book presents three approaches to using a wide variety of fonts in web design and goes into depth in his explanation of just what fontography really is. After being an interactive creative director for more than a decade, I can say with authority that most of the web has become a sea of sameness because of the lack of font variety and the ability to design with fonts.

Fluid web typography will give artists access to over 100 thousand fonts versus the less than 5 that are typically used online. So take a look at embedded open type, license font servers and web-font linking. You just might realize another wave of innovation in web design is already here.

A couple of links worth reading:


MIX 2010: Microsoft Steps Up Its Game With Designers and UX (and Bill Buxton Destroys Las Vegas)

Monday, March 22, 2010 by Paul Hernacki

MIX10 LogoI recently had the opportunity to attend MIX 2010, Microsoft's annual conference for web designers and developers focused on building great user experiences, in Las Vegas, along with Definition 6's two interactive Creative Directors from Atlanta and New York.

MIX 2010 is highly unlike most other Microsoft conferences where the topics frequently focus on .NET, Exchange, Office, and Windows. Instead it's chock full of design and UX goodness - a geeky love fest for all the cool tech that goes into creating great web, mobile, desktop, kiosk, and other assorted technically enabled experiences using the Microsoft platform.


It's hard to argue that this isn't an arena in which Microsoft is still playing a lot of catch-up. Adobe Creative Suite and Flash/Flex are still easily the staple of most creative and design departments. And many people definitely hug their MacBooks and frantically wave their iPhones about when asked to provide examples of great user interface design. But if there was one thing abundantly clear at MIX 2010 it is that Microsoft has no plans to cede the battle on these fronts, they are rapidly catching up in many areas, and even appear to be leading the way in a few. Seriously.

Microsoft is a marathon runner, not a sprinter. And as Steve Ballmer said at Microsoft's Worldwide Partner Conference last year regarding questions as to why Microsoft doesn't cede such battles as Search and Advertising and retreat back home to their core Windows, Office, or SQL Server business lines, "We. Don't. Go. Home." Anyone who doesn't believe him should have been at MIX. And do you really have to look further than an example like the Xbox?

Windows Phone 7 SeriesProbably the hottest subject of discussion and presentations was Windows Phone 7 Series. I am, admittedly, an avid iPhone user who stood in line the first week they came out. I happily ditched my old Windows Mobile device and it's BlackBerry predecessors back then to live in Apple's world and I've never been seriously tempted to use something else until I saw WP7.

I really believe WP7 is a game changer for Microsoft and the mobile industry. Sure, it has some shortcomings. I don't know how they could decide to not include copy-and-paste as a feature in the first release. And like iPhone, they also do not have application multi-tasking and they appear to have similarly stringent plans regarding their app store.

But the interface is fantastic, I love the "hub" metaphors, streaming video and even Xbox Live over the phone looked amazing. Not sure exactly how badly those things will kill battery life, but they sure looked impressive. For heavy Outlook users, the Outlook mobile experience on WP7 may alone be enough to get you to switch. Just awesome. And there's a chance it could finally be the breakthrough that Zune has been looking for.

Silverlight 4 is definitely another big step in the right direction. They continue to slowly chip away at adoption and now claim that it's at 60% market penetration, probably mostly attributable to the Olympics and adoption and rollouts of Windows 7.

Tools like Expression Blend keep getting better, and Sketchflow may even be better than the competition, it is simply cool. IE9 beta demos also got big buzz. It appears they have surpassed Firefox on overall performance, are coming close to Chrome in many aspects, and for certain functions like handling of video and HTML5 they could end up being even faster and better (when running on a Windows platform of course) by taking better advantage of your computer's processor and using a form of background hardware-based acceleration. The head-to-head examples showing some really slick use of animation and video in HTML5 were really amazing.

The one thing that Microsoft has which no one else can offer (not Google, not Adobe, not Apple, not anyone) is an end-to-end story on tools and capabilities in this arena. The depth and breadth of their tools and services is truly staggering when you put it all together. And I'm not just talking about the typical story of Windows + Visual Studio + .NET + SQL Server. On top of that throw in Expression Studio with SketchFlow + Project "Dallas" + Azure + Silverlight + Surface + Windows Phone 7 + OpenData + IE9 + Bing Search and Maps and on and on. Sure you can poke certain holes in individual pieces versus their competitors. But the cohesive power of all that together makes for a truly impressive lineup.

Channel9 Live StreamingThere definitely were a few other good tidbits at MIX. Announcements around Orchard, freely available tools for WP7 development, great live streaming of Channel9 straight from the event, strengthening support for JQuery, and a surprising number of atypical logos on screens being talked about as friends (e.g. Wordpress, Drupal, PHP, etc.).

And the keynotes included fantastic sessions by Scott Guthrie (@scottgu), VP of Microsoft's Developer Division, and great demonstrations by consummate tech presenter Scott Hanselman (@shanselman). But for me, the highlight of MIX was the opportunity to see Bill Buxton, Principal Researcher Microsoft Research, speak live. He is simply brilliant and one of the most passionate people alive when it comes to interface design and technology.

If you've never seen him speak it is worth your time to google (or bing) for videos of his speeches and spend an entire day just watching them. As the conference organizer, Microsoft's Thomas Lewis (@TommyLee), put it in a tweet during Bill Buxton's keynote: "OMFG! Buxton's brutality has destroyed Vegas! Only zombies, mushrooms & lavender frogs have survived! DESIGN IS GOD!". I couldn't have put it better myself. Buxton's speeches are often too filled with memorable lines to count, though my favorite at MIX included "The most important thing in the system is the wetware... the human being" during a segment where he described the importance of taking into accountTwitter Post by TommyLee on Bill Buxton Keynote all the users different prior experiences within the specific environmental contexts of where, when and how they will use a system that you are designing.

Side note: I still don't understand how such an amazing guy who lives and breathes design and is considered the Father of Multi-Touch can have such a horrible personal web site, but I can only assume it's a "cobbler's children" thing.

And last but not least, the overall crowd and dynamic of the attendees at MIX was fantastic if not a bit quirky. It was a great group of highly intelligent people that are all passionate about great design and truly unafraid to ask the hard questions of Microsoft and dole out praise as well as tough love in person in the sessions and in torrents over Twitter. Unlike typical creative and design conferences it's definitely rooted in a true developer core (e.g. more guys still talking about compilers as opposed to a more mixed-gender crowd talking about heuristics and having used many tools like these for years), but unlike normal View from Tweetup at MIX Lounge at THEhotelMicrosoft conferences it's a large group of people who love great creative design and have been dying for Microsoft to bring these kinds of things to the table.

This conference in Vegas was more WXSW for geeks than it was the concurrently running SXSW, but Twitter and Foursquare definitely reigned supreme there as well as the tools that joined everyone together digitally during the sessions, into the evening, around the bars, and throughout the event. Sunday evening even kicked off the conference with a massive tweetup at the MIX Lounge at THEhotel at Mandalay Bay. There is a real embrace of Twitter showing through by Microsoft that is really uncanny with regard to how they normally react to any tech service that they don't build and own.

At Definition 6, we do use a lot of tools and services across platforms including a very significant amount of work in the Microsoft platform. And we do use tools and design for platforms that are competitive to many of those that were showcased at MIX 2010. But there is no doubt that what we saw there has given us a lot to think about, some great ideas, and a few new weapons to put in our arsenal. We look forward to using many of these to create great solutions for our customers and to seeing them continue to evolve and improve.

Consider a Content Delivery Network to meet website performance needs

Friday, May 29, 2009 by Mike Reese

If you've heard of Content Delivery Networks (CDN) then you probably either work for one or you've had issues with website performance. Or maybe you believe that there is a potential concern with increasing website traffic and how your application will handle it. First of all, if you're facing the fear of an expanding user base, you've obviously done something right. So how do you avoid being the one left holding the bag while end-users fall off your site in droves? Maybe a CDN is the right way to go...but maybe not.

As a Technical Project Manager for Definition 6, I've had the opportunity to work with clients and projects that require, at least, an initial discussion regarding performance, and others who simply do not. Let me focus on those companies first. If you own a lead generation website that leverages alternatives means for producing sales and receives 2,000 - 5,000 unique visits daily, odds are, you're not going to need advanced performance capabilities. If you are noticing issues, then take a look at your production configuration. Are you on a shared solution? Are you serving up heavy, rich media content? Are your servers out-of-date and unmanaged. Take a closer look and you might find that the potentially expensive CDN solution isn't necessary.

But for website owners that are out of capitol to invest in peformance increasing devices for a struggling system, or for those that wish to provide enhanced, rich media content to users, then look at a CDN as a possible solution to your problems. I recently read a post on www.websitemagazine.com by Peter Prestipino in which he introduced TinyCDN (www.tinycdn.com). If you've researched CDN's, you know how expensive it can be, depending on the size of your content and frequency of delivery. TinyCDN is a good example of a feasible solution from a complexity standpoint and budget concerns.

If you're considering one of these options, hopefully you've taken the time to discover what is causing your website's slow performance. What you don't want to do is spend your budget on improving usability and find out after implementation of those changes that users are experiencing the same degraded performance. Take the time to baseline your performance metrics, from an application and server standpoint. There are numerous tools available that can provide these key metrics. Take a look at your analtyics package as well, what is it telling you? Application can't keep up with continuous requests? Or maybe you've had a dramatic increase in requests to view your new product video. If you're in a pinch, give something like TinyCDN a try. A band-aid solution might not be so bad if it's reasonably priced and avoids the loss of users.

Introducing the Interactive Roadmap

Friday, April 17, 2009 by Ira Gross
The mantra of our time seems to be “do more with less.”  Nowhere in business is this sentiment more pronounced than marketing.  With the economy in free fall and marketing budgets slashed to the bone, maintaining market share, let alone growing market share, is more difficult than ever.  Enter the Interactive Marketing Roadmap.

One of the keys to “doing more with less” is reuse.  Most marketing organizations spend a lot of resources developing marketing collateral for various tradition channels.  These artifacts include direct mail pieces, television spots, brochures, catalogues and the like.  The goal of the interactive marketing roadmap is to identify the optimal re-use of these items on the web.  The challenge is to employ limited incremental spend to leverage existing assets created in traditional channels for re-purposing in the web channel.  Definition 6 has spent a lot of time and intellectual capital trying to address this challenge.  Via our Interactive Marketing Roadmap, you can get the benefit of this cumulative effort and knowledge base.

So let’s start with a simple example.  Your company is about to launch a new product, so the marketing manager has created a new direct mail piece to explain the offering.  For educational purposes, let us say that it cost one dollar for the design, development and distribution of the direct mail piece.  And let us also assume the target market for this effort is 50,000 households.  That would equate to a cost of $50,000 to reach 50,000 prospects, or $1.00 per prospect.  If the piece got a 2% conversion rate, the program would be considered wildly successful.  More likely, most of the direct mail pieces end up in the circular file.  And identifying the one’s that didn’t is no easy task.  Plus, the “shelf life” of the entire promotion is no more than a week or two.

Now, let us leverage the Interactive Marketing Roadmap.  In this instance, we would identify the best re-use of the promotional direct mail package for the web.  First, we would most likely turn the direct mail copy into a targeted email marketing campaign.  The cost to turn the direct mail content into an email friendly version is a few thousand dollars.  Then there is the cost of the email blast, usually no more than pennies per email.  So we can spend $5,000 to make the direct mail piece email friendly, and spend an additional $2,500 on email distribution.  At that point, we can blast the email to 100,000 prospects for roughly $7,500.  Hence we tripled the total audience of the initial direct mail piece for an incremental spend of less than 20% of the cost of the original direct mail piece.  And click through and conversion rates from targeted email marketing campaigns is in the 4% conversion range.  At even less incremental cost we can add the direct mail piece to the website as new and additional content.  This will boost natural SEO results.  We can also allow the promotional coupon to be live on the website for an extended duration, thereby increasing its shelf life.  And through all of these initiatives, we have the added value of web analytics to give us insight into who is actually receptive to our overtures, so we can do even better next time!

Now, imagine that you have multiple brands, each of which employ a wide range of traditional marketing tactics, and the messaging of those tactics varies by market.  The Interactive Marketing Roadmap will literally map out the alignment of traditional and web programs across all of these brands, assets and markets to create a uniform, comprehensive marketing and tactical strategic plan.  And we can create this plan in matter of weeks.  That enables the marketing department to get the benefit of this analysis for the duration of the year.  I consider that a prime example of “doing more with less.”  And Definition 6 is the only online ad agency to offer such a service.

Seven Top Online Marketing Trends for 2009

Wednesday, April 1, 2009 by Michael Kogon

Business Development Exec, Rhonda Vincent, shares with us the 7 top online marketing trends for 2009…

For online marketers 2009 will be a challenging year, they’ll need to build the basis for future expansion, leveraging social media, emerging technologies and vendor partners who are thinking about their business and find ways to maximize their budgets.  Here are 7 online marketing trends for 2009 that I came across on a ClickZ report:

• Increase customer retention efforts by marketing to your existing customer base – it’s cheaper and more effective because you know who they are and you understand their behavior.
• Create more attractive content – it will engage your customers and will help with your search engine optimization marketing
• Develop targeted marketing campaigns across a variety of mediums…e-mail, text messages, instant messages.
• Leverage online communities such as LinkedIn, FaceBook, Twitter…
• Increase your Web Analytics efforts
• Enhance search marketing advertising to expand across social media, mobile, and local search.
• Continue to integrate distribution channels despite higher cost

Interactive Ad Agencies like Definition 6 can leverage this insight to maximize your spends with the best ROI to get you through this year and still plan for 2010 initiatives.
 

Keep New Registrants Coming!

Friday, January 23, 2009 by Michael Kogon

Client Manager, Gabe Rand came across a Marketing Sherpa article discussing 6 steps on how a simple referral process can create a surge in registrations.  The 6 steps mentioned in the article include preparing your email servers, building a referral page, building your email message, protecting the information, providing incentives and keeping the process as simple as possible.

Kiwibox's registration process has 3 simple steps:
1. choose a username
2. enter personal information
3. refer friends

After selecting which of your friends will receive the email and clicking the 'invite your friends' button, the registrants are dropped onto the welcome page where they being interacting.  A screenshot of the welcome page is provided here as an example.
 

Login to Marketing Sherpa to learn how Kiwibox, an online magazine and social network for teens, launched a redesigned site and saw an immediate lift in their registrations.  Contact Definition 6 to find out how we can help in the website integration process of a new or existing email service provider.

Messaging in the Browser

Thursday, January 15, 2009 by Michael Kogon

Technical Project Manager, Jason Norton, shares an article he recently came across about how Mozilla looks at the future of messaging...

"The web is an increasingly chatty place. Between following comment threads, checking in with friends on Twitter, reading a few blogs with RSS feeds, and conquering a mountain of e-mail, we have plenty of conversations to keep track of. Mozilla wants to help us on the conversational journey, which is why the company has launched Snowl, a new tool that offers a small glimmer of hope for those seeking communications nirvana.

Announced on the Mozilla Labs blog, the company presents Snowl with a simple question: "Could the web browser help you follow and participate in online discussions?" Snowl has materialized as a prototype Firefox extension based on a few key ideas:

•  It doesn’t matter where messages originate. They're alike, whether they come from traditional e-mail servers, RSS/Atom feeds, web discussion forums, social networks, or other sources.

•  Some messages are more important than others, and the best interface for actively reading important messages is different from the best one for casually browsing unimportant ones.

•  A search-based interface for message retrieval is more powerful and easier to use than one that makes you organize your messages first to find them later.

•  Browser functionality for navigating web content, like tabs, bookmarks, and history, also works well for navigating messages.

For its debut, Snowl only supports RSS/Atom feeds and Twitter messaging, and it offers two UIs for reading. The first is a traditional three-pane setup where feeds and Twitter users are organized in a left sidebar, with a message list above the center column and a preview/reading pane below."

The traditional 3-pane list view

 

 

 

 

 

 

 

 

 

 

 

 

 

 

River View:

 

SharePoint is the way to go for an Enterprise 2.0 platform

Friday, December 26, 2008 by Michael Kogon

Definition 6 Client Manager, Andy McCann, recently presented an article to our group on how more and more companies are utilizing SharePoint as their next Enterprise 2.0 platform.

Recognizing Sharepoint's dominance in the Enterprise 2.0 space, many other Web 2.0 companies are now beginning to release and develop Sharepoint Web Parts and features that allow for easy integration into the Sharepoint environment. Not surprisingly, Microsoft's ability to build a huge Sharepoint user base is building a platform for partners to grow upon. This will allow for an even richer experience for Sharepoint users which in turn should help drive even larger adoption of Sharepoint which in turn should grow the number of available tie-ins to Sharepoint.

Andy pulled out three key points from his findings:

1. For many companies, SharePoint is the portal for all their business data - and not just docs, spreadsheets, presentations, and PDFs, but also browser-based forms that interact with built-in workflow technologies which add business logic to sophisticated online applications.
2. Microsoft and several partners announced new social networking, RSS feeds and other Web 2.0 technologies that allow integration with Microsoft Office SharePoint Server 2007 so users can integrate internal company data with outward-facing applications like external customer and partner communities. Awareness Inc., NewsGator Technologies Inc. and WorkLight Inc., for example, are all announcing updated versions of their Enterprise 2.0 tools integrated with SharePoint. Microsoft will also announce nine partners that have released or will release Enterprise 2.0 tools integrated with SharePoint.
3. Nine companies have recently launched Enterprise 2.0 offerings that integrate with SharePoint technology.  Here is an example of how NewsGator launched their SharePoint add-on



To read the article in its entirety, go to: http://www.readwriteweb.com/archives/sharepoint_to_run_enterprise_2.php

Contact us today to find out how Definition 6 works with clients to build and deploy Microsoft’s SharePoint applications.

 
The Business Blogging Platform Powered by Compendium  |  Sitemap