Korvettenleutnant

Korvettenleutnant (Hun: Tengerészzászlós / en: translation Corvette lieutenant) was an officer rank in the Austro-Hungarian Navy. It was equivalent to Leutnant of the Austro-Hungarian Army, as well to Leutnant zur See of the Imperial German Navy. Pertaining to the modern day's NATO rank code it could be comparable to OF-1b.

Korvettenleutnant
in Austria-Hungary
Rank insigniaAustro-Hungarian Navy
Introductionca. 1916
Rank groupCommissioned officers
Army / Air ForceLeutnant
NavyKorvettenleutnant
NATO
equivalent
OF-1b

The right to be promoted to Korvettenleutnant was limited to so-called naval reserve officers only. However, professional officers skipped that rank and were regular promote from Seefähnrich to Fregattenleutnant (also OF-1a), the next higher rank (comparable to Oberleutnant zur See). A Korvettenleutnant did wear the same rank insignia as a Seefähnrich.

The rank name was selected in line to the division of war ships to specific ship categories early of the 19th century, e.g. corvette (de: Korvette), frigate (de: Fregatte), and to ship of the line (de: Linienschiff). In the Austro-Hungarian Navy the appropriate rank designations were derived as follows.

According to that systematic the rank designations to subaltern – or junior officers were derived as follows:

This sequence of ranks can be found in the today´s Croatian naval forces.

junior rank
Seekadett

(k.u.k. Kriegsmarine rank)
Seefähnrich
senior rank
Fregattenleutnant
Korvettenleutnant

Other countries

The rank designation Korvettenleutnent was used continuously in naval forces of former Yugoslavia and as junior officer (OF-1b) rank in modern today’s naval forces of Croatia, Slovenia and Serbia.

Rank insignia Korvettenleutnant
CountryCroatiaSerbiaSlovenia

Croatian Navy

River Flotilla

Slovenian Navy
Shoulder
sleev
Native designation Poručnik korvete Поручник корвете Poročnik korvete
rank OF-1b OF-1a OF-1b
gollark: ```pythonimport thesaurusimport randomimport concurrent.futures as futureswords_to_synonyms = {}synonyms_to_words = {}def add_to_key(d, k, v): d[k] = d.get(k, set()).union(set(v))def add_synonyms(syns, word): for syn in syns: add_to_key(synonyms_to_words, syn, [word]) add_to_key(words_to_synonyms, word, syns)def concat(list_of_lists): return sum(list_of_lists, [])def fetch_word(word): results = concat(thesaurus.Word(word).synonyms("all")) return resultsdef add_words(words): with futures.ThreadPoolExecutor(max_workers=50) as executor: word_futures = {executor.submit(fetch_word, word): word for word in words} for future in futures.as_completed(word_futures): word = word_futures[future] try: data = future.result() except Exception as exc: print(f"Error fetching {word}: {exc}") else: add_synonyms(data, word)def getattr_hook(obj, key): results = list(synonyms_to_words.get(key, set()).union(words_to_synonyms.get(key, set()))) if len(results) > 0: return obj.__getattribute__(random.choice(results)) else: raise AttributeError(f"Attribute {key} not found.")def wrap(obj): add_words(dir(obj)) obj.__getattr__ = lambda key: getattr_hook(obj, key)wrap(__builtins__)__builtins__.engrave("Hi!")```
gollark: Ah yes. Global Interpreter Lock. Right. This may be hard.
gollark: On the plus side, you should be able to use `zilch` in place of `None` now.
gollark: The python thesaurus-izer may need some parallelization to be effective.
gollark: We could use this; it seems a cool idea.

See also

References

    This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.