coding-guidelines | Coding guidelines for projects at Leapfrog | Static Site Generator library

I'm reading the C specification, which states in 6.5 Expressions

The effective type of an object for an access to its stored value is the declared type of the object, if any. If a value is stored into an object having no declared type through an lvalue having a type that is not a character type, then the type of the lvalue becomes the effective type of the object for that access and for subsequent accesses that do not modify the stored value.

Can anyone explain what this means? I've got a vague feeling that it has to do with pointers and malloc(), but that's as far as I can get without help from a lawyer...

Update based on answer: Can I safely do this?

The TypeScript Coding Guidelines state

Use undefined. Do not use null

Having just read another article on ECMAScript, which advocates for null over undefined, I was wondering whether Microsoft’s or the TypeScript team’s rationale is known for this decision?

http://c0x.coding-guidelines.com/6.7.2.1.html:

1401 If the struct-declaration-list contains no named members, the behavior is undefined.

Does this mean that the following is illegal?

Stateless React components should be named in PascalCase, so React can distinguish between native elements and components. Typescripts naming convention dictates that we should use lowerCamelCase or UPPER_CASE for the name of const variables.

How can I satisfy both (React and tslint)?

If you look here and here it says you should not prefix your member field variables.

But if you look at the source code for .net core all field variables are prefixed with _?

When you scaffold a Controller in Visual Studio 2017 it also generates fields with the _ prefix?

So something must be wrong here?

The C11 spec on enums¹, states that the enumerator constants must have type int (1440-1441):

1440 The expression that defines the value of an enumeration constant shall be an integer constant expression that has a value representable as an int.

1441 The identifiers in an enumerator list are declared as constants that have type int and may appear wherever such are permitted.107)

However, it indicates that the backing type of the enum can be either a signed int, and unsigned int, or a char, so long as it fits the range of constants in the enum (1447-1448):

1447 Each enumerated type shall be compatible with char, a signed integer type, or an unsigned integer type.

1448 The choice of type is implementation-defined,108) but shall be capable of representing the values of all the members of the enumeration.

This seems to indicate that only the compiler can know the width of an enum type, which is fine until you consider an array of enum types as part of a dynamically linked library.

Say you had a function:

Question: What is the best practice for naming private properties in Typescript and should one as a rule create a “get and set” for that property?

Reading the following link gave me pause to what I thought would be a good practice for coding Typescript: https://github.com/Microsoft/TypeScript/wiki/Coding-guidelines

I understand his qualifier to his coding guideline that this is not a prescriptive guideline, however, his convention on naming private properties brings up questions in my mind on proper encapsulation and use of private properties in Typescript. The convention I have been following is to name the private properties with the prefix of underscore and then create a get and set that I use to assign or get the value from that property. Back in Anders’ Delphi days that convention is what made it a property and not just another variable. That property gave it characteristic that allowed for tooling.

Example:

As I read about naming convection in asp.net Here

Use Camel Case for variables and method parameters

So i should use camel case naming for variables and method parameters but I don't know why visual studio warn me about these names:

Recently I've switched from pure node.js to Typescript. In Microsoft's coding guidelines for Typescript they want their contributors to use forEach instead of loops. Literally everywhere I read that iterating with forEach is roughly 95% slower than iterating over a for loop.

Since a foreach loop looks much cleaner in most situations I wonder if they simply don't care about the performance (decision made in favour of readable code) or if there is another reason why I could forEach in Typescript?

Microsofts Coding Guidelines for Typescript: https://github.com/Microsoft/TypeScript/wiki/Coding-guidelines