What Is Meant by 'First Class Object'

What are first-class objects?

In short, it means there are no restrictions on the object's use. It's the same as
any other object.

A first class object is an entity that can be dynamically created, destroyed, passed to a function, returned as a value, and have all the rights as other variables in the programming language have.

Depending on the language, this can
imply:

being expressible as an anonymous literal value

being storable in variables

being storable in data structures

having an intrinsic identity (independent of any given name)

being comparable for equality with other entities

being passable as a parameter to a procedure/function

being returnable as the result of a procedure/function

being constructible at runtime

being printable

being readable

being transmissible among distributed processes

being storable outside running processes

Source.

In C++ functions themselves are not first class objects, however:

You can override the '()' operator making it possible to have an object function, which is first class.
Function pointers are first class.
boost bind, lambda and function do offer first class functions

In C++, classes are not first class objects but instances of those classes are. In Python both the classes and the objects are first class objects. (See this answer for more details about classes as objects).

Here is an example of Javascript first class functions:

// f: function that takes a number and returns a number
// deltaX: small positive number
// returns a function that is an approximate derivative of f
function makeDerivative( f, deltaX )
{
    var deriv = function(x)
    { 
       return ( f(x + deltaX) - f(x) )/ deltaX;
    }
    return deriv;
}
var cos = makeDerivative( Math.sin, 0.000001);
// cos(0)     ~> 1
// cos(pi/2)  ~> 0

Source.

Entities that are not first class objects are referred to as second-class objects. Functions in C++ are second class because they can't be dynamically created.

Regarding the edit:

EDIT. When one says "everything is
an object" (like in Python), does he
indeed mean that "everything is
first-class"?

The term object can be used loosely and doesn't imply being first class. And it would probably make more sense to call the whole concept 'first class entities'. But in Python they do aim to make everything first class. I believe the intent of the person who made your statement meant first class.

What is meant by 'first class object'?

To quote Wikipedia:

In computer science, a programming
language is said to support
first-class functions (or function
literal) if it treats functions as
first-class objects. Specifically,
this means that the language supports
constructing new functions during the
execution of a program, storing them
in data structures, passing them as
arguments to other functions, and
returning them as the values of other
functions.

This page also illustrates it beautifully:

Really, just like any other variable

A function is an instance of the Object type
A function can have properties and has a link back to its constructor method
You can store the function in a variable
You can pass the function as a parameter to another function
You can return the function from a function

also read TrayMan's comment, interesting...

What is first-class object mean in Snowflake?

"First class object" simply means that your object exists independently.

According to the answer here (What are "first class" objects?), a first class object is an object that can be "dynamically created, destroyed, [...]"

What are first-class objects in Java and C#?

The problem is that "first class object" is not a well defined concept.

The normal usage is that someone says that an "object" is a class of thing that should have all of the properties X, Y and Z. But there are other things that don't have all of those properties, but they are sort of object-ish. So we'll call the former "first class" objects and the rest not "first class" ... and may be not objects.

The problem is that there are any number of views on the properties that a thing needs to have to make it a "first class" object. And no prospect of the people with opposing views coming to a consensus. (For example, a Javascript language expert might argue strenuously that an object is only first class if it is template-based.)

The only really solid insights about "first-classness" will be those that you can glean from the respective language specifications for Java and C#. And they only really apply within the scope of the respective languages / type systems ... and not across multiple languages.

So "first class Java object" or "first class C# object" might be meaningful, but "first class object" taken out of context is not.

Well that's my opinion ...

What is a First Class type?

Usually it means instances of T can be

returned from functions
passed into functions
constructed at runtime

Eg functions in C are not first class types as they cannot be constructed at runtime, but they are in JavaScript.

In some specialised circumstances, for example theorem proving, it means that types themselves are first class objects. More modern literature uses 'reified types' instead to denote this to avoid such ambiguity.

What is the difference between first-class entities and second-class entities in perl?

As MeNoMore correctly said, a first-class-entity is a data type of the language you can freely assign to variables etc. In Perl, these include:

Scalars
Arrays
Hashes
Coderefs (e.g. anonymous subroutines)
IO
Typeglobs (The symbol table is a hash of globs)
Formats

Those can reside in the symbol table. The scalar slot can be occupied by various other types in addition:

Signed integers
Unsigned integers
Floating point numbers
Strings
References
Regexes

Some of these entities have built-in constructors into tha language: Number and String literals for scalars, list notation for arrays and hashes, [] and {} for anonymous array- and hashrefs, the sub keyword for code, the open function for IO objects, the format builtin for formats, the reference operator for references, and the qr{} operator for regexes.

There are language constructs in Perl that are not first-class entities and cannot be assigned to scalars or other first-class entities. For example, packages. This code doesn't work:

my $anonymous_package = package { ... };  # XXX

Shell commands have their own builtins, but are no data objects, so this won't work:

# don't execute `yes`, but store a handle to it in reference
my $shell_command = \qx{yes};

Instead, this statement should not terminate (and probably blow your memory).

Lists in Perl are language constructs, but no data types:

my $listref = \($x, $y, $z); # assigns reference to $z instead

The builtin types in Perl can have coercion rules:

Numbers and Strings coerce back and forth.
A single scalar in list context is a list of arity 1.
An array in scalar context evaluates to the length of the array
An (even valued) array can be assigned to a hash
A Hash can be assigned to an array so that assigning this array to another hash would recreate the same hash
A Hash in scalar context evaluates to (a) a false value if it is empty or (b) to a string indicating the number of filled and allocated buckets e.g. 1/8 or (c) to the number of keys in numerical context.
Regexes in string context evaluate to a pattern string that behaves like the one they were specified with: qr(ab?c) eq "(?-xism:ab?c)", depending on the version of perl.

Objects can be overloaded to show similar coercion rules through overloading.

In the case of regex-refs, a scalar containing such a reference can be used interchangeably with a regex literal, e.g. in the pattern

$string =~ /ab?c/

the regex could be replaced with $regex if $regex is like above:

my $regex = qr/ab?c/;
$string =~ $regex ### no dereferencing syntax!
# $string =~ /$regex/ will work too, but may invoke string overloading first (?)

For example, coderefs require more biolerplate code:

sub foo {...}
foo();

versus

my $foo = sub {...};
$foo->();  # two possibilities
&$foo();

Explain the term 'First-class functions' in relation to Javascript

We often hear that JavaScript functions are first-class functions, meaning both functions and objects are treated by the language as the same thing. In practical terms, a function can be stored as a variable, inside an array or an object, as well as it can be passed as an argument or be returned by another function. That makes functions “first-class citizens” in JavaScript.

These are the examples:

var myfunc2 = function(a)
{
 return a + 1;
};

var myfunc2 = function myfunc4(a)
{
 return a + 1;
};

Refer the following links

http://odiseo.net/javascript/first-class-functions-in-javascript-how-comes-functions-are-treated-as-objects-in-js

http://www.developerfusion.com/article/84433/first-class-functions/