J's Tech Series 0.5.2a

Codename: Boron.

Changed

• (Computers) Racks and servers: Every storage server has two expansion slots, so its storage card has room beside a
  graphics card, which a board with no video of its own needs for a monitor. Only the Legacy storage server had two;
  the others had one, and a graphics card in it left no room for the Vaultis Array or the Vaultis Cache.

Fixed

• (Computers) Redstone Interfaces: A Redstone Interface placed facing up or down stands in its own block, its lens
  toward the block above or below it, without its feet. It turned on the bottom of its block instead and lay half
  inside the block under it. Its back is closed too: the gland where the cable plugs in and the bends of its wires
  showed their insides.
• (Computers) Cases and parts: The fans of the cases, the coolers, the processors and the graphics cards no longer
  flicker where their blades cross, and a card or an M.2 drive no longer flickers along the edges of its slot. In the
  Advanced High Performance and Aesthetic cases, the frames of the two front fans no longer flicker against the water
  cooler's radiator behind them, and their outer sides are closed.
• (Computers) Buses: The arrows on the External Storage Bus no longer flicker where the two of them meet.

J's Tech Series 0.5.1a

Codename: Boron.

Changed

• (Computers) Hardware: A motherboard's tooltip says whether it drives a screen by itself: a server board has a screen
  output of its own, for its console, and every other board needs a graphics card, or a processor with graphics, for
  a monitor. The manual's page on motherboards says so too, and what to do when a card will not go into a server.

Fixed

• (Computers) Programs: A server in a rack runs Σ# programs as any computer does, each server its own: sigma run
  at its prompt starts one there, where it said the machine could not run programs, and a script runs on by itself,
  listed and ended by its number with sigma ps and sigma stop. What a server runs is kept on its Server item with
  the rest of its run, so it is still running when the world comes back, and it ends when the server is switched off,
  restarted or pulled out of its rack. A server's programs reach its drives, its network and the operations they ask
  of it; Gateways, Redstone Interfaces, sound and windows are still a computer's alone.
• (Computers) Cases: The water cooler of the Advanced High Performance and Advanced Aesthetic cases lays its radiator
  across the two fans at the front, behind both of them, with its tubes coming down to it from the pump. It stood on
  end behind one of the fans, well above and below them.
• (Computers) Assembly: Once a board is in, the window of a computer or a server draws only the slots the board and
  the case wire. The others were drawn dimmed and looked like slots waiting for a part, but took none, so a card held
  over one went nowhere without a word: a storage server whose one card slot held a graphics card seemed to have five
  more. Before a board goes in, every slot still shows dimmed where its part goes.

J's Tech Series 0.5.0a: The Start Me Up Update

Codename: Boron.

API

• (Core, Computers) Versions: J's Core's API is at version 4 and J's Computers' at version 7. Everything this release
  adds to either, or changes, carries @ApiStatus.Experimental: it keeps the mark through this release and loses it
  when the next cycle begins. Each mod's API is now kept line by line, every type and member a mod can reach with the
  version that brought it, and the tests fail when the code and that list disagree; docs/API.md says how.
• (Computers) Added: ComputersRegisterEvent.graphicsProgram and JsComputersApi.registerGraphicsProgram: a program
  whose windows draw through a surface says so on both sides, so the server counts the video memory they hold too. An
  ISA or a file opener registered after the game has loaded is refused with a line in the log.
• (Computers) Added: IsaSpec, ComputersRegisterEvent.isa and JsComputersApi.registerIsa, which take over from
  ArchitectureSpec, architecture and registerArchitecture.
• (Computers) Added: EngineDef, EngineCapability, ComputersRegisterEvent.engine and
  JsComputersApi.registerEngine. A mod registers a Network Operations Engine by its package (a program registered
  like any other), the dialect it speaks, the version it ships in for each age of Mainframe and the extras it offers;
  until it brings a planner of its own it plans the way the Midsoft IQL Server does. Its package is of the new kind
  ProgramKind.NETWORK_ENGINE.
• (Computers) Added: the package dev.jstech.computers.api.planner, for the engines that take extensions (NextgreIQL
  among them): IPlannerRule weighs every plan the planner considers and is switched on or off per Mainframe;
  IPlannerOperator is a hint the dialect accepts after a statement; IPlannerStatistic shows among the planner's
  statistics and may say how long a step takes; IExplainNode adds notes under a plan's steps. A plan is a
  PlanCandidate of PlanSteps, whose cost a rule or a hint may change or which it may set aside, saying why. They
  are registered with ComputersRegisterEvent.plannerRule, plannerOperator, plannerStatistic and explainNode
  (or the JsComputersApi.register... methods of the same names).
• (Computers) Added: ProgramRequirement and ProgramSpec.requires, with requiring: a program says what it needs
  of the network's engine (the engine it is written for and the oldest version of it, or the capabilities it uses),
  which is checked when it is opened rather than when it is installed.
• (Computers) Added: kinds of component for Σ# programs' windows: ComponentKind and IComponentValidator,
  registered with ComputersRegisterEvent.componentKind (or JsComputersApi.registerComponentKind) in the adding
  mod's namespace; on the client, ComponentRenderers.register with an IComponentRenderer, which reports what a
  player did through IComponentActions.
• (Computers) Added: programs with windows written in Java: DesktopApps.register with an IDesktopProgramFactory
  making a DesktopProgram, which draws itself or through a SurfaceRenderer, for whoever opened it; this replaces
  registering a window factory with the mod's own desktop code.
• (Computers) Changed: what a program declares with ProgramSpec.withRam is what it holds on a machine of the Legacy
  era, grown on the later eras and shrunk on the Vintage; ProgramSpec.legacyMb() says it, with what a program of its
  kind holds when it declared nothing, and ProgramSpec.ramMbOn(HardwareEra) and ramMbOn(HardwareEra, boolean) say
  what it holds on a machine of that era. The forms of ramMbOn that took the system an OsDef names are gone.
• (Computers) Changed: OsDef says its shell with a ShellKind (shell, where it had the id shellId), and so do
  linuxDistro and terminalSystem. ProgramSpec has a description, of no longer takes the display name
  (named and described give the English words), and name() is the name to translate. A
  DesktopEnvironmentDef's native names are TextKeys, and so are what nameOf and launcherLabel give.
• (Computers) Changed: ComputerTerminalMenu stands on the Core's CoreMenu, which now holds what it had from the
  menu it stood on before. Its layout constants (INV_X, INV_Y, HOTBAR_Y and the STORAGE_ ones) and
  storageSlotCount() are gone: invY() and hotbarY(), with the new invX(), give where the inventory is drawn.
  openingTab says which tab a terminal opens on.
• (Computers) Changed: an operating space's screen is handed an IOperatingSpace, a narrow face of the machine (its
  menu as the game's kind of menu, the machine, the monitor, the space and the era), in place of
  ComputerTerminalMenu, which is no longer part of the API. IOperatingSpaceScreen.open takes it and gives back the
  screen built on its menu.
• (Computers) Deprecated: ComputersRegisterEvent.architecture, JsComputersApi.registerArchitecture and
  ArchitectureSpec. They still work, handing what they are given to the instruction set registration, and go in the
  next cycle; ArchitectureSpec.toIsa() gives the same values under the new name.
• (Computers) Removed: ArchitectureSpec.runs (ask the IsaSpec from toIsa()), and
  DesktopEnvironmentDef.programFor.
• (Computers) Changed: its advancements stand on J's Core's event trigger, jscore:event, with the events named in
  the mod's namespace (jsc:post_passed); JscEventTrigger, JscTriggers.EVENT and the mod's own AdvancementTab,
  AdvancementSpec and ConditionalAdvancementProvider are gone.
• (Industrial) Changed: its machines stand on J's Core's; AbstractMachineBlockEntity,
  ProcessingMachineBlockEntity, MaceratingRecipe and CompressingRecipe are gone, and its two kinds of recipe are
  J's Core's processing recipes.
• (Core) Added: GuideBlockRenderers and IGuideBlockRenderer in J's Core's client API: what draws a mod's own kind
  of block on a manual's page, or a picture drawn as the page is shown, registered once from its client setup, handed
  the block's data as a tag.
• (Core) Added: a build can ask a language for an instruction set and a version of the language at once, with
  IProgrammingLanguage.compile(sources, CompileOptions); a language without versions builds as it did for the
  instruction set alone, which is what the method does unless overridden.
• (Core) Changed: IProgrammingLanguage.Complaint carries its message as a Text, read in the language of whoever is
  shown it, with the arguments the message was written around; text() is the line a person reads, and format()
  is still the same line in English.
• (Core) Added: J's Core's client API, dev.jstech.core.api.client: ISkin, the look a mod draws through inside a
  machine's screen (moved here from the Core's own GUI package); SurfaceRenderer, what draws frames onto a surface
  of its size, asked no faster than its frame cap and only while it is shown; and the two surfaces, PixelSurface, an
  array of colours uploaded when it changed, and GpuSurface, a render target drawn into with the game's rendering.
• (Core) Added, outside the versioned API for now: the parts of a general library for technology mods.
  Progression axes (ProgressionAxis, ProgressionAxes, PlayerProgress, ProgressionGate) that the hardware
  eras and the industrial tiers are now two of; multiblock patterns from data files or code, with ports on their
  parts (MultiblockPattern, MultiblockPatterns, PortKind); chunk and region data with a spatial index
  (SpatialIndex, RegionIndex) and chunk loading by owner (ChunkLoaders); ores, structures and dimensions
  declared for data generation (WorldGen, WorldGenProvider); owners, access and teams (Ownership, IOwned,
  CorePermissions), with FTB Teams answering for the teams when it is installed; processing machines and their
  recipes (MachineBlockEntity, ProcessingMachineBlockEntity, ProcessingRecipe, ProcessingKind declared with
  ModContent.processing, ProcessingRecipeBuilder, IUpgrade, UpgradeEffect); the recipe viewers' bridge
  (IKeepsViewersClear); advancements (EventTrigger, AxisStepTrigger, Advancements, and the data generation's
  AdvancementTab and ConditionalAdvancementProvider, moved up from J's Computers); commands under /jstech
  (SeriesCommands); a GameTest kit (ScenarioBuilder, GameTestPlayers); HUD elements (HudElements,
  IHudElement, HudStack); holograms (Holograms); what a block entity says to Jade (IDescribed); what an
  entity wears (WornItems, IWornSource); dimensions made while the game runs (RuntimeDimensions) and the rules
  of each (DimensionRules, DimensionRulesData, DimensionHazardEvent); declared entities (ModContent.entity),
  vehicles (VehicleEntity, VehicleSpec, DriverInput, IDriver), robots (RobotEntity, IRobotTask,
  RobotTasks, CoreRobotTasks) and projectiles (CoreProjectile, ProjectileSpec, Projectiles); and the
  settings screen (CoreConfigScreen, ConfigDraft).

Added

• (Computers) Eras: Two hardware eras join the ladder: the Transition, between Legacy and Standard (the late 2000s,
  64-bit, blue BIOS, flat panels, systems and programs on DVD), and the Advanced, after Standard. Each has its own look
  on the computing screens: the Transition in navy glass, its headers, buttons and selected tabs in two bands over a
  line of sky blue; the Advanced light and flat, white panels on grey under a thin blue line. Both palettes can be
  recoloured by a resource pack like the others.
• (Computers) Eras: Blu-ray discs, the Advanced era's medium: the BD-ROM and the rewritable BD-RE, each holding four
  times a USB stick. Advanced programs ship on Blu-ray, and its systems and services on the stick.
• (Computers) Hardware: The Vintage era fills out, so a weak machine and a top one can be built in it: the Velocion
  5x86-133 on Socket 3; the Integra Pentix 75, ...

J's Tech Series 0.4.0a: The Booting Update

Codename: Beryllium.

This is a huge update, focused in bugfixing, code restructuring, sanitization and improvements on the API.
However, several things where changed, ranging fro ma full rework on MC-NET, an overall improvement in
computer's post, with Gentoo and Arch being the ones that got the biggest improvements. Beyond this,
several new programs where added, and the basis for a full new system coming in boron was also added.

Added

• Solitaire and Snake, the two games these desktops always shipped with. Klondike drawing one card,
  dealt from a number so the same number deals the same game and one player can hand another the deal they
  are stuck on; and a snake in an arena whose walls can be turned off, which takes away the easy way to die
  and leaves only running into yourself. Both are as light as Minesweeper and run on any desktop. Once every
  card in a Klondike is face up and the stock is gone, the table offers to play itself home rather than
  asking for another forty clicks in the one order they can be made.
• 67ark, which packs many files into one that really weighs less. A disk here counts the bytes of what
  is on it, so archiving a folder of logs is how a small disk is made to stretch; text that repeats packs
  hardest, so a log collapses much further than a config does, and the program shows what each one saved.
  Opening an archive lists what is inside it without unpacking anything. It is also on the right button,
  where an archiver belongs: any file or folder, in the explorer or on the desktop, offers to compress into
  an archive beside it, and an archive offers to take everything back out where it stands. Compressing a
  folder packs what is in it, however deep it goes. Taking things out never writes over a file that is
  already there; it leaves that one alone and says how many it left.
• Paint, a real picture rather than a grid of blocks: a canvas up to 128 by 128 in a palette of 256
  colours, every tool the program it is named after had, zoom and undo. What it writes is about a kilobyte
  where a colour per pixel would be twenty-four, which is what makes keeping pictures on a disk possible at
  all. A picture can be hung on the desktop as its wallpaper, so something a player drew ends up on every
  screen of that machine. Its files, like the archiver's, open on a double-click and carry an icon of their
  own in every listing. All two hundred and fifty-six colours can be reached: the strip shows two rows at a
  time and the wheel runs it through the rest, the dropper brings whatever it picked up back onto it, and
  no two of them are the same colour. The pencil draws from where the hand was to where it is, so drawing
  quickly leaves a line rather than a row of dots.
• Exceed, a sheet of cells. Besides the arithmetic a spreadsheet has always done, a cell can ask the
  network what it is holding: how many of a thing, how much room is left, how many servers there are. Those
  cells are drawn apart from the ones the player typed, so nobody wonders why a number moved by itself, and
  they are worked out from what the machine last said rather than from asking the world. It reads and
  writes the comma separated files the mod already had, so a sheet is a file any other program can open.
  However many cells read each other, the whole sheet is worked out in one pass down.
• Midsoft Messenger and its Messenger Service, the first program here where the other end is
  another player: who is on the network, a window per conversation, and the nudge. The service runs on a
  server mounted in a rack, which is what a server is for, and is reached from any computer on that
  network, so a conversation is there when you next sit down at any machine on it. The history belongs to
  that server and rides on the Server item with everything else it holds: pull the machine out of the
  cabinet and the conversations go with it. The service is also the first in the mod that does not cost a
  fixed amount: it grows on the disk as it keeps what people said, and in the machine's memory as more of
  them are connected, and the window shows both. With no server on the network running it, the window says
  so and will not pretend to send anything.
• Knot and KnotHub, which keep the source a network is still arguing over. Push a file from the
  machine you are at, pull a revision back onto it, and read who changed what with the changes marked line
  by line. KnotHub runs on a server beside the Messenger Service, and the history belongs to that machine
  the same way. It sits under the package manager rather than beside it: a package is a finished thing one
  player hands to another, and this is the code before it became one.
• The eight programs and the two services carry icons of their own, in the three styles the desktops here
  are drawn in: the outlined artwork of the earliest edition, the glossy one after it, and the flat one the
  later editions and the Linux desktops wear. A card and a heart, a coiled snake round an apple, a parcel,
  a painter's palette, a sheet of cells, two speech bubbles, the fork of a history, and the two services as
  the server that runs them with what they serve badged on the corner.
• The editor grew into a real one. It was a name, a text area and a status line; it now has line numbers,
  find and replace, go to line, the line and column in the bar, Open and Save As through the system's own
  file window, and more than one file open at a time. A page with unsaved work on it asks once before it
  closes, and the page that was saved is the one marked saved even if you moved to another meanwhile. It
  stays a text editor: highlighting, completion, projects and a compiler are what tell the five development
  environments apart, and they stay theirs.
• MC-NET draws the whole monitor, as every other system does. Its interface was a 244 by 230 window with the
  player's inventory under it, throwing away 140 columns of a screen the desktops fill, which is why the one
  interface in the mod that is a whole system read as an inventory panel. It is now the glass: a status bar
  across the top that says which network the machine is on, how many servers it has, how much they hold and
  what is in flight; the headings down the left as words rather than icons; the network's store nine wide and
  seven deep beside a panel that says everything the machine knows about whatever is picked out; and the
  player's own rows glued over the bottom. It keeps the era skins, so a Vintage machine shows it in green
  phosphor with scanlines, a Legacy one in beige and system blue, and the later eras in the dark it had.
• Operating spaces: what a desktop environment is to a Linux, for the system that has no desktop. MC-NET
  ships with one, called the Interactor; take it off and the machine is a prompt and nothing else, exactly
  as a Linux with its desktop removed is a TTY. What a monitor opens is now decided by the space installed on
  the machine rather than by what the system is capable of. An add-on registers a space of its own and ships
  the whole screen behind it, so it can invent a way of working a network that nothing here imagined; ours
  goes in through the same door rather than being a special case behind it.
• The prompt is a heading inside MC-NET's interface. Clicking Console used to throw a separate Command Prompt
  window over the screen, which is a thing a screen that is the whole machine has no business doing to
  itself. It is a view of the machine's own console, so everything the prompt can do on a machine with no
  interface at all it can do here, editors and compilers included. The Command Prompt is no longer offered as
  a program on a network system, because there is nowhere for a window to go.
• MC-NET can be taught a recipe. crafting_manager and pattern_studio are both desktop programs, so a
  Crafting Computer running MC-NET could not put a single pattern into its own Recipe ROM: the one player
  that system exists for could not autocraft with recipes of their own. A Patterns heading now does that
  work in the system's own shape, under the same condition the Crafting Manager installs under, a Crafting
  Computer with a Crafting Card: the draft with the three destinations the Pattern Studio's bar sends to, the
  .craft files on a medium in a linked drive with Load all and Load one, and the ROM with Unload and
  Download beside it. A pattern is still born at a Pattern Encoder and nowhere else.
• The network's store can be narrowed by mod, and what is picked out has a panel of its own: what it is, what
  holds it and how much each of them holds, whether the network has a pattern for it, and the two things
  worth doing with it. It is the same answer the prompt gives for a thing, so the screen and the prompt never
  disagree about what the network is holding.
• MC-NET keeps files. Its kernel declared no filesystem at all while a dozen programs were declared for it,
  the two text editors and both compilers among them: a machine with nowhere to read or write, asked to run
  things that do nothing else. It now keeps a flat store, files at the root and no folders, which is what a
  network appliance of that age had and what tells it apart from the personal computer of the same year. So
  there is no cd to change folder, no folders to make or remove, and no tree to draw.
• MC-NET stops speaking DOS. It is its own shell family now, beside the DOS one and the Unix one, and it says
  what it does in whole words: listfiles for the disk, seefile to put a file on the glass, and delete,
  copy, rename and write for the rest. There is no cd, no mkdir, no rmdir and no tree, because
  a flat disk has nowhere to change into and no folders to make. Its prompt is SYSTEM:>, naming the machine
  rather than a place, since there is no p...

J's Tech Series 0.3.0a: The Programming Update

Codename: Lithium.

Computers are now programmable using, Cannon, the series' own programming language language, is written.
It is compiled and run on the computers themselves, with five editors to write it in, and ComputerCraft's computers reach the
data network through the Network Gateway. The computing mod is now called J's Computers.

Added

• Computers can now be programmed with the series' own programming language, Cannon. You write it at any computer, compile
  it there with cannonc down to assembly, and run what comes out. The compiler produces a listing you can open and read a
  line at a time, so any output can be verified.
• For now, a program is one of two things, and says which by how it is written. One with a Main runs at the
  terminal that started it, holds the prompt, prints as it goes and is gone when it returns. One that
  implements IScript stays up: set up once, called every tick, told when it is stopped, and still running
  after the world has been away and come back.
• A program spends only what the machine's processors are worth in a tick, so an old computer really does
  print line by line where a fast one finishes at once, and one that loops forever costs its machine the
  same tick as one that does nothing. There is no ceiling on that worth: a faster machine gets through
  more, however fast it is. What protects the server is the clock instead: each machine may run its
  programs for so much real time a tick, and all machines together for so much, both set in
  jstech-balance.toml. A machine the server had no time for goes first on the next tick, so a busy
  server slows every computer evenly and never stops one.
• A program can do more than one thing at once. Thread.Start runs a body beside the rest of the
  program, the two taking turns a few instructions at a time over the same memory; a thread can sleep
  for so many ticks, yield its turn, wait for another to end (or give up after a while) and be stopped.
  Because nothing runs at the same instant, a single expression is never torn; a run of them can be,
  and lock (thing) { ... } keeps it together, held on every way out of the block. Threads, their waits
  and their locks come back from a save where they were.
• Programs can start programs. Program.Start runs a compiled program from the same disks, with
  arguments the other reads through Program.Args, and hands back a handle to wait on, read the output
  of, ask the exit code of, or stop. A program ends itself with Program.Exit(code); what another program
  started keeps its output and code for that program to read until it goes. Programs on one machine
  can send each other lines, heard through Program.OnMessage. At the prompt, cannon run passes on
  whatever follows the file name.
• Computers on one data network can share folders with each other. config share C:\pub opens a folder
  for reading, config share C:\pub write for writing too, and config unshare pub closes it. Every
  other machine on the network reaches it as \\host\pub at the prompt (/net/host/pub on the Linux
  systems), from a program through File, and in the file explorer under Network, where hosts, their
  shares and the files inside can be browsed, opened and copied.
• A program can reach the other computers on its network. Network.Computers() lists them and
  Network.Computer("desk") picks one; on it a program can start a program from that machine's disks
  (the same handle as a local one comes back, to wait on, read and stop), run a line at its prompt, send
  a line to one of its programs and list what it runs. Everything runs on the other machine, out of its
  own budget. A machine that would rather not take any of that says config remote off.
• A program can speak the network's own language. Iql.Run sends a statement to the Mainframe as the
  prompt would and hands back whether it went, what it said and the rows it read; Iql.Query gives
  the rows alone and stops the program on a refusal; Iql.Exec runs a saved procedure and Iql.RunFile
  a file of statements, one a line.
• What a program can reach: the machine's own drives, with the same paths the prompt uses; what the machine
  is made of and what it is running; what the network holds, could hold, and which servers hold it; what the
  Mainframe has been doing this past hour; and the network itself, to pull, push, craft and cancel. Every row
  it leaves in the network's log names the program that asked.
• A program can ask to be told instead of asking. It says once that it wants to know when something runs
  low, and is called when it does: on the crossing, not for as long as it stays crossed.
• Programs can be handed to other people. canpack wraps one up with everything it needs into a single
  readable file, publishes it to the network's Mirror, and anyone on that network installs it like any other
  package, marked as a player's own. An installed one gets an icon on the desktop and a terminal to run in.
• A program's memory is counted like everything else the machine holds, so the Task Manager lists it beside
  the windows and services, and a machine without the memory for one says so instead of trying.
• The file explorer knows a source file, a compiled program and a package on sight, and running one is a
  double-click.
• The Network Gateway, a peripheral that puts the data network within reach of ComputerCraft's computers
  when CC: Tweaked is installed. It is placed facing away from the computer it serves: the peripheral cable
  plugs into its back, a ComputerCraft computer, wired modem or networking cable meets its front, and
  there it is a jsc_gateway peripheral under its own name. Between the two sides sits a buffer of nine
  slots, reachable from the other faces by a chest, a hopper or a turtle, and shown on the block's own
  screen with a status line and two lights. Several Gateways may serve one computer.
• The Gateway Manager, a program for the computer that has Gateways on its ports: the rail lists them
  by name, Rename and Identify (the block's lights blink) act on the selected one, and four tabs show it.
  Status puts this side and the ComputerCraft side as two cards, says how CC names the Gateway, shows
  the buffer with a button that empties it into the network as operations, and lists the last requests.
  Permissions holds the switches for reading the network and running operations, a priority ceiling for
  requests from CC, and how many calls a tick the Gateway answers. Computers lists the ComputerCraft
  computers attached and can send them a test event; Log keeps the last forty things the Gateway did.
  The gateway command does the same at any prompt.
• Through a Gateway, a ComputerCraft program reads the network (what it holds and where, how much room is
  left, which computers are on it), pulls items into the Gateway's buffer and pushes them back, asks for
  a craft, follows and cancels operations, watches a total and is told when it moves, writes a line in
  the Gateway's log, and starts a program on one of our computers. Every call is paid for out of the host
  computer's tick, counted against the Gateway's call cap, kept under its permissions and written in its
  log; an operation that settles and a watched total that moves come back as events.
• cannon run hello.can runs a Cannon source file as it is, compiling it on the way in.
• A Cannon program reaches the ComputerCraft side through its machine's Gateways. Gateway.Names lists them
  and Gateway.Select picks the one a program means, which stays with the program; Gateway.Computers and
  Gateway.Peripherals say what is on that Gateway's wire and what each thing answers to; Gateway.Call
  calls one of those methods and brings back what it said (a table comes back as a list or a map, a whole
  number whole); Gateway.TurnOn, Shutdown and Reboot work the computers over there; Gateway.Send
  says something to one of them, and Gateway.OnMessage hears what they say back through the Gateway's own
  send. A machine with no Gateway, or a Gateway with no ComputerCraft behind it, says so.
• A Cannon program can open windows of its own on the desktop of the machine it runs on. System.UI gives it
  a Window and the widgets to put in it (Label, Button, TextBox, CheckBox, ProgressBar, ListBox
  and a Canvas it draws on itself), laid out in rows and columns where a weight takes a share of the room
  left over, or placed exactly where the program says. It hears what the player does through OnClick,
  OnChange, OnSubmit, OnToggle, OnSelect and the window's OnClose. The machine's own system draws
  it, so the same program is a Frames 95 window on 95 and an XP one on XP, and it has a place on the taskbar
  under the program's name. A window is saved with the program and comes back with it; shutting the last one
  ends the program unless it opens another. A machine that boots to a prompt has nowhere to put a window and
  says so.
• A number, a bool or a character can now go where an object goes, and a cast takes the number back out
  as whichever kind is asked for: int n = (int) held;.
• Mods may add a programming language of their own, and remove this one. A language that registers itself
  gets the prompt, the terminal, the task manager, saving and the tick budget without writing any of them.
• Five editors to write a program in, each a different bargain between what it shows you and what it costs
  the machine to keep open. Virtual Studio is the whole workshop in one window, and the only one that tells you
  what a line will cost the program before you write it. Virtual Studio Code offers the same suggestions in a
  fifth of the memory, with the machine's own console welded into the bottom of the window. Exposure suggests
  nothing and instead compiles every program on th...

J's Tech Series 0.2.0a

The mod became a series. The code every module shares now lives in a library mod of its own, J's Core,
and the industrial machines in their own mod, J's Industrial; J's Computronics keeps the computers, the
network and the programs. The three ship together at one version. Worlds from 0.1.0a do not carry over:
the industrial blocks and the material items changed their ids.

Added

• J's Core (jscore), the library every mod of the series requires: the hardware eras and the industrial
  tiers, the material catalogue, the data network, the Operations framework, energy, peripheral links,
  multiblocks, configuration, the event bus, persistence, the unit formatter and the screen toolkit.
• J's Industrial (jsindustrial), the machines and their recipes, with a creative tab of their own; the
  Pattern Studio pairs its recipes with the Macerator, the Compressor and the Electric Furnace.
• Priorities for network Operations: a level from LOW to HIGH, chosen in the Network Interactor's request
  and craft dialogs or with an IQL PRIORITY clause, and changed on a live Operation from the Task Manager.
  A queued Operation gains a level while it waits, so none starves.
• Cancelling an Operation in flight, from the Task Manager or with cancel <id> at the prompt; ops now
  lists each Operation's id.
• The time every Operation waited and ran on its log entry, the last hour's statistics per type in a Stats
  tab of the Network Manager, and a stats prompt command.
• One server config for the engine's balance, jstech-balance.toml: the disk latencies, the waiting
  timeout, the priority aging period, the Subframe share and the orphan expiry, clamped on load.
• A registry of Operation types and lifecycle events on the core's event bus, for mods that follow or drive
  the network's work.
• A README for the series and one per mod, and a page on the interface components the programs are built
  from.

Changed

• Every desktop program and dialog draws from one set of interface components; the desktop's error dialog
  is one of them.
• Subframes lend their share of capacity and their GPUs' queues to the Mainframe orchestrating them.
• A REINDEX reads the disks on its tick and rebuilds the catalog off it; a craft request is listed as
  pending while its plan is made off the tick.
• Saved Operations left unresumed for longer than the orphan expiry are discarded on reload instead of
  resumed.
• The server config jsc-server.toml is replaced by jstech-balance.toml.

Fixed

• A pull into a computer that was broken mid-transfer no longer keeps taking items out of the network.

J's Computronics 0.1.0a

The first numbered version. Everything before it was the unversioned groundwork of the 0.0.x line.
The mod is in alpha: computing is the only module, and it is still growing.

Added

• Hardware eras (Vintage, Legacy, Standard) for computers, monitors and drives, with 3D cabinets for
  the mainframes, the server racks and the USB flash drive.
• Removable media (floppies, CDs, DVDs and USB sticks), the drives that read them, and install media
  for systems and programs; This PC installs a program straight from an inserted disc.
• The Frames desktops (95, XP and 11), Linux systems with a boot manager, dual boot, package managers
  and three desktop environments, and the programs that ship with them: Command Prompt, Files, Editor,
  This PC, Settings, System Monitor, Calculator, Network Manager and the Network Interactor; the
  Crafting Manager, the Craft Planner, Storage Insights, the Automation Manager and Minesweeper install
  from their own media.
• Servers that mount in racks, one rack per era, the Supercomputer rack on its HPC fabric, and the
  Cluster Management Computer with its Cluster Manager program.
• Drive contents kept as storage volumes in their own save data, with disks sized by era.
• Machine autocrafting: the Crafting Computer, the crafting cable and switch, input, output and
  receiving buses, machine patterns, multi-stage recipes, parallel stages and crafting-card threads.
• Chemicals and fluids as network data, carried by the buses; Mekanism machines and the Fusion Reactor
  can be fed and driven through the network, including D-T fuel made from network gases.
• Crafting from the command line and from IQL through the same planner the graphical terminal uses.
• The Pattern Studio, where recipes are authored on the computer, and the Pattern Encoder, one per
  era, which burns them onto media.
• JEI: the ingredient list sits beside every monitor screen, and a recipe transfers into the Pattern
  Studio's bench or machine draft.
• Every system and program is credited to its software house, and tooltips colour their era.
• A contribution policy for automated tooling and a public documentation folder.

Changed

• Requires NeoForge 21.1.248 or newer.

Fixed

• The idle tick cost of big bases and the autosave freeze their drives caused.
• Desktop windows stay current after a restore.
• The Crafting Manager sees a disc inserted after its window opened.
• Breaking a drive that still holds a disc removes the drive.
• A rack server's desktop no longer crashes the monitor before the rack's era has reached the client.

J's Computronics 0.0.10a

Alpha archive. The last build of the 0.0.x line, with the datacenter topology, network fluids and failover. The 0.0.5a jar, built between 0.0.1a and this one from a tree that was never committed, is attached here as well.

J's Computronics 0.0.1a

Alpha archive. The first build with the Monitor terminal and the operating-system screens, kept for the record; everything before 0.1.0a is the unversioned 0.0.x line.