NIC or Gov dot in sites

Or the title should be “desperately needed – UI, UX, Graphics and web designers – contact E-GOV and TCS.”

Disclaimer: This one may come off “ranty”. At the same time, I do appreciate the increased usage of technology being by many departments.
I had the pleasure of going through one of the many e-gov websites yesterday.
http://passportindia.gov.in/AppOnlineProject/welcomeLink
The first impression in my mind was the flashing of a few other sites built for the government – “Oh, another one of these”. Is there a specification which states that the delivered website must conform to some well defined “ugliness standard alpha”? Most of them seem to have a common theme of marquees, blinking text and just unclean looking interfaces/color combinations/gradients. Is there a pointy haired (or is it the more traditional “topi wearing” in this case) boss who says, “Okay team, build this website. Designers, your reference word is – ‘vomit’. Good luck.”

Looking  at the passport seva website, is our friend the marquee there? Check. Do we have blinking text? Check. Can we make it “colorful“? Certainly.

Passport Seva website screenshot

Passport Seva website
Ministry of External Affairs, Government of India

On this particular website, look at the logos at the bottom – left: Facebook, Twitter, YouTube, Flickr and right: National e-Governance Plan. Those and the “Expanding Passport Services” images all have some really bad compression artifacts. That’s just tardy. Upon previously sharing this screenshot, one comment I received was, “they probably scaled them up from a 10×10 pixel source image”. My guess is that they took a mobile phone, pointed it at a newspaper ad (and not the glossy kind) which had the logos on them, clicked a photo and then uploaded that to the production website. One thing that I’m slightly impressed with is that they’re using a css sprite for the logos! This screenshot was taken in IE 9 as the “best viewed in” text asks. In Firefox 15.0.1, the menu items on top occlude part of the “Ministry of …” text.

I used to think they might be giving out these projects to school kids (the one’s who’s parents pushed them to take “computer subjects” in school without any interest of their own). Must be a program by the education department to give students some practical experience. Oh well, that’s how they’ll learn and then improve. Wait! what’s that written in the footer of the website – “Maintained By TATA CONSULTANCY SERVICES“.

I’m going to make a mental leap from that and assume it was also developed by the same company. TCS is supposed to be quite a reputed firm. I find it hard to believe they shipped this. A team of professionals released this?! Where’s the pride that professionals are expected to have? “I cannot let something like this be credited to me. This is not a showcase of what I can do. I’m expected to do better. I will fix it and deploy, even if I work a few hours extra this week.

I doubt there was a shortage of funds to get the team to deliver higher quality. I assume the government pays well for these projects. This is TCS (Rs.1411.95 on BSE as I write this), not a one person development shop (who learnt “HTML at NIIT(if you’re a fan, insert other generic school)” and was forced into taking this project) that’s low on funds to work harder to deliver higher quality.

This is just plain sad. I’m going to be optimistic and think that they will improve soon. At least the passport offices have the concept of giving an appointment rather than a bunch up at the entry point (another skill that we are great at) as was the case a few years ago. That’s an improvement.

Know of any similar “works of art”? Post away with links in the comments.

Posted in Computers and Internet | 4 Comments

Wizard of code [response]

Recently, Hindustan Times got in touch with me for input on an article in their Education section related to a career in game development (programming). This was published today (September 05, 2012) on page 2 of the Education insert, titled Wizard of code (in their New Delhi edition). Although I’m glad to have my photograph printed in an article with that title, I don’t fully agree with the content of the article. I think it leaves out quite a bit of information which would be useful for people looking to learn or get a career in programming games. In fact, some content of the article might mislead or confuse students. The article seems to include information more specific to a career in game art which was posted in an earlier issue.

I’m attaching a copy of the article below with highlighted portions to elaborate. A link to the original article is: http://paper.hindustantimes.com/epaper/showlink.aspx?bookmarkid=ITFJOPDZ2205&preview=article&linkid=1705b0af-cfff-40c2-bec9-50354a6f2b54&pdaffid=5ncoZjso4AlFtIgb4L6Vlg%3d%3d

Game development article highlighted

My views
creates art” – A programmer does not create art. An artist does. There may be exceptions of one man teams or programmers that also happen to have learnt and practiced creating production quality digital art but those are exceptions, not the rule.

all aspects of game development where visual art is required” – A programmer might work on (procedural) visual effects or tools to support them but writing “all aspects” is misleading. The latter part of statement about writing code to enforce rules of the game world (or system) in more accurate to what a programmer does.

Meeting with art director” – Once again, a programmer might meet the art director on occasion but not every morning. S/he is more likely to meet the technical director, a lead programmer or other developers in her team every morning. This meeting would let the team know how development of the current feature they’re working on is going. Whether they’re stuck on something and need ideas or solutions. They’d discuss concerns related to one feature integrating or working correctly when brought together with components/features that others on the team are working on.

6:30pm to 8:30pm” After committing code into version control in the evening (which would ordinarily take under 5 minutes), the person is either going to work on a personal research project or the team would get together to play some multi-player games! (This is not frowned upon). That should cover the two hour window mentioned in the article.

The Payoff section talks about becoming a senior game artist or later an art director. Instead this would be senior game programmer, lead programmer or technical director.

The Skills/Traits section mentions “An artistic bent of mind” – while it doesn’t hurt to have an artistic bent of mind, it’s more of a requirement for an artist. The section should include:
* A strong sense of logic and the ability to do research for coming up with solutions
* The ability to break a large problem down into smaller components/steps.
* Team skills – your components must work cohesively with those of others. Using version control (under-taught!) is critical for collaboration.
* Good communication skills, your code should be written in a way that makes it easy for team members to understand in case they need to modify parts to implement other features.

Getting There talks about studying “visual communication in fine arts“, once again, this seems like something more important for an artist. It talks about a taking courses in “animation“. Animation may mean many things in games (such as the code which animates a character which a programmer would be involved in) but the term, when used by schools, usually refers to animating digital assets. These courses teach students the creation of sprite frames for 2D animation (in tools like Photoshop/Flash etc) or the animation of 3D models (in tools like Max/Maya etc). While a little knowledge about using these tools may be handy since artists are going to be team mates of programmers on projects; the knowledge would help them be on the same page or communicate better but knowing detailed usage of these tools is not necessary for programmers. For a person would be like to be a game programmer, taking a course in “animation” may not be the best use of her time. S/he should concentrate on getting better at programming. This section should have been something on these lines:
You should code. Learning programming itself may be simple – what’s required is to practice it over and over to become masterful at it. You may enroll in a programming school (NIIT, Aptech, M/BSc, M/BCA etc) or use books or online resources to learn the basics, but that’s as far as it goes. Programming a lot make you start “thinking in the language” which is required. You may not even need a degree to become a highly paid developer if you truly learn to code. Though a school (getting a degree) offers a starting point and organized setting to learn in – and many prefer to learn in a peer group situation.
[See http://abstrusegoose.com/249 ]
“Joining an open source programming project online may also be a great way to learn more and it can showcase your skill. Community sites like Codeplex, BitBucket, GitHub and SourceForge are a few examples.” echos my views in the article.
Further, a skill which I feel is grossly under-taught (or not taught at all) in schools is using version control tools. These are critical to work in a team and offer benefits even on single person projects. Using tools such as Mercurial or Git is critical.

I’m glad that the article included the link to the Mercurial tutorial Hg Init. If just/even one student takes note of that article and starts using mercurial, I’d say the article was worth it!

My older (2008) post Getting into (programming) Games still has a lot of information which is still valid. Perhaps instead of the information on NintendoDS/Homebrew, learners might want to try similar exercises on Android/iOS/WP etc considering the mobile/smartphone penetration rate and the growing requirement for skilled developers on those platforms.

For what it’s worth, here’s the link to the older article on game art which shares a lot in common with the current article:
http://www.hindustantimes.com/HTNext/Education/Game-artists-are-in-demand/Article1-763522.aspx

Similar article for game artists

The post was re-blogged at:
http://www.consultingnetwork.co.in/wizard-of-code-the-response-by-pranav-tekchand/2543/

Posted in Computers and Internet, Press | 2 Comments

NodeJS

A team had been evaluating using NodeJS for a turn based multi player game’s server. For learning, they were using the built in net api component. They manged to get a basic two player messaging system going, first with an HTML (with XMLHttpRequest) test-client, then a Flash/SWF test-client. They still seemed to be having intermittent issues with the system’s reliability and trying to create a second game room (so that 4 players are connected in all) was also problematic with occasional crashes.

To help sort out the issues, I started learning a little NodeJS by looking at the docs and experimenting with samples. At first I didn’t quite understand the createServer functionality, I kept thinking back in terms of socket programming (in C) that I had learnt many years ago. I then looked at the code base the team had for the server – I had looked at it once earlier with another developer and I asked him whether he tried adding a few traces to better explain/understand what socket was in play at various points in time. He had said that using console.log with JSON.stringify was crashing the program. The developer had somehow got it working by using a few global variables as hacks. Another issue was the socket being closed and re-connected once again when the SWF was embedded in the browser (as opposed to running it directly from the IDE).

This time I tried tracing the net and socket object in the echo server sample and the game server code base. Upon doing so, I ran into the crash:

"TypeError: Converting circular structure to JSON"

A little reading showed that (as the error itself almost always states) a circular structure is an object which contains a reference to itself in its properties (or somewhere down the chain – property’s property). If this exception weren’t caught, the existing stringify implementation would be stuck in an infinite loop (creating an infinitely long string).

I felt getting some form of trace was the quickest way to better understand what was going on in this program. After a quick search to see if there was anything equivalent to a “shallow stringify”, I hacked one up [Gist]:

At first shallowStringify traced too much – function bodies which were properties of the socket object were also traced. I tweaked the helper to skip these (just trace the function’s name). This traced enough information to help identify which object was active where at various times.

Turned out that createServer offers functionality in a simpler manner or at a higher level than what I was thinking. The issue turned out to be the global variables that the developer had used. He too perhaps had been thinking in another language when he wrote the code. This is Javascript – it’s got closures and function scope. The handlers that he wrote for the events did not know which socket they were for.

// socket object available here.
// The handler was set up similar to:
client.on('data', onData);
// ...
function onData(data) {
  // handle data
}

Thanks to closures, the socket could be passed in.

// socket object available here.
// The handler was changed to up similar to:
client.on('data', function(data) { 
  onData(data, socket);
});
// ...
function onData(data, socket) {
  // handle data
}

By changing the code to pass in the socket like this, he got rid of the global variables and the code also began working for multiple game rooms. Plus everyone finally understood why the previous hack worked intermittently and why the new code worked correctly. As far as the double connection when the SWF was embedded in the browser was concerned, it turned out that the first request was for the cross domain policy file.

Posted in Computers and Internet, NodeJS | Leave a comment

Hello world!

Welcome to WordPress.com. This is your first post. Edit or delete it and start blogging!

Posted in Uncategorized | 1 Comment

Preprocessor output

I’ve been trying to migrate some code from one framework (Gramebryo’s older core) to another (the new Game Framework) and ran into some errors. Here’s some fixes/findings.
I have been diving in to the preprocessed output of source files for a lot of these fixes. In VS2005, use /P or on a source file’s Configuration Properties > C/C++ > Preprocessor > Generate Preprocessed Files.
 
It began with getting some "unresolved external symbols: boost::throw_exception" errors. That was resolved by switching on C++ Exceptions on the (VS2005) project. Without that, BOOST_NO_EXCEPTIONS defined in boost/config/compiler/visualc.hpp (for NewService.i)
This was not defined for older OldCore.i. Depending on that macro, a declaration or definition gets preprocessed from boost/throw_exception.hpp.
(Configuration Properties > C/C++ > Code Generation > Enable C++ Exceptions.)
 
The older project’s debug builds had _STLP_DEBUG enabled, enabling that on the new project got some ambiguous calls to Sleep; on source files which had a particular ‘using namespace’ statement.
Btw, I used a utility called cppdep (by Chris Steinbach) to find the "include chain" of certain headers. I hacked in a little code to it so that it prints out the chain for me; I’ve uploaded the modified cppdep here [x]. Edit: re-hosted on GitHub.
The usage for this version is:
 python explore.py PreprocessedSource.i HeaderToSearch.h.
The output would be something like:
* HeaderToSearch.h
< ParentHeader0.h
 …
< ParentHeaderN.h
< InputSource
 
Anyway, the ambiguous calls were cleaned up by getting rid of the using namespace statements and explicitly using the namespace-name:: where required.
 
Other tools that can be handy when dealing with such issues:
undname.exe decoratedname
This is a command line tool (VS bin directory) that takes the decorated name as it’s first argument and outputs a human readable (un decorated) format of the symbol.
dumpbin /LINKERMEMBER libname.lib | grep SearchSymbolName
Is another useful command line (VS) tool that can be used (apart from other switches) to list the decorated symbols in a lib.
lib /LIST filename.lib
Can be used to list the obj files that comprise of the lib.
 
Then I got some more unresolved external symbols, symbols that I was quite sure existed. Anyway, I opened the lib file that I thought would have the symbol in the (in a hex editor) and searched for the name of the function. After pasting the name of the unresolved symbol from the error/output window and the symbol name from the lib in a text editor; switching off word wrap revealed: the whole name was off by 1 character – stlp vs stlpd. One of the dependent projects also seemed to need _STLP_DEBUG to be defined on it.
Gamebryo uses STLPort and one of projects in the solution uses boost (1.34.1) and that expects _STLP_DEBUG to be defined in debug mode (in boost/config/auto_link.hpp). Though enabling the macro on the dependency breaks as it ends up needing all the Gamebryo libs to have it also enabled. This is something I’m currently trying to work around.
The issue has been fixed. I got rid of the _STLP_DEBUG macro from the projects. Switched off boost’s auto linking feature (BOOST_ALL_NO_LIB). Built the required boost libraries (BOOST_LIB_DIAGNOSTIC) with the runtime-debugging option set to off, the stdlib option set to stlport and linked to them manually.
To build, I used:
Edited tools/build/v2/user-config.jam:
using msvc ;
using stlport : 5.1.5 : D:\…\stlport D:\…\lib ;

and ran:
bjam msvc variant=debug,release threading=multi stdlib=stlport link=shared,static runtime-debugging=off runtime-link=shared stage

Posted in Computers and Internet | 3 Comments

Saving Some Memory

I’m about to write something about a language that many of my other colleagues would go “Ew! You willingly touched that language?”. All I can say in my ‘defense’ is that at the end of the day its the solution/the algorithm/getting things done that matters.
Some colleagues working on mobile/J2ME games were getting ready to test some of their games on devices. They ran into IOException when loading assets primarly: OutOfMemory – Even though “It all works great on the em/simulator”. They were building a game on a Motorola K1 – the spec says it provides a 900KB heap (Runtime.totalMemory() traces approximately 839000). Note that the em/simulator runs on the PC and allocates more memory for itself. Also note that the size of the JAR/PNG on disk doesn’t particularly matter (yes, its obviously proportionate). The amount of memory required by most devices is: width x height x 2(16 bit indices). The game used a Sprite class which loads a large image containing the individual animation sprites, and it takes the height and width of the individual frame as a parameter. Considering most of the images have a large numer of transparent pixels, this seemed like quite a waste of memory to me. Especially I believe drawing an image on these devices is more of a ‘blit’ rather than a ‘lookup texture for fragment’ operation. Here’s a strategy I threw together in a couple of minutes to help out. The basic idea is to let the artist make a normal large image (or even multiple images of the same size) so that s/he can continue to control and see where in the frame the asset is (without any additional learning curve for some other image creation strategy) and split it using the scheme mentioned below and change the loading/drawing code accordingly to accommodate it.

// Here's how to split the image into more tightly packed sub images.
// This assumes that drawing of the frame images in the initial large
// image that you're currently using is relative to the center of the 
// frame.
// Fix up syntactical issues for Java, and fill in appropriate function names
// Note this splitting is an offline process. Especially since you
// need to write out the individual images. Do it on the device would be
// pointless unless you have a really long content pipeline and wish to
// save a step.

// This information would be used to draw the sub image at an offset
// to the initial frame.
class SubImageDimDesc {
	// If needed
	//int top, left;
	//int  bottom, right;
	int xOff, yOff;	// I hear the drawing is relative to the center of the sprite
};

void createSplitImages(
	String baseFilename,		// "player" for "player.png"
	int frameWidth, frameHeight,	// individual frame dimensions. eg. 86x75
	)
{
	Image baseImage = Image.createImage("/"+baseFileName+".png");
	// Full input image dimensions. eg. 1032x225
	int totalWidth = baseImage.getWidth();
	int totalHeight baseImage.getHeight();
	int totalPixelsUsed = 0; 	// Just statistical data.
	int rows = frameHeight/totalHeight;
	int cols = frameWidth/totalWidth;
	// Color data in input image 0xAARRGGBB (Alpha, Red, Green, Blue)
	int [] rawImageData = new int[totalWidth*totalHeight]; // populate with input image data.
	// TODO: Populate 
	//Image.getRGB(rawImageData, totalWidth, totalHeight); // FIX ME

	SubImageDimDesc [] subImageDims = new SubImageDimDesc[rows*cols];

	int i=0;
	for(int r=0;r<rows;++r)
	{
		for(int c=0;r<cols;++c)
		{
			int top = frameHeight;
			int left = frameWidth;
			int bottom = 0;
			int right = 0;
 
			int subFrameWidth, subFrameHeight;
			// Find sub Image Dimensions from individual frame in large image.
			for(int h=0;i<frameHeight;++h)
			{
				for(int w=0;i<frameWidth;++w)
				{
					int pixel = rawImageData[(h*totalHeight)+(c*frameWidth)+w];
					// could also user if(pixel) but we can only check the alpha channel instead as well
					if((pixel & 0xFF000000)>0)
					{
						if(h<top)
						{
							top = h;
						}
						if(h>bottom)
						{
							bottom = h;
						}
 
						if(w<left)
						{
							left = w;
						}
						if(w>right)
						{
							right = w;
						}
					}
				}
			}
			subFrameWidth = right - left;
			subFrameHeight = bottom - top;
			// Allocate and populate data in the sub image
			int rawSubImageData[subFrameWidth*subFrameHeight];
			for(int h=0;h<subFrameHeight;++h)
			{
				for(int w=0;w<subFrameWidth;++w)
				{
					int pixel = rawImageData[((h+top)*totalHeight)+((c+left)*frameWidth)+w];
					rawSubImageData[(h*subFrameHeight)+w] = pixel;
				}
			}
 
			// FIX ME: See docs for function to set image data.
			//Image subImage = Image.setRGB(rawSubImageData, subFrameHeight, subFrameHeight); // FIX ME
			//subImageDims[i].top = top;
			//subImageDims[i].left = left;
			//subImageDims[i].bottom = bottom;
			//subImageDims[i].right = right;
			subImageDims[i].xOff = (frameWidth/2) - (left+subFrameWidth/2);
			subImageDims[i].yOff = (frameHeight/2) - (top+subFrameHeight/2);

			String subImageFilename = baseFilename+i+".png";
			// Write this sub image. TODO: Find correct function for this.
			// subImage.writeToFile("/"+subImageFilename);
			// Append subImageDims[i] to a descriptor file: FIX ME:
			//File splitImagesDescFile = File.open(baseFilename+".txt", MODE_APPEND);
			//splitImagesDescFile.write(subImageDims);
			//splitImagesDescFile.close();
			totalPixelsUsed += subFrameWidth*subFrameHeight;
			++i;
		}
	}
	System.out.println(i+" sub images created. This would save a total of "+((totalWidth*totalHeight) - totalPixelsUsed)+" pixels compared to the original image's memory footprint");
}

//-----------------------------------------------------------------------------
// The split images sprite class could take the "baseName" from above
// and a number (rows*cols) of images in this 'sequence'
class SplitImagesSprite {
	SubImageDimDesc subImageDims[];
	Image subImages[];
	SplitImagesSprite(String baseName, int numImages)
	{
		// Load Descriptor
		subImageDims = new SubImageDimDesc[numImages];
		// TODO: Read dims from file
		//File splitImagesDescFile = File.open(baseFilename+".txt", MODE_READ);
		//splitImagesDescFile.read(subImageDims);
		//splitImagesDescFile.close();

		// Load images
		subImages = new Image[numImages];
		for(int i=0;i<numImages;++i)
		{
			String subImageName = baseName+i+".png";
			subImages[i] = Image.createImage("/"+subImageName);
		}
	}

	// When drawing the ith image/frame, draw it at the offset
	// if earlier it was something like g.drawImage(baseImage, playerPosX+frameLeft, playerPosY+frameTop, frameWidth, frameHeight);
	// it would be something like g.drawImage(subImage, playerPosX+subImageDims[i].xOff, playerPosY+subImageDims[i].yOff);
	void drawFrame(int frameNum, int posX, int posY)
	{
		//g.drawImage(subImages[frameNum], posX+subImageDims[frameNum].xOff, posY+subImageDims[frameNum].yOff);
	}
};

The first image shows 15 frames in a single image and the other two show the first frame and the last frame saved separately. Some back of the envelope numbers, each frame in the input image is (86×75) 6450 pixels. The first split image is (50×57) 2850 pixels and the last one is (63×20) 1260 pixels. Congratulations you just saved about 55% on one and 80% on the last one.

Potential interviewees, if you’ve been reading so far, this might pay off since I might base some questions on this – I don’t think I’d particularly care about you knowing the insides of a language as long as you can be creative and demonstrate a thinking mind. Additionally, It is possible that reading from disk (flash) on phones might just be twice as expensive as reading from RAM (something on the lines of a Nintendo DS?), in that case infrequently used frame sequences could be kept out of memory. Also note that I don’t claim to be an expert about Java/mobile games, so if you have something constructive to say, go ahead and comment (otherwise, you know the drill.). I learnt that there’s a memory monitor that comes with the WTK in my quick look into J2ME, if you’re not aware of it or aren’t using it – get acquainted with it.

In other news, I quickly made a little asset to throw at my exporter to load up in a project which is ‘coming soon’ on the iPhone. Perhaps I’ll post some screenshots later (Update: See the album named ‘Kangaroo Quest’).

(3ds Max – Creating an Asterisk)
Line (Spline) tool (make half the asterisk in the front viewport)
Mirror Y axis (copy)
Modify panel > attach
Weld
Delete (the un-necessary vertex in the middle on the Z/up axis.
Extrude modifier
Convert to editable poly
Connect vertices to makes sure all faces are quads/tris.

There, now this post isn’t only about J2ME.

Posted in Computers and Internet | Leave a comment

Naming Assets

This has been lying as a text file on my desktop for a while to improve upon. I thought I’ll put it up and see what comments I get.
At the same time I’ll use this opportunity to announce that I finally have a domain http://pranav.tekchand.net (after patiently waiting to snatch it up). The site currently just links to this Windows Live Space and other online profiles. It also has some contact information.
As for this post it is still loosely laid out from thoughts I scribbled (excuse me for that).

ArtFileNaming.txt
Use project, model-character/object name, a serial/version number, change and/or separate changelog.txt

When a programmer requests art work from an artist s/he should also suggest a file name depending on what component (variable in code?) it would be used for. Since a programmer might have already spent some time thinking of appropriate variable names and is much more used to that process than most artists.
For example, for a contrail/jet stream effect, an artist (**) gave the texture pranav_sky_alpha.png, which was then renamed to StreamTile.png since it was a tile-able texture to be used in the jet stream effect from the sky diver’s hands. The examples could go on – like this particular video required for project XYZ: XYZ.avi, XYZ_Subbed.avi XYZ_Subbed_4.avi, XYZ_Sound.avi,  XYZ_640x480.avi, (and many more).

When creating an art requirements list, the PM/Lead/Art director should also spend a little time on names.

Artists should be encouraged to think of more meaningful names as well.

A proposed convention:
[Project Name]/[Asset Name].[Revision Number].[Optional change description].{extension}

Project Name: Project for which the asset is currently intended for.
(More sub directories to sort/classify the asset; examples:  Characters, Objects, Vehicles, Videos, …)
Asset Name    : Name of the asset.
Revision Number: An increasing number for the times the object has been modified. Think of this as the ‘incremental save’ feature in 3Ds Max, where it automatically adds/increases a number at the end of a file name.
(A decimal may be used for intermediate saves)
Optional change description: A few keywords describing the change made. Alternatively, there could be a "Changelog.txt" in the same directory as the asset. Which would contain the Revision Number (or full file name) followed by the description of the change made.

Examples:
TheAwesomeGame/LeadCharacter.3.TextureApplied.max
TheAwesomeGame/LeadCharacter.3.1.ModelTweaked.max
TheAwesomeGame/LeadCharacter.3.2.UVMapTweaked.max
TheAwesomeGame/LeadCharacter.4.TextureChanged.max
.3 and .4 are files that the artist would submit to the PM/Lead/Art Director (or whoever requested the asset). 3.1 and 3.2 are just saves made at ‘good stopping points in time’ by the artist.

Rationale:
Time is saved when a month after inactivity on a particular asset, some changes are requested. The ‘noodles’ of file names and locations becomes difficult to un-jumble. Minor/Subtle changes made to an asset may get lost and need to be re-done. For example, say the only change between two versions on an asset in the ‘soup’ is that certain normals were flipped to look correct in an engine. When the artist opens the unchanged file a month later, it might not catch his/her attention and those changes are lost, requiring more changes when its spotted again later.
I’m all for using a revision control software, but it seems like a bit of an uphill battle; It takes time to train a new hire/fresher – even many programmers seem to have a hard time getting used to the concept (I blame their choice of ‘bcoz’ instead of ‘because’, even if they type at 40+ wpm (citation/check if that is good/its just a number that popped into my head), when they’re fresh out of school). So expecting an artist to have time to/be willing to/be mentally built to (they’ve trained themselves to be right brained, as programmers were busy doing the opposite) learn version control may be a little more difficult. It seems like fixing certain details that they don’t think about often might make it easier for everyone. (And slowly get them used to the concept of version control, starting with such file names – embrace. extend. extinguish. 😉 ).
Additionally, all versions are available immediately in the same location – as compared to having to pull out specific versions from the version control software/system – since changes are mostly tracked per file name. Also considering most version control systems will probably store the whole file since it is (most art assets) binary (Yes, thank you, ‘future commenter’, mercurial could be set to do binary diffs and will keep older verisons compressed saving some space.) – you might as well have them all available in place.
Another minor benefit of naming this way is that the assets can be quickly sorted by age. (Yes, I’m aware of a sort by date, but try sending a file across to someone using some of those LAN/intranet messengers floating around.). I name photographs as "YYYY[MM]DD [Location/Event] (Number) [Optional caption/detail keywords].{extension}" for the same reason.

I hope to get some constructive comments to make this post better/more useful for everyone. What tools/conventions do you use?

PS: For those of you who can’t comment because you aren’t signed in or don’t have an account, please email me your comments/ideas/suggestions at my [firstname]@[lastname].net ([subdomain]@[domain] from the link mentioned above.) I’ll include them/make changes accordingly.

I’ve also signed up at the swimming pool again and now manage to swim 20 laps (1 kilometer) every time I go.
Swim Lap Log:
earlier (last year) 1×7-8 tops
Signed up again this year
1lap x 14times or so..
2×10.. (also jumped from 10m diving platform) (20 laps in all achieved)
Took a week off to get over a cold. Watched the YouTube videos Tejas was looking at, I just needed to get my head out of ‘competition mode’. I guess when I learnt to swim back in school I was training to race and my style/technique before watching the videos was expending too much energy.
6,6,6,4 (laps with open turns, commas for 1-2min pauses)
6,6,7.5+0.5FAST (I knew I was going to stop after the last lap so I gave it all I had left "FAST").
15May2009: 8, 8, 3.1+0.9FAST
16May2009: 10, 9.2+0.8FAST
17May2009: 12, 7.2+0.8FAST
18May2009: Pool closed on Mondays
19May2009 12, 7.1+0.9FAST
20May2009: 14, 5.1+0.9FAST
21May2009: 19.1+0.9FAST (20laps without a break target achieved! was projected for Saturday evening.) Timed lap a while later: 33 sec for 50m.

Posted in Organizations | 1 Comment