COMPUTER PROGRAMMING LANGUAGES
Hackers in the MetaCyber setting should know at least one Programming
Language at expert level or higher (14-).
There are many different programming, query, and scripting languages
in use in the MetaCyber setting, that must be purchased separately
as indicated by the adjoining table. A brief description of
each of the languages follows below.
- LANGUAGES (bought individually for 1 point)
- Enoch (E) / Enoch Plus (E+)
- Freestyle (FS)
- Logical Design Syntax (LDS)
- Logical Query Syntax (LQS)
- Packet Frameset Router Code (PFRC)
- Sidewinder (SW)
- VarDim 3.3 (VD3)
- Widget v12 (W12)
- WidgetScript (WScript)
- Wide-zone Switch Operation (WSO)
- Other (Specify)
A character must know at least one language, at normal cost,
in order to apply their otherwise theoretical Computer Programming
skill to a practical use.
Characters take a -4 skill penalty when using Computer Programming
for a task using a language they don't know. However this penalty
is lessened if the character knows a similar language at the
GM's discretion, but is never completely removeable. Penalty
Skill Levels cannot be purchased to apply to this penalty.
ENOCH (E) & ENOCH PLUS (E+)
The term computer language is a more expansive and alternate
term for the more commonly-used term programming language. It
includes a wide variety of languages used to communicate with
computers and includes query, markup, and scripting languages,
machine / byte codes, and even configuration files with special
A brief high-level glossary of terms is provided to help non-computer
programmers understand key concepts sufficiently to roleplay
a character with the Computer Programming skill.
MACHINE LANGUAGE: A system of instructions and data executed
directly by a computer's central processing unit. Machine code
may be regarded as a primitive (and cumbersome) programming
language or as the lowest-level representation of a compiled
and/or assembled computer program. Programs in interpreted languages
are not represented by machine code however, although their
interpreter (which may be seen as a processor executing the
higher level program) often is. Machine code is also referred
to as native code, a term that, in the context of an interpreted
language, may refer to the platform-dependent implementation
of language features and libraries. Practically no one programs
in a pure machine language.
ASSEMBLY LANGUAGE: A much more readable rendition of
machine language, called assembly language, uses mnemonic codes
to refer to machine code instructions, rather than simply using
the instructions' numeric values. Practically no one programs
in a pure assembly language.
HIGHER GENERATION PROGRAMMING LANGUAGES: A programming
language is an artificial language that can be used to control
the behavior of a computer. Programming languages, like human
languages, are defined through the use of syntactic and semantic
rules, to determine structure and meaning respectively. However
unlike human languages, programming languages are logic oriented
and are intended to allow the declaration of precise commands
that ultimately can be evaluated and / or executed by a machine.
Programming languages vary in their complexity, flexibility,
functionality, design orientation, and difficulty to use, as
well as what they are best used for. Thus rather than there
being one all-purpose universal programming language, there
have practically always been a plethora of them, with adherents
and detractors. In the MetaCyber setting there are many different
dominant / common programming languages currently in widespread
PROCEDURAL PROGRAMMING: A programming paradigm based
upon the concept of the procedure call. Procedures, also known
as routines, subroutines, methods, or functions simply contain
a series of computational steps to be carried out. Any given
procedure might be called at any point during a program's execution,
including by other procedures or itself.
OBJECT ORIENTED PROGRAMMING (OOP): is a programming paradigm
that uses reusable and individually defined "objects" and their
interactions to design applications and computer programs. Programming
techniques may include features such as encapsulation (internalizing
dependencies vs. relying on mutable global dependencies), modularity
(seperation of concerns into small task-oriented parts that
can be mixed together for different effects), polymorphism (use
of well-known interfaces / contracts allowing different implementations
to be consumed safely by other code that understands the interface),
and inheritance (ability to make more specialized derived classes
by inheriting from existing classes).
OOP vs PROCEDURAL PROGRAMMING: The focus of procedural
programming is to break down a programming task into a collection
of variables, data structures, and subroutines, whereas in object
oriented programming it is to break down a programming task
into objects. OOP languages generally include procedural aspects,
though across a more complicated concept of scoped accessibility.
The reverse is generally not true; procedural programming languages
do not usually have object oriented aspects; however some languages
have been able to "graft on" an OOP flavored syntax and defer
handling of it to the compiler or interpreter to translate the
code into something usable by the run time environment. This
is typically referred to as psuedo-OOP.
FUNCTIONAL PROGRAMMING: A programming paradigm that treats
computation as the evaluation of mathematical functions and
avoids state and mutable data. It emphasizes the application
of functions, in contrast with the imperative programming style
that emphasizes changes in state. Functional programming languages,
especially purely functional ones, have largely been emphasized
in academia rather than in commercial software development.
Note that many non-functional programming languages can be made
to exhibit functional behaviors if necessary (usually through
function pointers or delegation). Also note that "functions"
exist in procedural and OOP languages; the precise nuance of what the
word means are contextually different between the paradigms,
though related -- pure functional programming uses nothing but stateless
chained functions while "non-functional" programming may use
functions but not exclusively and they are not necessarily "pure".
METACYBER FUNCTIONAL PROGRAMMING: In the MetaCyber setting
no major commercially oriented language is purely functional in nature,
but all versions of Widget after v3 inclusive, Enoch Plus via
the "f" extention library (E+f), and Freestyle from v1 beta
up all support functional style programming at need. A number
of academic, domain-specific, and specialized proprietary languages
are functional as well.
QUERY LANGUAGE: Query languages are computer languages
used to make queries into databases and information systems.
Query languages typically focus around mechanisms to identify
data and / or patterns of data and while it is a gross simplification
they can usually be thought of as filtering mechanisms. More
advanced query languages include syntax for basic conditional
and even procedural logic, and most query languages provide
various mechanisms to transform and / or manage data. Of particular
note in a MetaCyber campaign, going after data will most likely
require use of one or more query languages; the most common
query language in use in the MetaCyber setting is Logical Query
SCRIPTING LANGUAGE: A common programming task is known
as scripting, or connecting / exercising diverse pre-existing
components to accomplish a new related task. Those languages
which are suited to scripting are typically called scripting
languages. Many languages for this purpose have common properties:
they favor rapid development over efficiency of execution; they
are normally implemented with interpreters rather than compilers;
and they are often strong at communicating with program components
written in other languages. However, scripting languages are
typically specialized and only meaningful within some larger
context. There are many different kinds of scripting syntaxes.
Among other things, scripting languages are often used to set
up login scripts, which makes it a subject of interest to hackers.
The most common general scripting languages in use in the MetaCyber
setting are VarDim Lite (VDL) and WidgetScript (WScript). The
most common script language used for security and network administration
is the special purpose Enterprise Administration Script Interpreter
(EASI, referred to as "easy script"); this is treated as "Other
MARKUP LANGUAGE: A classic concept in computer science
revolves around recognition that there is a difference between
data and how it is presented to a user. The same data can be
presented many different ways; the directions for how to do
so are effectively a form of meta data -- information that describes
or decorates other information. This is typically called "markup".
The needs of describing how to layout and display data vary
widely by intent, and can be highly specialized. This has lead
to the creation of numerous "markup languages" specific to different
presentation targets. Markup languages are generally easy, relatively
harmless, and of limited interest to serious software developers.
In the MetaCyber setting these types of "languages" are essentially
handwaved; any character with a Computer Programming or Computer
Usage Skill of at least 11- should be able to puzzle out basic
markup relevent to the subgroups of those skills they already
have without needing to pay additional points for the ability.
Enoch (E) and its successor Enoch Plus (E+) have
been around for over two decades, and are ideal for handling
critical, resource intensive processes. It is widely used for
robust applications of many sorts, and most operating systems
on the market. However it is a very "heavy" language,
relatively slow to develop in, and has been losing popularity
with developers for many years. While there are some differences,
in general a person that can program in E can figure things
out in E+, and vice versa as they are about 85% the same.
Most people only bother to learn it anymore if they plan to
work on legacy systems, operating systems, or for companies
that are slow to adopt newer technologies. E is mostly Procedural
while E+ is an "interesting" mix of Procedural and
Object Oriented methodologies, but both rely heavily on common
libraries to achieve most of their efficiencies and raw processing
power; a big difference between the two is that E+ allows the
creation of new libraries, and the overriding of common libraries,
and E+ has built in hooks to work with NSDL where as E requires
a lot of hackwork to be compatible with NSDL (which is often
buggy besides). E+ supports semi-interactive debugging and has
many debugging options.
A lot of firmware is coded in E, including some electronic locks.
Freestyle (FS) is framework based, relatively lightweight,
and flexible technology that relies on the use of syntax independent
core functionality interfaced via syntax "Styles",
which are all made to work together via syntax specific compilers.
Using decompilers it is even possible to translate code from
different syntaxes into a syntax of choice, making this technology
very easy to use. Styles are available mimicking the syntaxes
and primary features of most other major programming languages;
most strongly supported are an Enoch Plus Style called FS-E+,
and a Widget v12 Style called FS-W12.
Because of this assimilation oriented design Freestyle is easy
for programmers of differing backgrounds to use collaboratively
(though there are still practical limits), and though relatively
new with only three years on the market FS has gained a sizeable
following. Which isn't surprising since FS was purposely designed
to "take the best ideas" from the dominant development
platforms in use when it was created and "leave the rest
in the Disposer", according to several people involved
in the design team. FS supports very powerful and feature rich
almost fully interactive debugging, and multiple levels of logging
making it perhaps the easiest of all languages to debug in.
LOGICAL DESIGN SYNTAX (LDS)
Logical Design Syntax (LDS) is strongly associated with
LQS. However where LQS allows the analysis and manipulation
of data in a database, LDS allows the creation and manipulation
of the database objects themselves. However, only higher end
database systems support LDS; lower end products use wizards
or interfaces to accomplish the tasks, hiding the underlying
commands from the user.
The LDS standard is more closely complied with by the systems
that use it than LQS is however, with only very minor difference
across most flavors. LDS has no support for debugging.
LOGICAL QUERY SYNTAX (LQS)
Logical Query Syntax (LQS) is the defacto standard for
the vast majority of databases. Older databases, twenty years
and more, have widely divergent means of querying against, analyzing,
and modifying data, but practically all modern databases support
some variation of LQS. Though there are subtly different flavors,
and some implementations support more or less built in functions,
and none of the flavors exactly match the LQS standard, they
are all 80 to 95% the same so that there is a high degree of
knowledge carry over between them. LQS has no support for debugging.
PACKET / FRAMESET ROUTER CODE (PFRC)
Packet Frameset Router Code (PFRC) is used primarily
for the configuration and administration of network "backbone"
hardware. This is not a fully fledged programming language;
it has a limited set of commands that are supported by network
related hardware in accordance with strict standards. However,
due partially to its terseness, the macro execution nature of
the commands, and sensitivity to subtle differences arising
from specific sequencing it can be a very tricky language
to actually use.
Typically as a security measure PFRC is not usable remotely
on many critical devices; a person needs physical access to
a device to alter its code. PFRC is often referred to as "Phreak"
or variations on that theme in the industry. PFRC has no support
for debugging instead relying on a more industrial-oriented
"diagnostic" model. The diagnostics produce arcane metrics and
low-level system codes that are heavily reliant on expert interpretation.
There is a high degree of job security built into the model.
PFRC is used in a lot of infrastructure hardware and other low-level
physical devices and is very far removed from higher level,
user interface oriented software. It is not founded in traditional
higher level computer science design concepts, being focused
on much more concrete principles.
More technicians and IT engineers know it than software developers,
but because of its heavy use in infrascruture a lot of hardcore
Hackers learn it and can cause serious and very subtle harm
to hardware they can get physical access to by mucking around
with PFRC settings at the device level.
Pix-It is a language whose primary purpose is the definition
of visuals. It is generally only used to create special effects
and on screen visuals for the entertainment and media industries,
for game design, and to provide foundations for NSDL Wrappers
to make NEC. Pix-It is a component based technology oriented
around the idea of Rendered Object Components (ROCs); each individual
object or unit is rendered and compiled separately to form individual
components that can be instantiated, composed, and controlled
by a more traditional code engine.
Most code engines consuming Pix-it ROCs are written in a sublanguage
of Enoch or Enoch Plus which basically use a stripped down selection
of the common Enoch libraries plus a couple of Pix-it specific
libraries. These sublanguages are often called P or P+ in the
industry, though these are not official product names. A character
that knows both Enoch and Pix-It is proficient with this sublanguage.
Pix-It supports a debugger of a sort, but due to the component
oriented model and the unforeseeable ways in which individual
units can be consumed the debugger isn't very useful beyond
determining if a bug is internal or not. Rigorous and expensive
to develop test harnesses are required to truly test Pix-It
objects, leading to a big dichotomy between high quality (well
tested) and low quality (poorly tested or untested) ROC's, the
associated costs, and so forth.
Sidewinder (SW) is a lightweight OOP game design language.
Its main innovation is a good selection of basic pre-defined
objects that are useful for relatively simple games, such as
pixel mapping, pathing detection, random determinations, score
keeping methods, time keeping and hooking, and bots with extensible
behaviors. There are a lot of limitations on what SW based games
can do, but within those limitations it is possible to make
some fun and decent looking "arcade" style games relatively
The most common outlet for such games is on Personal Data Assistants,
and a pocket industry exists to produce games for this market.
SW games are too limited to be used for fully immersive NEC,
but they can be made NET enabled, allowing things like NET based
"face to face" tournaments similar to chess matches
back in the old days.
There is no practical or business use for SW games. Sidewinder
has no support for debugging, but it does support verbose error
VARDIM 3.3 (VD3)
VarDim 3.3 (VD3) is the final iteration of a popular
midweight programming language. VD 3.3 is a combination of modular
Procedural and psuedo-OOP, and its primary strength was being
designed specifically to allow rapid application development,
with a verbose and human-friendly syntax and integrated code
helpers. It has NSDL hooks built into it, and can even generate
low to mid quality NSDL Wrappers for compiled applications with
a built in wizard. The basic syntax and logic were also externalized
into what was called VarDim Lite (VDL) and used as a scripting
or macro language in many office applications.
VD 3.3 was innovative for its time, but since it makes it easy
for people without fully fledged formal computer science educations
to generate applications that are crude but powerful via wizard
code and drop-in components, it has something of a stigma associated
with it among some "real" programmers. The shocking
permissiveness of the toolsets and compiler also allow some
very questionable code to be compiled, which contributes to
this stigma as well. However, despite this stigma it is possible
for a person that knows what they are doing to write some very
good software with VD 3.3.
It primarily competed with Enoch Plus, relying on its
rapidity if development and a business model using less well
compensated programmers to contend with the more robust but
slower to develop industry juggernaught, and contributed heavily
to the weakening of Enoch Plus as the premiere development platform.
Three years ago plans for VD4 were killed, and instead all of
the best features of VD3 were conflated into Freestyle (FS).
There is a Style for VD3 syntax, but most of the conveniences
of the VD3 toolset that allowed very lazy coding have been reigned
back and more formal design is enforced. As a language that
has been obsoleted in the last few years, there is little to
no new development being done with it, but there are still legacy
applications in place. Support for VDL or something very like
it also continues to live on in many applications, making it
a useful language to be familiar with at times. VDL has no support
for debugging. VD3 has fully interactive debugging with adequate
but simple debugging tools; however it's overly permissive compiler
allows things to slip into releases that blow up at run time.
WIDGET v12 (W12)
Widget v12 (W12) is the current iteration of an OOP based
language with a thirty odd year history. However, the versioning
is misleading; the only thing v1 and v12 have in common is the
basic idea of being object oriented. Beyond that, they diverge
sharply in implementation. v11 was a watershed version for the
language, with a heavy shift towards a more Enoch Plus like
syntax, but adapted towards a "pure" object oriented
However v11 was rushed to market to staunch the loss of share
to E+, but was lacking some key pieces that had been core to
the Widget concept for many years and touched off bitter complaints
among its developer community. The most notable missing piece
was the built in support of Design Patterns that many considered
to be an integral part of technology.
In response v12 was released roughly a year later with the Design
Pattern functionality restored, and some allowances for the
older v10 style syntax to be incorporated or at least paralleled
in the new syntax. After some hesitancy, v12 was deemed to be
solid by the community, and soon was hyped as an E+ killer.
It was the "hot" language for about a year, before
the release of Freestyle (FS), which assimilates many of the
best features of W12 and has eaten into its user base over the
last three years.
W12 still has a reasonable market share, and most new apps written
three to four years ago were written with W12, making it a useful
language to know. Widget v12 has semi-interactive debugging,
solid debug tools, and almost too much logging.
There is also a very sparse scripting language that has stood
the test of time called WidgetScript (referred to as WScript),
modeled after the syntax and composition of Widget v10 but lacking
all the higher order OOP features. It has been in use for almost
a decade and finds widespread use in all sorts of unexpected
places, from custom utilities, to hacks, automation software,
scheduled tasks, and as part of internalized scripting support
for software written in the last three versions of Widget. It
is technically a seperate language (or more accurately a subset)
with its own quirks, but anyone that knows Widget v10, 11, or
12 can figure it out at need. The reverse is not necessarily
true; a person that only knows WScript would likely struggle
with the more advanced OOP concepts used in fully fledged Widget
based applications. The exact game effects, if any, is left
to the GM's determination.
WIDE-ZONE SWITCH OPERATION (WSO)
Wide-zone Switch Operation (WSO) is, like PFRC, primarily
used to configure network "backbone" hardware and
related devices piggybacking on its standard. Originally intended
purely to handle complex switching tasks to optimize the flow
of network traffic, its ability to manage communications in
a hyper-efficient fashion made it very usable for other interconnectivity
tasks and the standard was expanded over the years to increase
this compatibility, but the name was not changed. It is commonly
referred to as "Wizzo" in the industry, as are those
who are good at using it.
This language is more script-like than PFRC, and supports some
basic conditional programming, making it more flexible. It's
syntax is also less terse and more easily understood than PFRC,
and WSO supports basic authentication security, allowing many
devices that use it to support remote administration of some
functionality. WSO has no support for debugging, but does support
explicit logging if a programmer writes it in.
A lot of security oriented devices are coded in WSO, including
some electronic locks.
OTHER PROGRAMMING LANGUAGES
There are many other programming languages that have been used
in the past, and some lesser or niche languages still being
used in the modern day in the MetaCyber setting. The GM should
feel free to invent such other languages as they feel will enrich
their campaign, decide what they are used for, and characters
can learn those languages exactly the same as one of the languages
defined above. Note that proprietary corporate languages are
covered under the broad subgroup of Proprietary Technology.