An alphabetically sorted list of all keywords with references to their documentation:

PLMK internals:

\ALC
\GC
\HEAP
\MOT
\MOT-C
\MOT-W
\MOT-N
\META-CODE
\META-COMPILER
\META-FILE
\META-LIBRARY
\META-PARSER
\META-WRAPPER
\NULL-Value
\PLMK
\RPC
\RUNTIME
\TPL

programming languages:

\C_lang
\CC_lang
\CS_lang
\JV_lang
\GO_lang
\PHP_lang
\PL_lang
\PY_lang
\RB_lang
\TCL_lang
\ATL_lang
\VB_lang

environment variables:

\NHI1_BUILD
\NHI1_EXT
\NHI1_GEN
\NHI1_HOME
\NHI1_abs_top_builddir
\NHI1_abs_top_extdir
\NHI1_abs_top_gendir
\NHI1_abs_top_srcdir
\NHI1_setup
\NHI1_target

commercial:

\microsoft
\MONO
\DOTNET
\open-sorce
\opensuse
\oracle
\UNIX
\LINUX

technology:

\application-server
\garbage-collection
\OOP
\pthread
\runtime-local-storage
\server-instance
\thread
\thread-local-storage
\thread-pool

The following subsections provide a list of all keywords that are recognized by NHI1.

--- Structural indicators ---

All-Language-Compiler (ALC)

The alc is the abbreviation for "all languages compiler" where languages stands for programming languages as well as any form of structured data.

languages: C C++ C# VB.NET Java Python Ruby Perl PHP Tcl or GO
configuration: doxygen, texi, vim, shell etc

The alc-compiler is the central tool in the Programming-Language-Micro-Kernel (PLMK) and is used to take over error-prone and monotonous tasks that otherwise take a lot of time. The guiding principle in the alc-compiler is simply explained:

‍a code is only correct and valid if the alc-compiler has written it

That sounds a bit aloof at first, but it\'s the truth. because if you take programming seriously, you have to admit to yourself that people are far too imperfect to write really error-free code.

See also: alc compiler

Garbage-Collection (GC)

In computer science, garbage collection (GC) is a form of automatic memory management. The garbage collector attempts to reclaim memory that was allocated by the program, but is no longer referenced;

‍such memory is called garbage.

https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)

See also: RUBY is a callenging story

Global-Memory (HEAP)

Heap memory is a region of computer memory used for dynamic allocation of objects at runtime.
It is a dynamic area of memory where blocks of memory are allocated and deallocated dynamically as needed,
in contrast to the stack memory, where memory is allocated and deallocated in a last-in-first-out (LIFO) manner.
Objects stored in the heap have a longer lifetime than objects stored in the stack, as heap-allocated objects persist
until they are explicitly deallocated or until the program ends.

https://computersciencewiki.org/index.php/Heap_memory

See also: RUBY is a callenging story, Garbage-Collection (GC)

Managed-Object-Technology (MOT)

MkObjectC - managed-object details

Managed-Object-Technology (MOT) is a class system in C that is designed to integrate automatically into other software, which of course also includes other programming languages.

See also: Managed-Object

See also: Programming-Language-Micro-Kernel (PLMK) MOT-Class MOT-Wrapper Managed-Object-Technology-Null (MOT-N)

Managed-Object-Technology-Class (MOT-C)

The core of the MOT is the class and the class is a C struct with a link between:

instance-type: The instance-type represents the attributes of the instance (example: MyClassS → MkBufferS → MkObjectS)

class-type: The class-type represents the attributes of the class (example: MyClassST → MkTypeDefSTT → MkTypeSTT)

The type is a struct and a struc which follows the MOT-format is called a MOT-class.

The Programming-Language-Micro-Kernel (PLMK) is defined by the set of all classes that follow with MOT-format.

The type MyClassS is always related to the class MyClassC.

By definition a type and a class are using the same root-name like MkBufferS versa MkBufferC.
The term class is used in the Target-Programming-Language (TPL) with class support,
- The term class is also used together with instance to distinguish the class-type from the instance-type.
The term type is used in the Target-Programming-Language (TPL) without class support (such as C)
- The term type is also used to name the struct of the class-type and the instance-type.
The term instance is used for the requested and initialized memory of type instance-type.
- The term instance is also referred to as class-instance.

Example: type template for MyClassS with base type MkBufferS: // instance-type to represent the data from the class MyClassC …

struct MyClassS {

// [super]

// BEGIN-MyClassS-super - created by 'c_Class.tcl -example' - DO NOT change

union {

struct MkObjectS obj; // instance-base MkObjectS

struct MkBufferS buf; // instance-base MkBufferS

} super;

// END-MyClassS-super - created by 'c_Class.tcl -example' - DO NOT change

// [super]

// BEGIN-MyClassS-native

// END-MyClassS-native

};

A MOT-class always starts with a union called super.

The first item in the union is always the MkObjectS instance-base.
All items in the super-union share the memory.
The super-union is used for the cast-operation (cast the MOT-class into the base-class) also.

A MOT-class is not just limited to the C programming language, but the technology allows the SAME class to be used as a MOT-class in almost all programming languages: "write once → use everything" .

To complete the picture, the All-Language-Compiler (ALC) creates all code required to organizes the interaction of the different components and offers the end user a coherent API.

See also: Managed-Object-Technology (MOT)

Managed-Object-Technology-Wrapper (MOT-W)

The MOT-Wrapper is used to connect the MOT-Class (lang=C) to a Target-Programming-Language (TPL) (lang=C++,C#,VB.NET,Java,Python,Ruby,Perl,PHP,Tcl or GO).
Two connection methods are conceivable:

[level-0] Connection as reference. TPL-instance and MOT-instance are one object
struct Wrapper {

// init...

struct MyClassC hdl;

}

level-0 is experimental and only possible with a language like C++.
- The biggest problem here is that when the TPL-instance is HARD deleted (e.g. C++ delete ptr) from the outside, the MOT instance is also deleted, which is difficult to control in a complex scenario (e.g. in the event processing of an application server) and ultimately creates "disorder" in the Programming-Language-Micro-Kernel (PLMK).
- level-0 is not used.
[level-1] Connection as pointer. TPL-instance and MOT-instance are two objects
struct Wrapper {

// init...

struct MyClassC *hdl;

}

level-1 was implemented and confirmed as a solution through extensive testing.
- level-1 uses two separate instances, one instance in the Target-Programming-Language (TPL) and one instance in the Programming-Language-Micro-Kernel (PLMK).
- both instances have a lifetime and can also be separated again.
- the MOT monitors the connection of the instances and guarantees plausibility.

See also: Managed-Object-Technology (MOT)

Managed-Object-Technology-Null (MOT-N)

The NULL-Intance in Managed-Object-Technology (MOT) is the counterpart to the NULL value pointer in C …

NULL defined via MOT

In general, the Managed-Object-Technology (MOT) is connected to the Target-Programming-Language (TPL) via the MOT-Wrapper and the MOT-Wrapper connects two instances,

the TPL-instance and the MOT-instance.

Both instances can become NULL separately from each other so that the TPL and MOT are separated.

There is therefore not just one NULL but two.

To map a MOT-NULL you need an intact TPL-instance whose MOT-Wrapper-hdl is NULL.

read more at : MOT-Null → Managed-Object

See also: theKernel NULL-Value Programming-Language-Micro-Kernel (PLMK)

meta-api-source-code-format (META-CODE)

The meta-code is an importand part of the alc compiler because this is the glue between the input file (e.g. api-definition} and the output files (e.g. the code)

The best definition of meta-code is a wrapper around a given API that follows the Programming-Language-Micro-Kernel (PLMK) programming style.

See also: alc compiler

meta-code-compiler (META-COMPILER)

The meta-compiler is the tool to generate the meta-file from the meta-header and the meta-parser.

See also: META-COMPILER

meta-code-library-definition-file (META-FILE)

The meta-file is created by the meta-code-compiler (META-COMPILER) using the meta-code-parser-extension (META-PARSER), meta-code-external-header-file (META-HEADER) and optional the meta-code-header-wrapper-file (META-WRAPPER) as input.

The meta-file is:

the text-based database with TCL syntax in which the attributes that define a library are stored
generated by the alc-frontend and used by the alc-backend and the alc-middleware.
a singular definition of information, every information is only stored at one place.
ordered in terms of structure, which always delivers the same logic-output for the same logic-input.
intended to be stored in the code-repository in order to ultimately secure the API and to centrally verify a change.
human-readable and human-changeable in order to quickly create test-data or to add your own meta-code extensions.

See also: alc compiler, META-FILE

meta-code-external-header-file (META-HEADER)

The external-header-file is the source of the API information and the goal of the Programming-Language-Micro-Kernel (PLMK) in conjunction with the All-Language-Compiler (ALC) is to use this file to provide language binding for a variety of languages.

See also: META-HEADER

meta-code-library (META-LIBRARY)

The meta-library is either created directly by the programmer or is the meta-code-wrapper around a native-library created by the meta-code-compiler (META-COMPILER).

The meta-library uses only the meta-data-types and the meta-code-structure.

The native-meta-library is the link between the meta-library and the Target-Programming-Language (TPL), with the connection being established via the Managed-Object-Technology (MOT).

See also: META-LIBRARY

meta-code-parser-extension (META-PARSER)

The meta-parser is a C compliant extension to the C programming language to associate an attribute with an C-object-definition (e.g. function, struct, enum, argument etc.)

See also: META-PARSER

meta-code-header-wrapper-file (META-WRAPPER)

If an external-header-file cannot be changed, it is a good idea to call this file via a wrapper and then add the changes using __parser__global__(...) .

See also: META-WRAPPER

NULL-Value

The NULL-Value in Managed-Object-Technology (MOT) is the counterpart to the NULL value in C …

This problem looks simpler than it is because NULL is not defined in every language.

TCL e.g. does not understand the NULL as a data type and an approximation with "" is only correct to the extent that the target API also understands the "" as a NULL-Value.

Unfortunately, this is not always the case and therefore:

wherever a NULL is explicitly required the MK_NULL is used in C .
wherever a NULL as string (MK_STRN) is required then the string "MK_NULL" is used in C.

To support the NULL the following items are defined:

the NULL-value called MK_NULL
the NULL-string called MK_NULL_STR
the NULL-string-length called MK_NULL_STR_LEN
the NULL-check called MK_NULL_STR_CHECK

Note: The Programming-Language-Micro-Kernel (PLMK) translate the string "MK_NULL" into the MK_NULL pointer wherever a pointer is expected as a return value.

See also: theKernel Managed-Object-Technology-Null (MOT-N) Programming-Language-Micro-Kernel (PLMK)

Programming-Language-Micro-Kernel (PLMK)

The PLMK is the summary of all tools, libraries and technologies used to build and use the microkernel.
The PLMK includes theKernel and theCompiler as well as the build environment.

                                                                                                          This structure is clearly defined by separating concerns into three distinct programming layers: 
                                                                                                          -# the library-layer (\ref \selfref), 
                                                                                                          -# the tool-layer (<a href="../../theCompiler/main/index.htm">theCompiler</a> and build tools), 
                                                                                                          -# the target-layer (the API seen by the \ref TPL programmer).

                                                                                                          <dl>
                                                                                                           <dt> library-layer
                                                                                                              <dd>  The \e library-layer implement the <a href="../../theKernel/main/index.htm">theKernel</a> library and is responsible
                                                                                                                    for the \e quality-target of the entire project.
                                                                                                                    - implementation of the \e managed-object technology
                                                                                                                      - providing basic classes for: \ref doc_mk_c_MkBufferC "buffer", \ref doc_mk_c_MkBufferListC "list", \ref doc_mk_c_MkBufferStreamC "stream", \ref doc_mk_c_MkLogFileC "logging", \ref doc_mk_c_MkRuntimeC "runtime" and \ref doc_mk_c_MkErrorC "error"
                                                                                                                    - establishing and managing the \e library-items
                                                                                                                      - providing the \e startup and \e cleanup API
                                                                                                                      - providing the \e logging, \e debugging and \e error API
                                                                                                                      - providing the \e memory and garbage-collection API
                                                                                                                    - written in plain \ref C_lang
                                                                                                            <dt>  tool-layer
                                                                                                              <dd>  The \e tool-layer creates the tools and is responsible for the integration of all components into the 
                                                                                                                    <a href="../../NHI1/main/index.htm">NHI1</a> framework.
                                                                                                                    \li implementation of the \e project and build technology.
                                                                                                                    \li implementation of the \e token-stream-compiler technology
                                                                                                                    \li generate the source-code for the \e target-layer.
                                                                                                                    \li written in plain \ref C_lang, \ref TCL_lang and the \ref TPL
                                                                                                            <dt>  target-layer
                                                                                                              <dd>  The \e target-layer is the \e API used by the \e target-language-programmer.
                                                                                                                    \li written in plain \ref TPL
                                                                                                          </dl>

See also: theKernel theCompiler

Remote-Procedure-Call (RPC)

Note: t.b.d.

See also: ...

Thread-Local-Global-Namespace (RUNTIME)

A RUNTIME is a thread-local structure that maps the global namespace of a meta-code-library (META-LIBRARY) and is initialized when a new thread is started.

The kernel-runtime MkRuntimeS is always present and maps the meta-kernel.

See also: theKernel theLink

Target-Programming-Language (TPL)

TPL describes the set of all programming languages supported by the Programming-Language-Micro-Kernel (PLMK).

This set includes (C,C++,C#,VB.NET,Java,Python,Ruby,Perl,PHP,Tcl or GO) but is not constant and can be expanded at any time.
Adding a new language takes about 4 weeks, with about 1/3 spent on implementation and 2/3 on testing.
The All-Language-Compiler (ALC) must be expanded for each new programming language, which ultimately improves the All-Language-Compiler (ALC) and the generated code benefits all supported languages.

See also: theKernel theCompiler

C

What is C?

C is a general-purpose, procedural, high-level programming language used in the development of computer software and applications, system programming, games, and more.

C language was developed by Dennis M. Ritchie at the Bell Telephone Laboratories in 1972.
It is a powerful and flexible language which was first developed for the programming of the UNIX operating System.
C is one of the most widely used programming languages.

The C programming language is known for its simplicity and efficiency. It is the best choice to start with programming as it gives you a foundational understanding of programming.

See also: https://www.geeksforgeeks.org/c-programming-language/

C++

C++ is the most used and most popular programming language developed by Bjarne Stroustrup. C++ is a high-level and object-oriented programming language. This language allows developers to write clean and efficient code for large applications and software development, game development, and operating system programming. It is an expansion of the C programming language to include Object Oriented Programming(OOPs) and is used to develop programs for computers. This C++ Tutorial will cover all the basic to advanced topics of C++ like C++ basics, C++ functions, C++ classes, OOPs and STL concepts.

What is C++?

C++ is a most popular cross-platform programming language which is used to create high-performance applications and software like OS, Games, E-commerce software, etc. It was developed by Bjarne Stroustrup, as an extension of C language. C++ give a high level of control over system resources and memory.

Why Learn C++?

C++ is one of the most used and popular programming languages.
C++ is used in making operating systems, embedded systems, and Graphical User Interfaces.
It is an object-oriented programming language that implements all the OOPs concepts such as Abstraction, Encapsulation, and Inheritance, which gives a clear structure to programs and allows code to be reused, lowering development costs and providing security.
It is portable and can be used to create applications that can be adapted to multiple platforms.
C++ is easy to learn so that you can choose it as your first programming language. It makes programming easy for programmers to switch to C++ because its syntax is similar to C, Java, and C#.

See also: https://www.geeksforgeeks.org/c-plus-plus/ https://en.cppreference.com/w/cpp/language/

C#

C# is the most common programming language used to develop multiple applications in the.NET framework, and it was introduced by Microsoft in 2000. It was designed to be a simple, object-oriented programming language that can be used to create a wide range of applications and software.

It features a clear syntax, an object-oriented nature, and platform independence, which makes it simpler for developers to organise their code and makes it more legible and manageable.

It is platform-independent in the sense that it may be used to create programmes that operate on different platforms such as Windows, macOS, Linux, and mobile devices. This makes C# a versatile language.

See also: https://www.geeksforgeeks.org/csharp-programming-language/ https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/

Java

Developed by Sun Microsystems in 1995, Java is a highly popular, object-oriented programming language. This platform independent programming language is utilized for Android development, web development, artificial intelligence, cloud applications, and much more.

See also: https://www.geeksforgeeks.org/java/ https://www.oracle.com/java

GO

Golang is a procedural and statically typed programming language having the syntax similar to C programming language. Sometimes it is termed as Go Programming Language. It provides a rich standard library, garbage collection, and dynamic-typing capability. It was developed in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson at Google but launched in 2009 as an open-source programming language and mainly used in Google’s production systems. Golang is one of the most trending programming languages among developers.

See also: https://www.geeksforgeeks.org/golang/ https://go.dev/

PHP

The term PHP is an acronym for – Hypertext Preprocessor. PHP is a server-side scripting language designed specifically for web development. It is open-source which means it is free to download and use. It is very simple to learn and use. The file extension of PHP is “.php”.

PHP was introduced by Rasmus Lerdorf in the first version and participated in the later versions. It is an interpreted language and it does not require a compiler.

Characteristics of PHP

PHP code is executed in the server.
It can be integrated with many databases such as Oracle, Microsoft SQL Server, MySQL, PostgreSQL, Sybase, and Informix.
It is powerful to hold a content management system like WordPress and can be used to control user access.
It supports main protocols like HTTP Basic, HTTP Digest, IMAP, FTP, and others.
Websites like www.facebook.com and www.yahoo.com are also built on PHP.
One of the main reasons behind this is that PHP can be easily embedded in HTML files and HTML codes can also be written in a PHP file.
The thing that differentiates PHP from the client-side language like HTML is, that PHP codes are executed on the server whereas HTML codes are directly rendered on the browser. PHP codes are first executed on the server and then the result is returned to the browser.
The only information that the client or browser knows is the result returned after executing the PHP script on the server and not the actual PHP codes present in the PHP file. Also, PHP files can support other client-side scripting languages like CSS and JavaScript.

Origin and History

PHP was created by Rasmus Lerdorf in 1994 and initially stood for “Personal Home Page.” Over the years, it evolved into “PHP: Hypertext Preprocessor.”
PHP is open-source and has a large community of developers contributing to its development.

Purpose of using PHP

PHP is primarily used for server-side web development. It enables the creation of dynamic web pages by embedding PHP code within HTML.
PHP can perform various tasks, including handling form data, generating dynamic page content, managing databases, and interacting with servers.

See also: https://www.geeksforgeeks.org/ruby-programming-language/ https://wiki.php.net/

Perl

Perl is a general purpose, high level interpreted and dynamic programming language. Perl supports both the procedural and Object-Oriented programming. Perl is a lot similar to C syntactically and is easy for the users who have knowledge of C, C++. Since Perl is a lot similar to other widely used languages syntactically, it is easier to code and learn in Perl. Programs can be written in Perl in any of the widely used text editors like Notepad++, gedit, etc.

See also: https://www.geeksforgeeks.org/perl-programming-language/ https://perldoc.perl.org/

Python

This Programming Language Python Tutorial is very well suited for beginners and also for experienced programmers. This specially designed free Python tutorial will help you learn Python programming most efficiently, with all topics from basics to advanced (like Web-scraping, Django, Learning, etc.) with examples.

What is Python?: Python is a high-level, general-purpose, and very popular programming language. Python programming language (latest Python 3) is being used in web development, and Machine Learning applications, along with all cutting-edge technology in Software Industry. Python language is being used by almost all tech-giant companies like – Google, Amazon, Facebook, Instagram, Dropbox, Uber… etc.

See also: https://www.geeksforgeeks.org/python-programming-language-tutorial/ https://www.python.org/

Ruby

Ruby is a dynamic, reflective, object-oriented, general-purpose programming language. Ruby is a pure Object-Oriented language developed by Yukihiro Matsumoto. Everything in Ruby is an object except the blocks but there are replacements too for it i.e procs and lambda. The objective of Ruby’s development was to make it act as a sensible buffer between human programmers and the underlying computing machinery.

See also: RUBY is a callenging story, https://www.geeksforgeeks.org/ruby-programming-language/, https://ruby-doc.org/

TCL

What is Tcl?: Tcl is a simple-to-learn yet very powerful programming language. Its syntax is described in just a dozen rules, but it has all the features needed to rapidly create useful programs in almost any field of application - on a wide variety of international platforms. See more about Tcl at What is Tcl

What is Tk?: Tk is a graphical toolkit for Tcl. It allows you to develop graphical applications that run on Windows, Linux, MacOS X and many other platforms. And not just from Tcl - Tk can be used from many languages including C, Ruby, Perl, Python and Lua. See more about Tk at What is Tk

See also: https://www.tcl-lang.org/

ATL

What is ATL?: ATL is a fork of TCL version tcl8.5 and uses the myoo extension for namespace-based Object-Oriented-Programming (OOP). ATL is ~20% faster than latest tcl8.6 because it lacks the complex NRE technology, and it does not require the tcloo built-in from tcl8.6 onwards. In this sense, myoo replaces tcloo.

VB.NET

VB.NET stands for Visual Basic. Network Enabled Technologies. Microsoft released the .NET platform in 2001, that supports Visual Basic .NET which is an upgrade to the last version of VB programming language. It is a high-level programming language for the Microsoft .NET Framework. It is also possible to run VB.NET on Linux and MAC operating systems.

Visual Basic or VB is a programming language was initially released in 1991. It was the first programming language that directly supported programmable graphical user interface using language-supplied objects. From that time until 2002, there were 7 other versions released, each version having features that increased the power of the language.

See also: https://www.geeksforgeeks.org/difference-between-vb-net-and-visual-basic/ https://learn.microsoft.com/en-us/dotnet/visual-basic/language-reference/

NHI1_BUILD

The build root directory, the real directory used is NHI1_abs_top_builddir

NHI1_EXT

The extension root directory, the real extension directory used is NHI1_EXT

NHI1_GEN

The generated-files root directory, the real generated-files directory used is NHI1_abs_top_gendir

NHI1_HOME

The real source directory: is same as NHI1_abs_top_srcdir

NHI1_abs_top_builddir

The real build directory: NHI1_BUILD/NHI1_target/NHI1_setup

NHI1_abs_top_extdir

The real extension directory: NHI1_EXT/NHI1_target/NHI1_setup

NHI1_abs_top_gendir

The real generated-files directory: NHI1_GEN/NHI1_target/NHI1_setup/...

NHI1_abs_top_srcdir

The real source directory: is same as NHI1_HOME

NHI1_setup

The setup is the last part of the build-directory :

possible values are: aggressive debug debug2 nothread perf-aggressive perf-release release
- user can define more setups with: Nhi1Exec, Nhi1Config etc
the real build-directory is: NHI1_abs_top_builddir

A setup is created with Nhi1Config and is just the configure of the build directory.

NHI1_target

The target is the second to last part of the build directory:

possible values are: x86_64-suse-linux-gnu
basically the return of ./config.guess of the automake/autoconf build environment.
other values can also be chosen, but the configure script must accept the value.

microsoft

Microsoft Corporation is an American multinational technology conglomerate headquartered in Redmond, Washington. Founded in 1975, the company became highly influential in the rise of personal computers through software like Windows, and the company has since expanded to Internet services, cloud computing, video gaming and other fields. Microsoft is the largest software maker, one of the most valuable public U.S. companies, and one of the most valuable brands globally.

https://en.wikipedia.org/wiki/Microsoft

MONO

Mono is a free and open-source software framework that aims to run software made for the .NET Framework on Linux and other OSes. Originally by Ximian which was acquired by Novell, it was later developed by Xamarin which was acquired by Microsoft. In August 2024, Microsoft transferred ownership of Mono to WineHQ.

https://en.wikipedia.org/wiki/Mono_(software)

.NET

The .NET platform (pronounced as "dot net") is a free and open-source, managed computer software framework for Windows, Linux, and macOS operating systems. The project is mainly developed by microsoft employees by way of the .NET Foundation and is released under an MIT License.

New versions of the .NET platform are released annually, typically in November. The most recent version of .NET is .NET 9, released in November 2024, while the current long-term support (LTS) version is .NET 8, released in November 2023 and scheduled to receive updates until November 2026.

https://en.wikipedia.org/wiki/.NET

open-source

Open-source software (OSS) is computer software that is released under a license in which the copyright holder grants users the rights to use, study, change, and distribute the software and its source code to anyone and for any purpose. Open-source software may be developed in a collaborative, public manner. Open-source software is a prominent example of open collaboration, meaning any capable user is able to participate online in development, making the number of possible contributors indefinite. The ability to examine the code facilitates public trust in the software.

https://en.wikipedia.org/wiki/Open-source_software

OpenSUSE

openSUSE is a free and open-source Linux distribution developed by the openSUSE project. It is offered in two main variations: Tumbleweed, an upstream rolling release distribution, and Leap, a stable release distribution which is sourced from SUSE Linux Enterprise.

https://en.wikipedia.org/wiki/OpenSUSE

Oracle Corporation

Oracle Corporation is an American multinational computer technology company headquartered in Austin, Texas. Co-founded in 1977 by Larry Ellison, who remains executive chairman, Oracle ranked as the third-largest software company in the world by revenue and market capitalization as of 2020, and the company's seat in Forbes Global 2000 was 80 in 2023.

The company sells database software, particularly the Oracle Database, and cloud computing. Oracle's core application software is a suite of enterprise software products, such as enterprise resource planning (ERP) software, human capital management (HCM) software, customer relationship management (CRM) software, enterprise performance management (EPM) software, Customer Experience Commerce (CX Commerce) and supply chain management (SCM) software.

https://en.wikipedia.org/wiki/Oracle_Corporation

UNIX

Unix (trademarked as UNIX) is a family of multitasking, multi-user computer operating systems that derive from the original AT&T Unix, whose development started in 1969[1] at the Bell Labs research center by Ken Thompson, Dennis Ritchie, and others. Initially intended for use inside the Bell System, AT&T licensed Unix to outside parties in the late 1970s, leading to a variety of both academic and commercial Unix variants from vendors including University of California, Berkeley (BSD), Microsoft (Xenix), Sun Microsystems (SunOS/Solaris), HP/HPE (HP-UX), and IBM (AIX).

https://en.wikipedia.org/wiki/Unix

LINUX

Linux is a family of open-source Unix-like operating systems based on the Linux kernel, an operating system kernel first released on September 17, 1991, by Linus Torvalds. Linux is typically packaged as a Linux distribution (distro), which includes the kernel and supporting system software and libraries—most of which are provided by third parties—to create a complete operating system, designed as a clone of Unix and released under the copyleft GPL license.

https://en.wikipedia.org/wiki/Linux

application-server

9.a (client-server) One interpretation is that multiple clients connect to the same server.

An application server is a server that hosts applications or software that delivers a business application through a communication protocol. For a typical web application, the application server sits behind the web servers.

An application server framework is a service layer model. It includes software components available to a software developer through an application programming interface. An application server may have features such as clustering, fail-over, and load-balancing. The goal is for developers to focus on the business logic.

https://en.wikipedia.org/wiki/Application_server

garbage-collection

See also: C# references

In computer science, garbage collection (GC) is a form of automatic memory management. The garbage collector attempts to reclaim memory that was allocated by the program, but is no longer referenced; such memory is called garbage. Garbage collection was invented by American computer scientist John McCarthy around 1959 to simplify manual memory management in Lisp.

https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)

Object-Oriented-Programming (OOP)

Object-oriented programming (OOP) is a programming paradigm based on the concept of objects, which can contain data and code: data in the form of fields (often known as attributes or properties), and code in the form of procedures (often known as methods). In OOP, computer programs are designed by making them out of objects that interact with one another.

Many of the most widely used programming languages (such as C++, Java, and Python) are multi-paradigm and support object-oriented programming to a greater or lesser degree, typically in combination with imperative programming and declarative programming.

https://en.wikipedia.org/wiki/Object-oriented_programming

pthread

In computing, POSIX Threads, commonly known as pthreads, is an execution model that exists independently from a programming language, as well as a parallel execution model. It allows a program to control multiple different flows of work that overlap in time. Each flow of work is referred to as a thread, and creation and control over these flows is achieved by making calls to the POSIX Threads API. POSIX Threads is an API defined by the Institute of Electrical and Electronics Engineers (IEEE) standard POSIX.1c, Threads extensions (IEEE Std 1003.1c-1995).

Implementations of the API are available on many Unix-like POSIX-conformant operating systems such as FreeBSD, NetBSD, OpenBSD, Linux, macOS, Android[1], Solaris, Redox, and AUTOSAR Adaptive, typically bundled as a library libpthread. DR-DOS and Microsoft Windows implementations also exist: within the SFU/SUA subsystem which provides a native implementation of a number of POSIX APIs, and also within third-party packages such as pthreads-w32, which implements pthreads on top of existing Windows API.

https://en.wikipedia.org/wiki/Pthreads

runtime-local-storage

See also: MkKernel_Storage_C_API; MkRuntimeC_C_API

server-instance

See also: MqContextC_LinkApi_Link_C_API; 9.a (client-server) One interpretation is that multiple clients connect to the same server.

thread

See also: HOWTO thread in PLMK

In computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by a scheduler, which is typically a part of the operating system. In many cases, a thread is a component of a process.

The multiple threads of a given process may be executed concurrently (via multithreading capabilities), sharing resources such as memory, while different processes do not share these resources. In particular, the threads of a process share its executable code and the values of its dynamically allocated variables and non-thread-local global variables at any given time.

The implementation of threads and processes differs between operating systems.

https://en.wikipedia.org/wiki/Thread_(computing)

thread-local-storage

See also: MkKernel_Storage_C_API; MkRuntimeC_C_API; Weak or Strong reference

In computer programming, thread-local storage (TLS) is a memory management method that uses static or global memory local to a thread. The concept allows storage of data that appears to be global in a system with separate threads.

Many systems impose restrictions on the size of the thread-local memory block, in fact often rather tight limits. On the other hand, if a system can provide at least a memory address (pointer) sized variable thread-local, then this allows the use of arbitrarily sized memory blocks in a thread-local manner, by allocating such a memory block dynamically and storing the memory address of that block in the thread-local variable. On RISC machines, the calling convention often reserves a thread pointer register for this use.

https://en.wikipedia.org/wiki/Thread-local_storage

thread-pool

See also: plmk_thread_pool

In computer programming, a thread pool is a software design pattern for achieving concurrency of execution in a computer program. Often also called a replicated workers or worker-crew model, a thread pool maintains multiple threads waiting for tasks to be allocated for concurrent execution by the supervising program. By maintaining a pool of threads, the model increases performance and avoids latency in execution due to frequent creation and destruction of threads for short-lived tasks. The number of available threads is tuned to the computing resources available to the program, such as a parallel task queue after completion of execution.

https://en.wikipedia.org/wiki/Thread_pool