I guess you mean keywords. Although I would argue you should also include stuff like assignment operators in the language. Arguably, many parts of standard libraries belong to the languages as well bc they actually shape everyday code people write. That’s a complicated question. But only in terms of keywords it varies greatly between languages. Lisps provably have like 5 of them and languages like Ruby or even C have around 20 More on reddit.com

void means the method doesn't return a value. You can have a method declared void kickRocks() and if it is void, you can just call it. It doesn't provide a value, it just kicks the rocks. kickRocks(); If you have a method that does return a value, then it needs to return that value. int breakRocks() may return how many rocks are broken. You can use that value. count = count + breakRocks(); Or you can ignore the return value. breakRocks(); But either way, it needs to fulfill its return value. Static has more than one place it might get used, but for fields or methods, it means that thing belongs to the class itself and not the instances of the class. Your Rocks class allows rocks of three sizes, so when you make a Rock myRock = new Rock(RockSize.SMALL), you get an instance of Rock that probably has a field that stores its size. Each instance of a Rock gets its own size. However, if the Rock class also needs to keep a list of all rocks and let you know how many rocks have been made, that list isn't a separate list for each instance of a rock, its for the class itself, so that list is static, which means there is only one list, not a seperate rock list for each rock. String[] args is an array of strings so if the program is run from the command line, it can access all the arguments passed in that command line. If you aren't running your stuff from a command line, you can probably just ignore the args. It needs to be there, but you don't have to use them. More on reddit.com

It's mostly a matter of opinion how many keywords is an "appropriate" amount. Of the ones you mentioned, they all have good reasons for existing IMO. Data classes are a centrepiece or Kotlin and pretty universally liked. Enums are enums, that exists in Java too. lateinit exists because Kotlin is designed to be null-safe, which typically prevents certain Java-like constructions. lateinit allows you to declare a variable that is both non-null (for the purposes of internal logic) and not immediately initialized. I personally try to avoid it, but it allows you to do things Java don't. Type aliases are just sugar, definitely. I often find that too many typealises make code harder to read, but with restricted use (e.g. private typealises) can make code clearer. More generally, don't feel you have to learn them all at once. There's a bunch I have still never used (like tailrec) because I just don't write those kinds of algorithms. edit: typo More on reddit.com

protected internal sealed override unsafe fixed delegate* unmanaged, ref readonly int> Test() You can also nest delegate* unmanaged forever. More on reddit.com