I think there are many many many options. A few of which are: If your project is only focused on supervising rhino horn you could name your project rhino-horn-supervisor and not package anything just have flat top level files main.go, hornoutput.go, or w/e If supervising rhino horn is one component of a larger application there … Read more
Here a short answer, formed as another question: Torch, SMORCH ??? PyTorch developed from Torch7. A precursor to the original Torch was a library called SVM-Torch, which was developed around 2001. The SVM stands for Support Vector Machines. SVM-Torch is a decomposition algorithm similar to SVM-Light, but adapted to regression problems, according to this paper. … Read more
There are precedents for using a noun in the Framework, e.g. Enumerable.Average<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal?> selector) Enumerable.Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) Enumerable.GroupBy<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) ConcurrentDictionary<TKey,TValue>.GetOrAdd(TKey key, Func<TKey, TValue> valueFactory); The noun is often an appropriate verb with an agentive suffix. In your example I would … Read more
That is correct, and allowed by the Standard. But a better approach is to use some naming-convention for member variables. For example, you could use m_ prefix for all member variables, then anyone could infer what m_state is. It increases the readability of the code, and avoids common mistakes. Also, if m_state is the member, … Read more
I would use the plural: Tokens. This implies that the static class is serving as a collection of items of some sort (whose runtime types are not that of the class). On the other hand, an enumeration’s fields are instances of the enumeration type. For example, TypeCode.String is a TypeCode. It would be weird to … Read more
Use: module FooLib end module FooLib::Plugins end class FooLib::Plugins::Plugin; end #the base for plugins class FooLib::Plugins::Bar < FooLib::Plugins::Plugin; end class FooLib::Plugins::Bar2 < FooLib::Plugins::Plugin; end or in a different words: module FooLib module Plugins class Plugin; end #the base for plugins class Bar < Plugin; end class Bar2 < Plugin; end end end Also arrange the … Read more
I usually ask myself: What is this method doing? The answer dictates what the method should be called. It is completely independent of the programmer, of course. Note: If you can’t succinctly describe what the method is doing, it’s probably doing too much and should be split up. Choosing your method’s verb: Performing calculation(s): calculate … Read more
Because int is a primitive type, not a class, thus it is not directly comparable to String. The corresponding class type is Integer, spelled according to the class naming conventions. Similar pairs of primitive and class types are byte vs Byte short vs Short long vs Long float vs Float double vs Double boolean vs … Read more
In Java: Foo, AbstractFoo and Foo – although AbstractFoo could just be Foo. Evidence: java.util.List (interface) java.util.AbstractList (abstract class) java.util.Formatter.BigDecimalLayoutForm (enum) For the interface part, see the Naming Conventions section of the Java Coding Conventions document. It doesn’t talk about enums and abstract classes though.
Something about naming convention for properties in Kotlin, I know it’s not for methods. But it’s related: From book Kotlin in Action (by Dmitry Jemerov & Svetlana Isakova) – section 2.2.1 Properties: In Kotlin, properties are a first-class language feature, which entirely replaces fields and accessor methods. Listing 2.5. Declaring a mutable property in a … Read more