If you could be interested in a new language, I have some ideas.
So far these are just the basics, but that's because it's still a work in progress.
If you already know how to program, I'll do some tutorials on algorithms later.
Please send me suggestions, doubts or criticisms!

What is Software Development and Programming?

Software development can be divided into two stages: design and coding.
What I mean by those two stages: software design is what you do when you're thinking about your software. Coding is the act of translating that into an actual program. So design worries about software engineering, algorithms, AI, and mostly everything, while coding worries about programming languages, and mainly only that.

You can learn design while knowing very little coding, but the most common learning path is to study coding first. For that, you just have to keep one thing in mind: learning a programming language is very similar to learning a natural one. That's because Turing demonstrated (with his "Turing completeness" notion) that minds are equivalent to computers. That is, if you understand how you would solve a problem, with all details, then you can translate your thoughts into any computer language.

So get into the mindset of learning a new language: in order to become fluent, you need not only a lot of practice, but also contact with other speakers. This is specially important with programming languages, since computers won't ever teach you vocabulary. For example, they won't ever say that, even though "walking in a speedy manner" works, "running" is a better way of saying it. So try finding a friend that can help you, even if just on the internet, and also try to read many other's codes. Anyway, computers do understand everything you tell them, and they will point out any minor syntactic error you make. That annoys many people, but you'll see that you'll learn syntax in no time because of it. Don't forget, learning languages is not easy, so don't give up for silly reasons.

On Programs, Procedures, Functions

Let's start with some basics: the basic block of a language is a procedure, also called a method, also called a function. That is, going by the dictionary on those three words, a series of actions, with a purpose, that acts on an input to produce an output. Let's see an example:

bool isLoginValid(string username, string password) {
  if (passwordDatabase[username] == password)
    return true;
  else
    return false;
}

The purpose of this function is to validate a login. It does that by comparing the given password with the one associated with the username on the program's password database, then outputting true of false if they match or not. For your information, "string x" means that x is a sequence of characters, and "bool" is the type for true and false (don't worry about memorizing that yet, we'll be learning everything in more depth later). This isn't a very secure system, since storing passwords in a database allows for reading them directly, so anyone that figures out a way of doing so would have access to anyone's account. So let's see another example:

bool isLoginValid(string username, string password) {
  string salt;
  salt = saltDatabase[username];
  if (hash(password, salt) == hashDatabase[username])
    return true;
  else
    return false;
}

There are a lot of details in this new version, and you don't need to try understanding any of it. Just note that you have a series of steps, generally one per line, and that when executed they say if a login is valid or not, even if you don't understand exactly what each of them does yet. Also, there's a function "hash" there, executed taking "password" and "salt" as inputs, so note that you can use functions inside the definition of functions.

Moving on, let's talk about the structure of a code file. You can see that the definition of function also applies to complete programs, and indeed a program is a function. However, as we noted, we can use other, "auxiliary" functions to help defining it. Also in our examples we never told the computer where were our databases, but we'd need to in a real program.

And that's mainly it: a program is composed of a "main" function (which we are often forced to call "main"), auxiliary function definitions, and other things such as databases. But code for a software can be quite big, so for organization most languages allow you to split it in multiple files. So here's an example of a complete program in C:

#include 
void main() {
  printf("Hello World!");
}

The first line says that we're also using the STanDard Input and Output file, which contains standard code for input and output such as writing to the screen. The second line is saying that our main function takes no input and produces no direct output. Then the third is the instruction that the main function performs: writing "Hello World!" on the console (we call that "printing" it). Go on and run that: you can try IdeOne, just change the language on the bottom left from "Java" to "C".

On Types and Objects

Let's go back to functions: they get some input and produce some output. But what really are these values? Well, they're data of some kind. We already saw they can be strings, booleans, databases. Technically, they are just a bunch of bits, but we, programmers, see them for what they represent instead. And the definition of what exactly they should represent is done by the programmers themselves.

These "types" (string, boolean, ...) are there to help us, so we don't have to think on a "lower level" of abstraction, that is, sowe don't have to think about what each bit should be doing. Let's say we had a library software: it would deal a lot with book descriptions, that contain their title, author, and many characteristics. Instead of creating functions that take all these parameters, we can create a type that holds all of them together:

struct Book {
  string title;
  string author;
  // ...
};

We call user-defined types "structures".

There's one step beyond a structure (which is a set of properties), which is a "class": a structure and it's native operations. To see why they're so important to software development today, let's think on a bigger software: a 3D game. We could have a "Model3D" class, that represents the entities displayed in the game, like the ground and yourself. To display them on screen, we could have a "Scene" class that would manage all the objects you want to render. Now, you don't care about Z-Buffers, Tesselation, Anti-Aliasing, or any of the options you can choose from to make your game, you just want it to work. That is, you want a Scene class that would have these elements:

class Scene {
  // ...
  void addObject(Model3D object);
  void render();
};

That is, you don't care about what a Scene manages, you just want it to work. So you care about which functions it supports, not which variables it contains. You could have it like:

struct Scene {
  // ...
};
Scene addObjectToScene(Model3D object, Scene scene);
void renderScene(Scene scene);

But that's just a messier way of doing it.

So the idea of object-oriented programming is to define what classes you need to do what want, specifically which functions you need for them. Then you repeat: define which classes you need to implement those functions, and so on. There is also a concern with "quality": you'll want to make classes that make sense (on the translation-from-english view), that don't depend on too many others (so they're well organised), and so on (I'm not the best OO programmer around btw).

On Memory, Variables, Arrays and Pointers

When thinking just with input and output of functions, there's no easy way to store data for later use. To do that, we use "variables": a variable is piece of computer memory that holds some value. For example, we had

salt = saltDatabase[username];

Which meant that the variable "salt" was receiving ("=") the value of "saltDatabase[username]". We ended up using this variable right after that, which is good practice, but not necessary. (The good practice is to make your variables have a "short livespan", so you use one heavily in a block of the code, then never again.)

You may be wondering, what does "saltDatabase[username]" mean? Well, that's a long story, but it starts with arrays, which are sets of many variables. In our case, our array is the saltDatabase, which contains a variable for each user (and each variable contains a salt). The "array[index]" notation means, as you may have guessed, to access the index's variable in the array.
Technically "arrays" usually have variables for each natural number (0, 1, 2, ...), and for strings (like username) you need some other thing, like "maps", but you get the picture.

Finally, there is the notion that the entirety of the computer memory is like a giant array (since it's storing many variables). To explore that, some languages allow you to get the memory's index of a variable: it's called a pointer. And instead of "memory[pointer]", the usual notation for this special thing is just an asterisk, "*pointer".

They are specially useful for recursive classes: say you want a structure Person which can say who are the parents of people. If you do it like this:

struct Person {
  Person mother;
  Person father;
}

The computer will think that each Person stores two other Person variables inside of them. This leads to an error, since it would make the structure infinitely big.
The way to do this with pointers is to notice that each person doesn't contain it's parents, but rather knows who they are. So by changing the parents to pointers, it now works

struct Person {
  Person* mother;
  Person* father;
}

The difference, now, is that if there isn't information about someone's parent, that can be denoted by having the corresponding pointer be anything (typically some special value, often called "null").

On choosing a first language

If you want a "general-purpose" language, you'll probably want to learn a popular one first, since then you get more resources from the internet. Thus there are 4 contenders: Java, C/C++, Python and Javascript. There is an endless debate on which one is better and why the others suck, but most of it comes down to unintuitive quirks that only native speakers know how to avoid, so I won't go into them. Specially since you can do the same in all of them, it only takes more effort for some things.

Java is a very verbose language, so it's great for large projects. It's also used for Android development.
C/C++ are good languages to learn about computer internals. They're also good for handling large amounts of data.
Python is a very terse language, so it's great for simple projects. It's also used to integrate other code.
Javascript is the language for web development. Which means your users don't have to download anything. It's also terse.


And that's it for basic notions for programming. I'll be doing tutorials on how to translate all this to specific languages on request.