Technology

Computer Programming

Languages Skill Subgroups Skill Modifiers Software Development Hacking
 
 
 
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.
METACYBER COMPUTER LANGUAGES
  • 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)
    • Pix-it
    • 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+)
COMPUTER LANGUAGE DEFINITION
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 syntaxes.
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 use.
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 Syntax (LQS).
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 Software".
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)
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
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)
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 quickly.
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 logging.
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 approach.
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.
WIDGETSCRIPT (WScript)
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.