on 09-Dec-2023 (Sat)

The most popular text editors for Go are VSCode (free), GoLand (paid), and Vim (free).

Database URLs

Database connection strings are specified via URLs. The URL format is driver dependent but generally has the form: dbdriver://username:password@host:port/dbname?param1=true&param2=false

Any reserved URL characters in the DB connection URL need to be escaped. Note, the % character also needs to be escaped

Explicitly, the following characters need to be escaped: !, #, $, %, &, ', (, ), *, +, ,, /, :, ;, =, ?, @, [, ]

It's easiest to always run the URL parts of your DB connection URL (e.g. username, password, etc) through an URL encoder. See the example Python snippets below:

$ python3 -c ' import urllib.parse; print(urllib.parse.quote(input("String to encode: "), "")) ' String to encode: FAKEpassword!#$%&' () * +,/:;= ? @[]
FAKEpassword%21%23%24%25%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D
$ python2 -c ' import urllib; print urllib.quote(raw_input("String to encode: "), "") ' String to encode: FAKEpassword!#$%&' () * +,/:;= ? @[]
FAKEpassword%21%23%24%25%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D
$

React DOM Hooks - Hooks for web applications which run in the browser DOM environment.

React DOM Components - React supports all of the browser built-in HTML and SVG components.

React DOM APIs - The react-dom package contains methods supported only in web applications.

React Components - Documents built-in components that you can use in your JSX.

React Directives - Provide instructions to bundlers compatible with React Server Components.

React Hooks - Use different React features from your components.

Mathe- matical conceptions as expressions of pure thought have also seemed to provide the open gateway to arealm of essence that is independent of existence, physical or mental aself-sub- sisting realm of ideal and eternal objects which are the objects of the highest that is, the most assured knowledge.

The theory that conceptions are definitions of conse- quences of operations

ince the former doc- trine about the proper way to form conceptions, to the effect that agreement with antecedent properties determines the value or validity of ideas, was the doctrine common to all philosophic schools except the pragmatic one of Peirce the logical and philosophical transformation thus affected may be said to be more far-reaching than even the extraordinary de- velopment in the content of natural science which resulted. It is not too much to say that whatever should be future develop- ments in discoveries about light, or that even if the details of the Einstein theory of relativity should be some time dis- credited, agenuine revolution, and one which will not go back- ward, has been effected in the theory of the origin, nature and test of scientific ideas.

unless we can have ends-in-view without experiencing them in concrete fact, no regulation of action is possible. The question might be put thus: How can we act without acting, without doing some- thing? If, by acontradiction in terms, it had been possible for men to think of this question before they had found how to answer it, it would have been given up as insoluble. How can man make an anticipatory projection of the outcome of an activity in such away as to direct the performance of an act which shall secure or avert that outcome? The solution must have been hit upon accidentally as aby-product, and then employed intentionally. It is natural to suppose that it came as aproduct of social life by way of communication ;say, of cries that having once directed activities usefully without in- tent were afterwards used expressly for that purpose. But whatever the origin, asolution was found when symbols came into existence. By means of symbols, whether gestures, words or more elaborate constructions, we act without acting. That is, we perform experiments by means of symbols which have results which are themselves only symbolized, and which do not therefore commit us to actual or existential consequences. If aman starts afire or insults arival, effects follow jthe die is cast. But if he rehearses the act in symbols in privacy, he can anticipate and appreciate its result. Then he can act or not act overtly on the basis of what is anticipated and is not there in fact. The invention or discovery of symbols is doubtless by far the single greatest event in the history of man. Without them, no intellectual advance is possible jwith them, there is no limit set to intellectual development except inherent stupidity.

MDN: Resources for Developers, by Developers (entire site)

The Modern JavaScript Tutorial (entire site)

As you deal with most people of good nature, setting boundaries will improve not only your life, but theirs as well.

But there are some people who are dangerous, or who love their power or control so much that a clear verbal boundary is seen as a challenge to be defeated.

If someone has given you reason to fear them, be careful about how you set a boundary with them. Before deciding on what boundaries to set, first assess your own risk. If you, your children, your home, or your possessions would be en- dangered by setting verbal boundaries, create a physical boundary through distance, or by relocating. If you live with or work for a person who could threaten you if you set a boundary, talk to a third person for counsel as to the best course for you to follow. As necessary, use lots of help from other good, trustworthy people to ensure your safety and security.

Installation - Learn React (whole page)

The common feature of PostgreSQL client applications is that they can be run on any host, independent of where the database server resides

When specified on the command line, user and database names have their case preserved — the pres- ence of spaces or special characters might require quoting.

Table names and other identifiers do not have their case preserved, except where documented, and might require quoting

clusterdb (section)

createdb (section)

createuser (section)

dropdb (section)

dropuser (section)

ecpg (section)

pg_amcheck (section)

pg_basebackup (section)

pgbench (section)

PostgreSQL Client Applications: pg_config (section)

PostgreSQL Client Applications: pg_dump (section)

PostgreSQL Client Applications: pg_dumpall (section)

PostgreSQL Client Applications: pg_isready (section)

pg_receivewal

PostgreSQL Client Applications: pg_recvlogical (section)

PostgreSQL Client Applications: pg_restore (section)

PostgreSQL Client Applications: pg_verifybackup (section)

PostgreSQL Client Applications: psql (section)

PostgreSQL Client Applications: reindexdb (section)

PostgreSQL Client Applications: vacuumdb (section)

The three kinds of SQL functionality: how to create the structures to hold data, how to populate the database, and how to query it

Chapter 4. SQL Syntax (whole chapter)

Chapter 5. Data Definition (whole chapter)

Chapter 6. Data Manipulation (whole chapter)

Chapter 7. Queries (whole chapter)

Chapter 8. Data Types (whole chapter)

Chapter 9. Functions and Operators (whole chapter)

Chapter 10. Type Conversion (whole chapter)

Chapter 11. Indexes (whole chapter)

Chapter 12. Full Text Search (whole chapter)

Chapter 13. Concurrency Control (whole chapter)

Chapter 14. Performance Tips (whole chapter)

Chapter 15. Parallel Query (whole chapter)

Golang-migrate: Getting started (whole page)

Generics were introduced in Go 1.18.

Go is a general-purpose language designed with systems programming in mind. It is strongly typed and garbage-collected and has explicit support for concurrent programming. Programs are constructed from packages, whose properties allow efficient management of dependencies.

The syntax is compact and simple to parse, allowing for easy analysis by automatic tools such as integrated development environments.

syntax is specified using a variant of Extended Backus-Naur Form (EBNF)

Notation

The syntax is specified using a variant of Extended Backus-Naur Form (EBNF) :

Syntax = { Production } .
Production = production_name "=" [ Expression ] "." .
Expression = Term { "|" Term } .
Term = Factor { Factor } .
Factor = production_name | token [ "…" token ] | Group | Option | Repetition .
Group = "(" Expression ")" .
Option = "[" Expression "]" .
Repetition = "{" Expression "}" .

Productions are expressions constructed from terms and the following operators, in increasing precedence:

| alternation
() grouping
[] option (0 or 1 times)
{} repetition (0 to n times)

Lowercase production names are used to identify lexical (terminal) tokens. Non-terminals are in CamelCase. Lexical tokens are enclosed in double quotes "" or back quotes ``.

The form a … b represents the set of characters from a through b as alternatives. The horizontal ellipsis … is also used elsewhere in the spec to informally denote various enumerations or code snippets that are not further specified. The character … (as opposed to the three characters ...) is not a token of the Go language.

Source code representation

Source code is Unicode text encoded in UTF-8. The text is not canonicalized, so a single accented code point is distinct from the same character constructed from combining an accent and a letter; those are treated as two code points. For simplicity, this document will use the unqualified term character to refer to a Unicode code point in the source text.

Each code point is distinct; for instance, uppercase and lowercase letters are different characters.

Implementation restriction: For compatibility with other tools, a compiler may disallow the NUL character (U+0000) in the source text.

Implementation restriction: For compatibility with other tools, a compiler may ignore a UTF-8-encoded byte order mark (U+FEFF) if it is the first Unicode code point in the source text. A byte order mark may be disallowed anywhere else in the source.

Characters

The following terms are used to denote specific Unicode character categories:

newline = /* the Unicode code point U+000A */ .
unicode_char = /* an arbitrary Unicode code point except newline */ .
unicode_letter = /* a Unicode code point categorized as "Letter" */ .
unicode_digit = /* a Unicode code point categorized as "Number, decimal digit" */ .

In The Unicode Standard 8.0, Section 4.5 "General Category" defines a set of character categories. Go treats all characters in any of the Letter categories Lu, Ll, Lt, Lm, or Lo as Unicode letters, and those in the Number category Nd as Unicode digits.

Letters and digits

The underscore character _ (U+005F) is considered a lowercase letter.

letter = unicode_letter | "_" .
decimal_digit = "0" … "9" .
binary_digit = "0" | "1" .
octal_digit = "0" … "7" .
hex_digit = "0" … "9" | "A" … "F" | "a" … "f" .

Comments

Comments serve as program documentation. There are two forms:

1. Line comments start with the character sequence // and stop at the end of the line.
2. General comments start with the character sequence /* and stop with the first subsequent character sequence */.

A comment cannot start inside a rune or string literal, or inside a comment. A general comment containing no newlines acts like a space. Any other comment acts like a newline.

Tokens

Tokens form the vocabulary of the Go language. There are four classes: identifiers, keywords, operators and punctuation, and literals. White space, formed from spaces (U+0020), horizontal tabs (U+0009), carriage returns (U+000D), and newlines (U+000A), is ignored except as it separates tokens that would otherwise combine into a single token. Also, a newline or end of file may trigger the insertion of a semicolon. While breaking the input into tokens, the next token is the longest sequence of characters that form a valid token.

Semicolons

The formal syntax uses semicolons ";" as terminators in a number of productions. Go programs may omit most of these semicolons using the following two rules:

1. When the input is broken into tokens, a semicolon is automatically inserted into the token stream immediately after a line's final token if that token is
   • an identifier
   • an integer, floating-point, imaginary, rune, or string literal
   • one of the keywords break, continue, fallthrough, or return
   • one of the operators and punctuation ++, --, ), ], or }
2. To allow complex statements to occupy a single line, a semicolon may be omitted before a closing ")" or "}".

To reflect idiomatic use, code examples in this document elide semicolons using these rules.

Identifiers

Identifiers name program entities such as variables and types. An identifier is a sequence of one or more letters and digits. The first character in an identifier must be a letter.

identifier = letter { letter | unicode_digit } .

a
_x9
ThisVariableIsExported
αβ

Some identifiers are predeclared.

Keywords

The following keywords are reserved and may not be used as identifiers.

break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var

To support this, you’ll write a function that declares type parameters in addition to its ordinary function parameters. These type parameters make the function generic, enabling it to work with arguments of different types. You’ll call the function with type arguments and ordinary function arguments.

Each type parameter has a type constraint that acts as a kind of meta-type for the type parameter. Each type constraint specifies the permissible type arguments that calling code can use for the respective type parameter.

While a type parameter’s constraint typically represents a set of types, at compile time the type parameter stands for a single type – the type provided as a type argument by the calling code. If the type argument’s type isn’t allowed by the type parameter’s constraint, the code won’t compile.

Keep in mind that a type parameter must support all the operations the generic code is performing on it. For example, if your function’s code were to try to perform string operations (such as indexing) on a type parameter whose constraint included numeric types, the code wouldn’t compile.

Intended specifically for cases like these, the comparable constraint is predeclared in Go. It allows any type whose values may be used as an operand of the comparison operators == and !=. Go requires that map keys be comparable. So declaring K as comparable is necessary so you can use K as the key in the map variable.

Specify for the V type parameter a constraint that is a union of two types: int64 and float64. Using | specifies a union of the two types, meaning that this constraint allows either type. Either type will be permitted by the compiler as an argument in the calling code.

Ledger-CLI: Command-Line Accounting (whole page)

The SQL Linter for Humans (whole page)

Using Euler's formula, we can rewrite the Fourier series in terms of complex exponentials as:

\(\displaystyle f(x)=\sum\limits^{+\infty}_{n=-\infty}c_{n}e^{j\frac{n\pi x}{L}}\)

Where \(\displaystyle c_{n}=\frac{1}{2L}\int^{L}_{-L}f(x)e^{j\frac{n\pi x}{L}}dx\).