I'm primarily a developer, but, I do a bit of design off and on, and I keep trying to make myself better.

After some experience and talking on other designers on Forrst, I think I've learned a few things about design that might be helpful to other people that are primarily technical, but, have to crack open Photoshop once in a while.

## Don't be crazy

If you're like me, design isn't what you're building your app around, you just need it to look and feel good and intuitive.

So, you've probably looked at amazing web design with absolutely off the wall colors that some how just look right. You could try that, or, taking a much easier route, design with simplicity in mind.

People either really like nutty design or they really hate it. Instead, go with simplicity, which people usually like.

Don't try to use atypical color swatches, instead, use a one or two color based theme.

## Typography matters

Read up a little bit about typography. Its actually kind of interesting, and very important.

Again, don't be crazy applies here to. Don't use fonts that are incredibly abnormal unless you know that you're going to somehow pull them off well.

## Use vectors!

Vector images are awesome! You can scale them up or down without loss of quality!

So, invest some time in learning a vector editor. Even though its a little bit less intuitive than a bitmap editor, it'll pay off in the long run.

## Pictograms

Pictograms are fonts that are shaped as icons.

So, instead of icons being bitmaps, they're vectors, so, especially on mobile devices, zooming in won't result in quality loss.

Also, changing colors, size, shadow, etc. no longer need an image editor; you can do it with CSS!

I like the entypo pictograms.

## Reward the user

Every time the user does some kind of action, "reward" them with some kind of feedback.

When you hover over a button, it should do something, same for when you click it.

Basically, not only does this let the user know that what they did actually meant something, it also makes your application more fun to use.

So, yeah, that's a couple of things I've gathered from various experiences, but, I would love to learn more. Provide design tips in the comments below :)

India is a place of extreme changes; changes in society (going from a strict, family-based social structure to something more westernized), in the economy and in the people.

India is a growing economy, by all means. But, there are some sectors which have been lagging recently, and one of them is online shopping.

Why wouldn't online shopping be working?

People definitely have the money to spend (of course, not all of them, but, a growing number), no doubt about it. There's corruption and some pretty crazy tax policies, but, most of these things can be maneuvered, especially by startups.

The number reason, in my opinion, is the complete lack of house addresses. This may be difficult to comprehend for someone living in the United States, UK, Germany etc. but, the situation is very real; there's no such thing as a numbered address for (most) of India.

There are names of roads, but, these don't actually mean anything, because, often times, they're decided by the people living near the roads instead of them being official names. And, there's roads and alleys that have no name at all (with large apartment complexes by them)!

So, if you wanted to refer to an address, its usually done via referencing a nearby road and maybe another landmark.

This is an absolute nightmare for online business. Its insanity. Since there's no real method of determining addresses, its extremely difficult for the postal office to be of any use at all (and, on top of that, packages get stolen all the time), so, companies have to come up with their own delivery service (for example, Flipkart), which is an enormous task, and still doesn't work out well all the time.

It takes tremendous infrastructure to have a proper address system; the first huge task is to name all the roads and number all the buildings that, so far, have been getting along by referencing landmarks. But, without that, its going to be very difficult to host an "ship-to-home" business in India.

Why would you want to learn assembly? I don't know, but, if you would like to (and, really quickly), this is probably good reading.

So, processors run something call opcode, which basically means binary. Of course, not all processors are the same, but, to preserve some measure of sanity, there's something called x86 which is a specification which gives some guidelines about opcode. If you want to, you can find a whole listing of opcodes for x86 right here.

Of course, no one really wants to write pure opcode, so, there's assembly. Every assembly instruction (usually) corresponds to one "instruction".

To take these instructions and turn them into opcode, there's an assembler, which is very much like a compiler, except its called an assembler (there's more than that to it, but, that's the general idea).

There's two main assemblers for *nix; GNU Assembler and The Netwide Assembler.

The GNU Assembler was initially built as an output format for GCC, and isn't really suitable for writing code in, so, we'll use NASM.

Installing nasm on Ubuntu/Debian is a breeze:

sudo apt-get install nasm


Now, we're ready to start writing some assembly.

section .text
global _start

_start:
jmp _start


Save this into a file called first.s or something, and fire up nasm:

nasm -f elf first.s


Or, on 64 bit systems:

nasm -f elf64 first.s


Which will give you an ELF file called first.o, which you can then link:

ld first.o -o first


Run the code:

./first


And, you should have something that just runs continuously.

What have we just done? Analyzing the code, we first tell NASM about the _start "function" (which is just a name for a group of assembly procedures), then, inside that procedure, we're using the jmp call to go back to the beginning of _start. Recursion!

Something a little more interesting:

section .text
global _start

_start:
mov eax,4
mov ebx, eax


This uses registers which are little pieces of memory attached onto the processor that are extremely volatile). We use the registers EAX and EBX. First, we use the mov command.

mov is possibly the worst name you could come up for what it does; it doesn't actually move anything, it copies it. So, the number 4 is copied into the register EAX, which is then copied onto EBX.

Assembly gets much more interesting as you learn more "commands"; you can find a full listing here (courtesy of Intel).

Since assembly is so simple, its very easy to get started, but, its rather difficult to do anything useful; if you think strings are difficult in C, you have no idea what you've gotten yourself into.

Enjoy!

With Rails 3 mandating the use of Gemfiles for gems (which, in my opinion, is an excellent idea), you should probably understand how to use Gemfiles to their maximum extent.

## Tip #1: Groups

group :development do
gem "sqlite3"
end

group :production do
gem "pg"
end


Lets you specify groups for certain gems. In the example above, if I'm not under production, it will not require the "pg" (PostgreSQL) gem.

bundle install --without production


That will run install the bundle, excluding gems under the production group.

This especially useful for Heroku deployments, because many a times, you don't have access to PostgreSQL on your development computer (although, you really should) and Heroku won't accept Gemfiles with "sqlite3" in them without some extra haggling.

Most of us use some Linux distro or Mac OS X with Rails - Windows Rails users seem to be a very small community.

Every now and then, on the #rubyonrails IRC channel, some confused guy comes in, and has absolutely no idea why some of his code won't work (from some tutorial, usually) and ruby keeps giving him odd error messages.

Usually, the first question anyone asks is "what operating system are you on?"; invariably, its some kind of Linux distro, and the next question asked is "how'd you install ruby/rails?"

Usually, the answer is "apt-get" or "aptitude" for ruby, and then gem for rails (or, in worse cases, "apt-get" for everything).

Let's get this down right now; THIS IS THE WRONG WAY OF DOING THINGS.

Nearly all the repositories have old versions of ruby (and even older versions of rails), and they have all kinds of configuration chinks. You cannot work like that. Instead, you have to use RVM, which is quite possibly the best thing since sliced bread.

RVM manages your rubies for you so that you don't end up with version differences killing your productivity.

Installation is done via the awesome new "pipe into sh" route:

curl -L get.rvm.io | bash -s stable


source ~/.rvm/scripts/'rvm'


If you want to use version 1.9.3, just go ahead and:

rvm use 1.9.3


Want to test with 1.9.2? Sure:

rvm use 1.9.2


Commands like gem also work right out of the box:

gem install rails


That's it. You're done. You no longer have to deal with the frustration that arises from using distro-built ruby packages.

DISCLAIMER:

These instructions may or may not work by the time you're reading this; it was published on 4/28/12, so, consider that before you reference this tutorial when asking for help.