Website Writer Needed. English must be perfect $4 Per Page by adminAt

$4 Dollars per page – After you do some work, we can up this to 5 dollars per page when you are consistent. NO ESCROW, we can pay per page, so you are not out work. But escrow slows us down… (Budget: $30-250, Jobs: Academic Writing, Article Rewriting, Medical Writing, Research, Technical Writing)


Exclusive Freebies: PhotoViewer XML and Radar Chart

Everyone likes something for nothing, so why not sink your teeth into these two great free files from the ActiveToFocus team! Check out the demos, download the files then see what else ActiveToFocus have to offer over at ActiveDen..

Each of these free downloads comes complete with full source files and documentation (pdf, doc). For further support leave your comments below or contact ActiveToFocus through their ActiveDen page.


Freebie: PhotoViewer XML

PhotoViewer XML is a slick xml image gallery boasting a multitude of features.

  • xml driven
  • simple to implement and alter
  • accordion menu select
  • scrolling image display
  • supports swf, jpg, gif, png files
  • supports multiple categories
  • supports large number of thumbnails
  • all styles set through xml
  • image zoom in and out
  • image rotate
  • image resize
  • fullscreen

Freebie: Radar Chart

Also known as a web chart or a spider chart, this XML driven radar chart is a great way to display multivariate data; nicely animated, with a couple of display options. Try it out for yourself!

These Exclusive Freebie files are free for personal and commercial use only. They may not be sold or redistributed.

Creative Sessions: Interface Design Launch

Successful interfaces allow you to use them easily – they should feel seamless with the device you’re accessing with, and the experience you’re having. Successful interface designers have a theoretical foundation in numerous fields, which focus on planning and delivering great user experiences, as well as a strong graphic sensibility which they use to create interfaces that are attractive and fun to interact with. In this session we cover numerous subjects on Interface Design.

There are many fields that have risen in the last few years, such as Experience Design, Interaction Design, Information Architecture, and User-Centered Design that form the backbone of your interface design. We’ll be getting into these subjects in this session to give you a theoretical foundation and some starting points for study. We’ll also bring all this together and discuss interface design workflows of professionals and provide materials to learn Graphic User Interface (GUI) Design to get you on your way to creating professional interfaces.

Head over to our article on Getting Started with Interface Design to get going with a broad overview of interface design.


Participate in this Session’s Group Project

Jump over to this Session’s creative project on Create an Application Icon or Dashboard Widget. Choose the project to participate in that best fits your skill level and interest. This session’s Beginner/Intermediate project the brief is to make an icon for applications, which is great practice for building your GUI skills.

coda

We also have an Advanced project where you design a widget, which is a great way to get some hands on experience with designing interfaces, as they are typically smaller apps with a tight focus. You can post your projects in the comments here and get some feedback from the community.


Download this Session’s Cover Art as a Digital Wallpaper

Jump over to this session introduction to download this session’s wallpapers made by Wojciech Pijecki.


More Creative Sessions

Creative Sessions logo.Every month we’ll be running a two week Session on a creative topic. This Session is on Interface Design, and future Sessions will be on varied topics like, gaming design, and creative freelancing, and more. Unlike regular Tuts+ content, Sessions content is more theoretical, opinion based and will often cross many disciplines.

Handling Screen Architecture: The Painless Way!

Ever thought screen architecture was a needlessly painful and tedious task? Then this tutorial is your friend.

We found this awesome author thanks to FlashGameLicense.com, the place to buy and sell Flash games!


Final Result Preview

Let’s take a look at the final result we will be working towards:


Step 1: The Screening Process

If you are anything like I was, I always hated the beginning of a project, because I would have to set up all of the screens. After I stopped coding on the timeline, I lost the ease of just saying: gotoAndStop(x).

As we all know, timeline coding is just wrong; It pollutes the environment and causes tooth decay. It was simple to switch screens however. I spent a lot of time online trying to find an efficient method of screen switching, but all I found was methods full of pain, punishing the developer for having complex screen architectures. And not changing screens from the base screen caused me to slap ugly code into my game such as:

parent.parent.parent.dispatchEvent(Event.CUSTOM_EVENT, screen1_to_screen2);

See what I mean? Custom event after custom event, I grew tired of this absurdity. There has to be a better way.


Step 2: The Light at the End of the Tunnel

So, I set out to find a method of handling complex screen architectures without all of that pesky mental trauma. No events. I turned to my favorite way of handling tasks that need to be referenced from anywhere in the game: Static variables and methods.

Using static variables would allow me to reference an object from anywhere I wanted in the game, even in a popup of a popup of a popup. I decided to couple this with the simplicity and usability of Flash’s display list.

Enter the ScreenHandler class.


Step 3: Your Game

It probably has many screens. You likely have your splash screen, main menu, game screen, credits, victory screen, and many others. We need to set up our screens first. We won’t put any content into it yet, the gameplay is up to you.

Here are the screens I have:

These are the screens I'll be using in my great game.

As you can see, I have left out the preloader. Preloading correctly is a whole other tutorial. You can learn about it here:

Active Tuts+: The comprehensive guide to preloading a single swf file

I’ll explain how to combine this with that tutorial near the end. Now on to the part you’ve all been waiting for!


Step 4: The ScreenHandler Class

Essentially, the ScreenHandler class is a display object that holds all of your screens and internally switches them at will. The code is surprisingly simple. However, I won’t just lay a wall of code for you to run into. It would be a waste if you didn’t fully understand the code. So I will break it down into a couple of sections.

The first thing we need to do is create the actual class. Here is the code:

package  {
	import flash.display.Sprite;
	public class ScreenHandler extends Sprite{
		//Variables go here
		public function ScreenHandler() {
			//Constructor goes here
		}
		//Functions go here
	}
}

Wow, that is extremely empty.

Next we’ll add in our screens as variables:

private var splashScreen:SplashScreen;
private var mainMenu:MainMenu;
private var levelSelect:LevelSelect;
private var game:Game;
private var credits:Credits;
private var victory:Victory;

Just throw those under the “Variables go here” comment.

And just like that, we’re 1/10th of the way there!


Step 5: What Makes it Tick

This is the function that you will call to switch your screens. The good news is that it’s only 4 lines of code. The bad news is that it’s only because I like to break down my code into manageable chunks. This is the only public function in the entire class, as this is all you need to call to get the class to function. Encapsulation at it’s finest!

public function switchTo(screenName:String):void{
	newScreenName = screenName;
	switchScreens();
}

That goes under the “Functions go here” comment. Simple, no? Now you need to make a variable called newScreenName and a function called switchScreens.

private var newScreenName:String = "";

You already know where that goes. And here is the switchScreens function:

private function switchScreens():void{
	removeOldScreen();
	makeNewScreen();
}

I warned you: manageable chunks.


Step 6: I Still Don’t Know Anything!!!

Before you get angry with me, realize that I’m doing this for your own good. No, really. Breaking it up into manageable chunks like this makes it easier for you to find and alter the code if you need custom functionality. I myself always find the need to change code later on in the game, so I just adopted this coding practice. Also, if you are writing code and something’s broken, it’s easier to find the source of the problem. Ok, enough of my sidetracking. Here are the functions that make it happen (for real this time).


Step 7: The Beauty of the Display List

The removeOldScreen function takes its miraculous functionality from AS3’s display list. This was probably the best improvement from AS2. The parent-child relationship that the display list has is extremely useful in almost any visual manipulation, and looping through children in a display object is faster than looping through MovieClips in an array. It really is great. Before we write the removeOldScreen and makeNewScreen functions, we need a parent to hold the screens. Here’s another variable:

private var screenLayer:Sprite = new Sprite();

and add this line of code to your constructor:

this.addChild(screenLayer);

Alright, now we have a parent foundation that allows for easy modification and debugging. All that’s left to do is write the removeOldScreen function. Here is the code:

private function removeOldScreen():void{
	var oldScreen:MovieClip;
	oldScreen = screenLayer.getChildAt(0) as MovieClip;
	screenLayer.removeChild(oldScreen);
}

What we are doing is creating a placeholder variable that is going to ‘become’ our current screen. We then grab the child at the index of ‘0’ (which is the first child of the parent object) and set our placeholder equal to it. This convenient method allows us to do whatever we like to any screen without having to call the screens specific variable name. We then use the removeChild method to get rid of the screen for good. Just beautiful.

Well, now we can make a blank screen. It would be nice to be able to put something there, right? Well I’m about to tell you how to do that.


Step 8: Rectifying the Blank Screen

This is the most verbose section of the code, but it’s very easy to make, understand, and customize. This section of the code is basically a giant switch statement that contains all of your screens. The argument that we pass into the switch function is that newScreenName variable we set in the switchTo function.

private function makeNewScreen():void{
	switch(newScreenName){
		case "SplashScreen":
			splashScreen = new SplashScreen();
			screenLayer.addChild(splashScreen);
		break;
		case "MainMenu":
			mainMenu = new MainMenu();
			screenLayer.addChild(mainMenu);
		break;
		case "LevelSelect":
			levelSelect = new LevelSelect();
			screenLayer.addChild(levelSelect);
		break;
		case "Game":
			game = new Game();
			screenLayer.addChild(game);
		break;
		case "Credits":
			credits = new Credits();
			screenLayer.addChild(credits);
		break;
		case "Victory":
			victory = new Victory();
			screenLayer.addChild(victory);
		break;
		default:
			mainMenu = new MainMenu();
			screenLayer.addChild(mainMenu);
		break;
	}
	newScreenName = "";
}

The code is pretty self-explanatory, but I will explain it anyways.

case "Screen":
	screen = new Screen();
	screenLayer.addChild(screen);
break;

You associate a string to a screen. That string is the argument that you will pass into the switchTo function. It then goes through the switch statement and selects the correct screen to add. It then constructs an instance of the variable and adds it to the screenLayer. You aren’t required to set a default, but it’s useful to have a default for any switch statement you have for debugging purposes. It activates if none of the other cases match the argument.

Note: The registration point of the screens need to be at the top left corner for the screens to be displayed correctly.

Now we have the functionality behind the ScreenHandler class. Now it’s time to apply it to our program! Before we apply it to our program, we need to add a child to the screenLayer otherwise, we’ll have nothing to remove when we call removeOldScreen the first time. This will give us an error, and errors are bad. Mkay?

splashScreen = new SplashScreen();
screenLayer.addChild(splashScreen);

Add that underneath the rest of the constructor. Now go to the top of the class and import flash.display.MovieClip, if you haven’t already done so, and we can move on.


Step 9: Making it Work

If you haven’t looked at the tutorial I referenced earlier, now might be the time to do so.

Active Tuts+: The comprehensive guide to preloading a single swf file

Back? Great.

The screen handler will be added to the Application class. The actual sprite itself will be a public static variable, so you can reference it from anywhere in your code and it will switch the screen. Easy, right?

public static var screens:ScreenHandler = new ScreenHandler();

then add this to the Application class’ constructor:

this.addChild(screens);

If you ever need to switch screens from anywhere in your code, this is how you do it:

Application.screens.switchTo("SelectedScreen");

Step 10: There’s More?

Well, we’re done with the screen handler per se. After I code all of the buttons to switch to whatever screen I wish, it works.

You may say: “Thomas, this screen switching is ugly! I want screen transitions!”

Well, it’s a good thing the codes are easily customizable. Just ask nicely next time.


Step 11: Making it Look Good

The first step in adding screen transitions is deciding what kind of screen transition you want. For this example, I’m just going to make a simple fade out and in. Easy right?

  • Start by making a new Symbol.
  • Name it Transition, and export it for actionscript.
  • Draw a rectangle the size of your screen.
  • Make a new keyframe on frame 10.
  • Make a new keyframe on frame 20.
  • Return to frame one and convert the alpha to 0;
  • Go to frame 20 and convert the alpha to 0;
  • Right click on the space between the keyframes and select ‘Create Shape Tween’.

Your finished Screen Transition should look like this:

This is a screenshot of the screen transition. Not much movement here.

Now that we have that set up, lets code our Transition class!


Step 12: A Little Class

This is a simple class to set up for our purposes, although you can always customize it to fix your needs. It needs to extend MovieClip, and the only thing we are adding to it is a variable.

package  {
	import flash.display.MovieClip;
	import flash.events.Event;
	public class Transition extends MovieClip{
		public static var exitFrames:Number = 11;
		private var timer:Number = 0;
		public function ScreenTransition() {
			this.addEventListener(Event.ENTER_FRAME, remove);
			this.addEventListener(Event.REMOVED_FROM_STAGE, removeListeners);
		}
		private function remove(e:Event):void{
			timer++;
			if(timer >= 20){
				parent.removeChild(this);
			}
		}
		private function removeListeners(e:Event):void{
			this.removeEventListener(Event.ENTER_FRAME, remove);
			this.removeEventListener(Event.REMOVED_FROM_STAGE, removeListeners);
		}
	}
}

The variable we added was exitFrames. We set it to 11. Why? Because that’s the frame that the transition reaches 100% alpha, and it’s the frame we are going to switch the screens on. The other functions handle the removing of the clip itself and handle the removing of event listeners once it’s been removed. Less garbage collection, eh?


Step 13: But You Said No Events!

Remember how I said we wouldn’t use events? Well, I lied. The screen transition requires a few events so that the switching of the screen properly delays and the transition is removed after it has finished its job.

Since the beginning, my goal was to make this class as versatile and easy to use as possible. I didn’t want any headache when I set up my screen architecture. In keeping up with those guidelines, I will make the adding of screen transitions an option, since sometimes, a screen transition is not necessary.


Step 14: Changing Things Around

To add in screen transitions, we don’t even have to touch the removeOldScreen or makeNewScreen code because I separated them beforehand. It’s almost like I knew this was going to happen…

We are going to need a slew of new variables:

private var transitionLayer:Sprite = new Sprite();
private var transition:Transition;
private var transTimer:Number = 0;
private var makeTransition:Boolean;

The transitionLayer is going to house our transition clip. That way it doesn’t interfere with our screenLayer’s number of children. The transition timer is going to be used for timing our actions in the event just right. The make transition variable is going to control whether a screen transition will be used, that’s up to you!

Next, we are going to need to change things around in the constructor as well. This is what your new constructor should look like:

this.addChild(screenLayer);
this.addChild(transitionLayer);
splashScreen = new SplashScreen();
screenLayer.addChild(splashScreen);

And last but not least, go to you import area and import flash.events.Event. After that we can make way.


Step 15: Re-working the switchTo Function

I still want to keep this function short and sweet, as to not complicate the user end result. Encapsulation is great, no?

public function switchTo(screenName:String, trans:Boolean = true):void{
	newScreenName = screenName;
	makeTransition = trans;
	this.addEventListener(Event.ENTER_FRAME, switchScreens);
}

There are a lot of new things in here. In the arguments section, we added trans, which is set to true by default. This means, that unless you say otherwise, it is automatically set to make a screen transition. This saves you the trouble of having to type out ‘true’ every time you switch screens. Our makeTransition variable is then set equal to trans. The switchScreens function now will accept an event argument, which leads us to the next section.


Step 16: Re-working the switchScreens Function

Let’s focus on the code to make the screen transition work first. This will feature a good amount of change from our previously simple code.

private function switchScreens(e:Event):void{
	transTimer++;
	if(transTimer == 1 && transitionLayer.numChildren < 1){
		transition = new Transition();
		transitionLayer.addChild(transition);
	}
	if(transTimer >= transition.exitFrames){
		removeOldScreen();
		makeNewScreen();
       transTimer = 0;
       this.removeEventListener(Event.ENTER_FRAME, switchScreens);
	}
}

Let me break it down:

private function switchScreens(e:Event):void{
	transTimer++;
	if(transTimer == 1 && transitionLayer.numChildren < 1){
		transition = new Transition();
		transitionLayer.addChild(transition);
	}

First we add an Event argument into the function. We set the transTimer to increase by one every frame. If the transTimer is equal to one, and the transitionLayer has no children, we add a transition.

       if(transTimer == transition.exitFrames){
		removeOldScreen();
		makeNewScreen();
		transTimer = 0;
		this.removeEventListener(Event.ENTER_FRAME, switchScreens);

	}

Once the transTimer reaches the exitFrames we set earlier, we make the screen change happen. Because that’s what it’s all about, right? Then it resets the transTimer, then removes the event listener. Now it switches screens with a smooth screen transition!


Step 17: Re-working the switchScreen Function (Part 2)

We will now accommodate the possibility that you don’t want a screen transition to happen. We are going to wrap all of our current switchScreens code in an if statement:

if(makeTransition){
	//All of your current switchScreens code goes here
}

Wasn’t that easy? Now we make an else section for when makeTransition isn’t true:

if(makeTransition){
	//All of your current switchScreens code goes here
} else {
	removeOldScreen();
	makeNewScreen();
	this.removeEventListener(Event.ENTER_FRAME, switchScreens);
}

And there you have it, a fully functional screen handling class with the ablility to control the adding of screen transitions! Great stuff.


Step 18: The Full ScreenHandler Class

This is what the finished code will look like:

package  {
	import flash.display.Sprite;
	import flash.display.MovieClip;
	import flash.events.Event;

	public class ScreenHandler extends Sprite{
		private var splashScreen:SplashScreen;
		private var mainMenu:MainMenu;
		private var levelSelect:LevelSelect;
		private var game:Game;
		private var credits:Credits;
		private var victory:Victory;

		private var newScreenName:String = "";

		private var screenLayer:Sprite = new Sprite();
		private var transitionLayer:Sprite = new Sprite();
		private var transition:Transition;
		private var transTimer:Number = 0;
		private var makeTransition:Boolean;

		public function ScreenHandler() {
			this.addChild(screenLayer);
			this.addChild(transitionLayer);
			splashScreen = new SplashScreen();
			screenLayer.addChild(splashScreen);
		}

		public function switchTo(screenName:String, trans:Boolean = true):void{
			newScreenName = screenName;
			makeTransition = trans;
			this.addEventListener(Event.ENTER_FRAME, switchScreens);
		}

		private function switchScreens(e:Event):void{
			if(makeTransition){
				transTimer++;
				if(transTimer == 1 && transitionLayer.numChildren < 1){
					transition = new Transition();
					transitionLayer.addChild(transition);
				}
				if(transTimer == transition.exitFrames){
					removeOldScreen();
					makeNewScreen();
					transTimer = 0;
					this.removeEventListener(Event.ENTER_FRAME, switchScreens);
				}
			} else {
				removeOldScreen();
				makeNewScreen();
				this.removeEventListener(Event.ENTER_FRAME, switchScreens);
			}
		}

		private function removeOldScreen():void{
			var oldScreen:MovieClip;
			oldScreen = screenLayer.getChildAt(0) as MovieClip;
			screenLayer.removeChild(oldScreen);
		}

		private function makeNewScreen():void{
			switch(newScreenName){
				case "SplashScreen":
					splashScreen = new SplashScreen();
					screenLayer.addChild(splashScreen);
				break;
				case "MainMenu":
					mainMenu = new MainMenu();
					screenLayer.addChild(mainMenu);
				break;
				case "LevelSelect":
					levelSelect = new LevelSelect();
					screenLayer.addChild(levelSelect);
				break;
				case "Game":
					game = new Game();
					screenLayer.addChild(game);
				break;
				case "Credits":
					credits = new Credits();
					screenLayer.addChild(credits);
				break;
				case "Victory":
					victory = new Victory();
					screenLayer.addChild(victory);
				break;
				default:
					mainMenu = new MainMenu();
					screenLayer.addChild(mainMenu);
				break;
			}
			newScreenName = "";
		}
	}
}

This is how you implement it in the Application class:

public static var screens:ScreenHandler = new ScreenHandler();

in the Applications constructor, add

this.addChild(screens);

and use this function from anywhere in your code to switch screens:

Application.screens.switchTo("SelectedScreen");

If you don’t want a screen transition:

Application.screens.switchTo("SelectedScreen", false);

Step 19: The Finished Product


Step 20: Enjoy

I believe I accomplished what I set out to do. The class is easy to use and even more versatile in adding screen transitions than the good ole’ timeline. I hope you get some use out of this class, and even improve upon it and make it even more versatile. The sky is the limit with screen transitions, and maybe (probably), you can come up with improved methods of handling screen architecture: the painless way!


Conclusion

I hope you liked this tutorial, thanks for reading!

Quick Tip: Asset Tracking in 3Ds Max

If you work with more than one computer, keeping track of textures and scene files can be a nightmare! In this quick-tip, Benoit Staumont takes us through his ingenious solution to the problem. Utilising both Max’s Asset Tracking functionality and some command-line shortcuts, today’s tutorial shows you one way of managing your files across all of your Windows PCs.


Video 1

Download

Note: click the ‘Monitor’ icon to view tutorial in full-screen HD.


Don’t miss more CG tutorials and guides, published daily – subscribe to Cgtuts+ by RSS.

Fast Recipes for Work #1: Pierogi Casserole

Everyone knows that freelancers live on caffeine and nicotine, but it’s important to put the right fuel in your body occasionally.  Based on the feedback from a previous article, I’d like to present a few fast recipes that let you create a quasi-healthy meal, with a minimum amount of prep time, cooking time, and most importantly, clean up time.  Try out the recipe, and let us know what you think.

Pierogi Casserole

  • 1 small bag frozen pierogi
  • 1 jar of your favourite spaghetti sauce
  • 1 cup shredded cheddar cheese(or mozza, or both)

_____________________

Turn oven on to 350°F

Place frozen pierogi in a casserole dish (um, remember to remove from plastic bag…)

Add pasta sauce (pour over top of pierogi  – recycle jar)

Sprinkle with shredded cheese

Bake in oven for 45 minutes to an hour

Remove from oven, scoop into bowl, serve with side salad and/or garlic bread.

Go back to coding/writing/designing – with a full belly.


Awesome Links #5: Social Media Management, Web Design Tips, More

An insightful post by Tamar Weinberg on the importance of engagement and time investment in social media.

250 Quick Web Design Tips: Part 1 and Part 2

Six Revisions’ quick web design tips series is an excellent resource for both beginners and experienced designers.

Cool PC Apps: The Top 50 PC Applications for Freelancers

A list of essential PC applications for freelancers by our sister site, Freelance Switch.

How Google Works (Infographic)

An amazing infographic that shows what goes behind a Google search.

A Guide to Irfanview: Desktop Tool For All Your Image Editing Needs

A guide to Irfanview, the popular freeware for editing images. The article talks about some superb features of this well known yet underrated tool.

Giving Dressing Up a Dressing Down

WorkAwesome has offered quite a few articles about dressing professionally. Some suggest that helps you to get promoted and gain respect in the workplace. It’s certainly good advice; dressing well is a positive statement about your attitude and preparedness. But, how big of a statement is it? Should we be taking such care to “look sharp,” or have the effects been embellished?

There’s an obvious correlation between higher-level jobs and better dress, but perhaps it’s a classic “chicken or the egg” conundrum: Which comes first? Are people promoted or hired due – in part – to their professional appearance, or do their high-level jobs enable (or require) them to dress better? Maybe the only reason that executives dress well is because they have to.

I was skeptical. I know a sweater from a suit, but I didn’t think clothing had much influence on the way you’re perceived, respected, promoted or paid. There are plenty of wildly successful people who don’t dress particularly well. For every suit-wearing Donald Trump there’s a Steve Jobs wearing a black turtleneck with bluejeans. They’re both successful in their own ways, suggesting that dress doesn’t matter much.

So, to determine if dress really matters, I dressed very poorly for one week, and then I conspicuously overdressed for a second one.

The “bad duds” consisted mostly of poorly-patterned shirts, threadbare slacks with small holes, mismatching colors, and ill-fitting garments. My absolute worst was a hideous button-down shirt – tight at the shoulders, billowy at the waist and patterned like diagonal, faded graph paper. Don’t ask me where I got it. Combined with a pair of khaki pants that would make MC Hammer jealous, I had a perfect outfit for dressing poorly at work.

The better clothing is newer, more expensive, more stylish, more formal, and a much better fit in all cases. The best outfit I could put together is an expensive suit tailored perfectly for… the friend that loaned it to me. Fortunately, we’re the same height, weight and body type. I’m not one to care much about style, but I must admit, I feel good in the suit. It has a silk-like fabric, with nearly-invisible stripes that join perfectly at each seam. I never got to see the price tag, which is probably for the best.

A more precise, more controlled experiment would be much longer; I’m sure appearance-related changes – if they truly exist – take more than a few weeks to develop. It wasn’t a perfect test by any means, but I was observing carefully for appearance-driven differences.

The Week of Geek – Week 1

Dressed carefully in my worst, I looked haggard, and people took notice. I was called a “goofball” and a “propeller-head” separately, both times in front of several other coworkers. In terms of work, It was suggested that I do not write any of the marketing copy for a website I had just built, as in “if you let the geeks do the marketing, who knows how it will turn out!?”

I suspect words like “goofball,” “propeller-head,” and “geek” have as much do with my personality as it did with my clothing, but those seemingly-harmless comments somehow led to the notion that I wasn’t able to write effectively or connect with customers. In a roundabout way, my abilities were inferred from a quick look at my appearance, and I was pigeonholed as a “code geek” who communicates better with a computer server than a fellow human. In their defense, I was intentionally dressing the part, but appearance – apparently – can have a strong, albeit indirect effect on perceived abilities.

A few close coworkers made some friendly jokes about my wardrobe. They weren’t in on the experiment; were they laughing with me or at me?

Finishing With Flair – Week 2

Week 2 felt notably different. Somehow I felt more relaxed in more formal dress. I looked good, I felt good, and I worked more productively. My coworkers did notice the sudden change in appearance, and their lighthearted teasing turned to genuine complements. Whether it was the clothing itself or the compliments, I took myself more seriously. Maybe they did too.

During week 2 I was invited to attend several executive-level meetings about up-and-coming projects. I had never been invited to these before. Coincidence?

Conclusions:

  • Good or Bad, People Notice: When my dress went from normal to bad, bad to fantastic, and fantastic back to normal, every change was noticed. It seems you can impress just as easily as you can underwhelm, and people unknowingly make inferences about your skills from your appearance.
  • Looking Good Feels Great and Works: Even if dressing better had no other effects at all, it made me feel good, It improved my attitude, and in turn increased my productivity and work quality. It’s probably the after-effects of dressing well that can elevate your status, not the clothing itself.
  • Importance Varies: My appearance, whether dapper or dismal, didn’t have a tremendous impact on my work. But, had the same “fashion statements” been made by a director or a “C level” executive, they would have been saying “I take this seriously” or “I don’t care” much more loudly than I ever could.

Two weeks is just a glimpse into the effects; given more time, looking sharp (or looking shoddy) could have a much larger impact. Dressing well won’t single-handedly improve your status at work, but according to my makeshift experiment, it does have some subtle, indirect benefits.

Mixing Twitter and Work

Twitter. It’s a great escape.

It’s overflowing with helpful resources and links. It gives you an inside look at the latest trends and enables you to connect with authors, celebrities and industry professionals you once could only admire from afar. What’s not to love?

The allure of Twitter is getting harder and harder to overlook, but many workers are still hesitant to fully participate. Social media is often viewed as a distraction in the workplace. Making your tweets public is like giving your boss a minute-by-minute record of your distraction level. Do you really want to chance using Twitter at work?

Besides the whole not-working-at-work stigma, Twitter can potentially lead to other problems as well. Although you may try hard to keep your tweets professional and clean, you never know how someone else might interpret them. What you think is smart and funny may be a total turn-off to someone else. Self-employed workers must be careful to avoid offending potential clients as well. There’s a certain level of risk to be sure. You have to find a way to be smart about it.

So how do you handle Twitter in the workplace? Do you tweet at work? Do you choose to keep your profile private? Or do you think these concerns are not really that big a deal?