What Do ≪ and ≫ Stand For

What do and stand for?

< stands for the less-than sign: <
> stands for the greater-than sign: >
≤ stands for the less-than or equals sign: ≤
≥ stands for the greater-than or equals sign: ≥

What does .NET stand for? Is it an acronym?

About 10 years ago, I was part of the large team in Redmond working on the set of projects which became ".net". This was during the time the decisions were being made about what to name this work. I can tell you from first-hand experience that ".net" is not an acroynm.

Instead, the James Kovacs blog post that Jim W posted is accurate: there was a long list of names that the team cycled through and rejected before finally settling on ".net". The final name was chosen because it:

mirrored the domain suffix of (at the time) every ISP, so was intended to remind users that "web-enabling your software" was the core scenario being targetted by this work
was more approachable to business types and CIOs than geekier names like "Universal Runtime" or "COM+ 2.0"
had practical benefits like: being short, easy to spell, globalized well, could leverage already-owned domain names for every Microsoft product, etc.
actually passed legal/trademark review (surprisingly difficult!)

So it was intended to mean something, but more so by connotation rather than directly abbreviating or describing something. In other words, the name was only partly marketing nonsense! ;-)

More trivia

I don't remember the exact positioning (it's been 10 years!), but I believe that the name ".net" was supposed cover three basic things:

".net Framework" - a new framework for writing web-enabled apps
".net web services" - a way of accessing Microsoft (and others') software over the web programmatically using open standards and protocols (anyone remember "Hailstorm"?)
".net enterprise servers" - a set of products which made bulding web-enabled applications easier.

In practice, only the first meaning stuck with users. The others morphed into other names (e.g. "Windows Server System") or were genericized by the public (e.g. "web services", SOA, etc.). Anyway, that's why you don't see Microsoft products named "<product name here>.NET Server" any more-- Microsoft wisely decided to limit the ".net" name to the things that developers actually thought of as ".net"!

BTW, in addition to being short and easy to spell and say, ".net" as a name also helped with the web services strategy which Microsoft was persuing at the time, which revolved around (and still does) offering software which was also available in the cloud. The idea was that we'd have, for example, Office.com for a hosted UI version, and Office.net for the APIs. The name also was convenient since Microsoft already owned the .net domain-name variants for every microsoft product.

There's a funny T-Shirt (I think Don Box had them made?) which lists all the considered names (e.g. URT, COM+, etc.) with thick red lines drawn through all the names except the last one (".net"). The list goes from the top of the shirt right down the back, like a long list of cancelled Mötley Crüe tour dates, but nerdier!

PHP PDO - What do $dbh and $sth stand for?

$dbh = "Database Handle"

$sth = "Statement Handle"

I prefer the longer forms, as they are more descriptive. It is often helpful to future maintainers if you are explicit, even when using common acronyms and abbreviations.

In the past, when hard drive capacity, memory and bandwidth were scarcer, the abbreviations may have made sense. Today there is (arguably) greater value in producing readable, maintainable code.

What does as stand for in the foreach loop in PHP?

It doesn't stand for anything.

It simply means that the variable through which you will access the current item in the array will be accessed in the loop via that variable name.

In the X-UA-Compatible tag, what do the X and UA actually stand for?

The "X" is a prefix conventionally used by vendors to denote non-standard HTTP headers. It has since been deprecated.

"UA" stands for user agent. For most users, the user agent is the web browser, so it makes sense in context.

I'm surprised none of the documentation for X-UA-Compatible actually says what "UA" stands for. Perhaps the documentation simply assumes the author already knows. It doesn't help that web searches for "UA" turn up entirely different expansions for the same abbreviation altogether.

What does T stand for in Result T, E in Rust?

It's a naming convention for a generic type.

Generic types in Rust are typically named with a single capital letter. The non_camel_case_types warning enforces that the name starts with a capital letter, but it's just a warning and nothing prevents you to name it otherwise.

T is the most commonly seen letter, you'll often see this where the item really doesn't care what the type represents, but there are some other letters commonly used in particular cases as follow:

If the type is an error type: E. Example:
```
fn err(self) -> Option<E>
```

If the type is a predicate: P. Example:

fn filter<P>(self, predicate: P) -> Filter<Self, P>
where
    P: FnMut(&Self::Item) -> bool,

If the type is a function type: F, G, etc. Example:

std::iter::Iterator::for_each<F>(self, f: F)
where
    F: FnMut(Self::Item)

If the type is the return type of a generic function: R. Example:

fn with<F, R>(&'static self, f: F) -> R
where
    F: FnOnce(&T) -> R,

If the type is a key type in some map: K. Example:
```
fn keys(&self) -> Keys<K, V>
```

If the type is a value type in some map: V. Example:

fn insert(&mut self, key: K, value: V) -> Option<V>

If the type is an implementation of Iterator: I. Example:
```
impl<I> Clone for Fuse<I> where
    I: Clone, 
```

If the type is an implementation of Read: R. Example:

fn chain<R: Read>(self, next: R) -> Chain<Self, R>
where
    Self: Sized,

If the type is an implementation of Write: W. Example:
```
struct BufWriter<W: Write> { /* fields omitted */ }
```
If the type is an implementation of ToSocketAddrs: A. Example:
```
fn connect<A: ToSocketAddrs>(addr: A) -> Result<TcpStream>
```
If the type is a path (ie. implements AsRef<Path>): P. Example:
```
pub fn open<P: AsRef<Path>>(path: P) -> Result<File>
```
Everything else: T, U, etc., usually in alphabetical order.

What does a stand for in a data type declaration?

Short answer: it's a type variable.

At the computation level, the way we define functions is to use variables to refer to their arguments. Like this:

f x = x + 3

Here x is a variable, and its value will be chosen when the function is called. Haskell has a similar (but not identical...) mechanism in its type sublanguage. For example, you can write things like:

type F x = (x, Int, x)
type Endo a = a -> a -> a

Here again x is a variable in the first one (and a in the second), and its value will be chosen at use sites. One can also use this mechanism when defining new types. (The previous two examples just give new names to existing types, but the following does more.) One of the most basic nontrivial examples of this is the Maybe family of types:

data Maybe a = Nothing | Just a

The things on the right of the = are computation-level, so you can mostly ignore them for now, but on the left we are declaring a new family of types Maybe which accepts other types as an argument. For example, Maybe Int, Maybe (Bool, String), Maybe (Endo Char), and even passing in expressions that have variables like Maybe (x, Int, x) are all possible.

Syntactically, type constructors (things which are defined as part of the program text and that we expect the compiler to look up the definition for) start with an upper case letter and type variables (things which will be instantiated later and so don't currently have a concrete definition) start with lower case letters.

So, in the type signature you showed:

alphabet :: DFA a -> Alphabet a

I suspect there are actually two constructs new to you, not just one: first, the type variable a that you asked about, and second, the concept of type application, where we apply at the type level one "function-like" type to another. (Outside of this answer, people say "parameterized" instead of "function-like".)

...and, believe it or not, there is even a type system for types that makes sure you don't write things like these:

Int a -- Int is not parameterized, so shouldn't be applied to arguments
Int Char -- ditto
Maybe -> String -- Maybe is parameterized, so should be applied to
                -- arguments, but isn't

Do SO and RO postfixes have a standard meaning, as in EnvelopeSO ?

These postfixes commonly says what is the role of the object.

For objects intended to transfer data, it is common to add the TO suffix, so we have ServerTO, AccountTO, UserTO, CompanyTO, CustomerTO, SaleItemTO, etc. TO is an acronym for Transfer Object. A variation of this is the DTO suffix which means Data Transfer Object.

For objects intended to control the database access we have the DAO suffix for Data Access Object, so we have a UserDAO, CustomerDAO, SalesDAO, etc.

The UI or GUI suffix is frequently used for user interface objects. These are acronyms for Graphical User Interface or simply User Interface.

Other common uses of this are VO for Value Object and DO for Domain Object.

I once saw BE suffix for Business Entity, SL for Service Locator and PB for Page Bean.

Although this is a common practice in lot of places, I weakly recommend against it. A descriptive name is normally much better than a cryptic acronym suffix (or prefix), but if you can't find one that is not too long, use the acronym. Instead of CustomerTO or CustomerDTO you could name it just Customer. Instead of SalesDAO you could name it SalesPersistence or SalesDatabase. This eliminates the problem of trying to understand what the suffix should mean when you get a VendorDSA or a PersonTF.

In partcular the DTO, TO, DAO, UI, GUI, VO and DO suffix are very common and widespread. Other suffixes are normally obscure.

For your case in special, I have no idea of what is SO and RO, and I can't do anything better than just guess, which again shows that a descriptive name is better than an acronym as a suffix. My best bet is that SO is Service Object and RO is Resource Object.

What does the 'c' in cURL stand for?

From their website:

cURL is the name of the project. The name is a play on 'Client for
URLs', originally with URL spelled in uppercase to make it obvious it
deals with URLs. The fact it can also be pronounced 'see URL' also
helped, it works as an abbreviation for "Client URL Request Library"
or why not the recursive version: "Curl URL Request Library".

http://curl.haxx.se/docs/faq.html#What_is_cURL

What Do ≪ and ≫ Stand For