A Software Engineering Symbol

Harrison Ainsworth

http://www.hxa.name/articles/

2009-01-25

Summary

A symbol for software engineering, evolved from the hacker emblem. It is very easy to draw, portable, adaptable, and uniquely expresses the nature of software. (350 words)

Definition

It is not a normal logo. It has an abstract definition: eight bits (as ‘0’ or ‘1’ characters), in a 4-connected structure (each element must be above/below/right/left at least one other). This gives various forms in a minimal pattern. Here are four examples:

   001     1 10
   1 1    0010
   011       0

   10         1
    1       1001
   011    010
    00

(If rendered directly in text, it requires a monospace font.)

It signifies: a respect for, an affiliation with, the extraordinary and fascinating thing that is ‘software’; and interest in producing it technically well-structured in an organised and effective way. Or maybe just: Built on Software!

Explanation

The hacker emblem

The idea is inspired by and builds on the hacker emblem: http://www.catb.org/hacker-emblem/ – re-using and extending it, in the spirit of open software development. It retains (implicitly) an underlying 2D grid, changes cells to bit characters, fixes their count to eight, and abstracts the arrangement to a general 4-connected structure.

The meaning is complementary to the hacker emblem, or rather a subset or intersection of it.

Rationale

  • Based on fundamental units: bit and byte.
  • Abstract and mutable, reflecting the protean nature of software.
  • Represents building things from simple modular pieces.
  • Implicitly contains a graph/network structure hinting at data communication.
  • Makeable with a text-editor, so echoing the basic tool of software.

It is graphically a little weak, but that is appropriate. It deliberately bends graphical rules for the particular purpose: It is like the internal structure of a logo, the abstraction of a logo, rather than a logo itself. So, it suits software engineering: it expresses something that is hidden from normal view, but familiar to those understanding the technicalities.

Usage

The symbol idea/concept/design/etc. is intended to be free – usable/copyable without restriction (being so abstract, could it even be covered by copyright?).

The ‘reference implementation’ is the above examples, in ASCII plain-text and monospace font. But variety according to the definition is good.

Generator

(JavaScript by MAW)

Code

Here is a simple command-line tool to generate the symbol, in Lua 5.1 (and according to UNLICENSE).

download:`http://www.hxa.name/tools/sesgen.lua`

-- Implementation description.
--
-- Data structure: a sparse 2D array, as a hash-table keyed by coords -- this
-- can hold the cells and allow then to take any form.
--
-- Algorithm: start with one cell, grow 7 more cells, then transcribe the cells
-- into a string. Grow by finding all unoccupied positions adjacent to occupied
-- cells and choosing one.




-- data structure primitive operations -----------------------------------------

function init()

   return { [coordToKey(0, 0)] = makeValue() }

end


function makeValue()

   -- good enough randomness for this purpose
   return math.random( 0, 1 )

end


function coordToKey( x, y )

   -- (carefully avoid -0)
   return "" .. (x == 0 and 0 or x) .. " " .. y

end


function keyToCoord( key )

   return string.match( key, "(%S+) (%S+)" )

end




-- algorithmic parts -----------------------------------------------------------

-- cells -> undefined (cells mutator)
--
function grow( cells )

   -- make set of potential cells valid to grow into
   local potentials = {}
   local count      = 0
   -- step through all cells
   for key, _ in pairs(cells) do
      local x, y = keyToCoord( key )

      -- look left, right, below, above
      for a = 0, 1 do
         for b = -1, 1, 2 do
            local adjacent = coordToKey( x + (a * b), y + ((1-a) * b) )
            -- include if not already occupied in cells
            if not (cells[adjacent] or potentials[adjacent]) then
               potentials[ adjacent ] = true
               count = count + 1
            end
         end
      end

   end

   -- choose a potential cell
   local newKey = ""
   do
      local index = math.random( count )
      -- step through until chosen index
      for key, _ in pairs(potentials) do
         if 1 == index then
            newKey = key
            break
         end
         index = index - 1
      end
   end

   -- make actual cell
   cells[ newKey ] = makeValue()

end


-- cells -> string
--
function output( cells )

   -- get cells rectangular bound
   local min = { x= 0, y= 0 }
   local max = { x= 0, y= 0 }
   for key, _ in pairs(cells) do
      local x, y = keyToCoord( key )
      min.x, min.y = math.min( min.x, x ), math.min( min.y, y )
      max.x, max.y = math.max( max.x, x ), math.max( max.y, y )
   end

   -- transcribe cells into a block of chars
   local str = ""
   for y = min.y, max.y do
      for x = min.x, max.x do
         local cell = cells[ coordToKey(x, y) ]
         str = str .. (cell and cell or " ")
      end
      str = str .. "\n"
   end

   return "\n" .. str

end




-- execution control -----------------------------------------------------------

-- check if help message needed
if (arg[1] == "-?") or (arg[1] == "--help") then

   -- print help message
   print("\n" ..
      "  Software Engineering Symbol Generator\n" ..
      "  Harrison Ainsworth / HXA7241 : 2011-01-26\n" ..
      "\n" ..
      "Run with no arguments to generate an instance of the\n" ..
      "'software engineering symbol' -- eight bits in a four-connected\n" ..
      "structure. See:\n" ..
      "  http://www.hxa.name/articles/content/software-engineering-symbol_\n" ..
      "    hxa7241_2009.html\n" ..
      "\n" ..
      "License: http://unlicense.org/UNLICENSE\n" )

-- execute
else

   -- make non-deterministic
   math.randomseed( math.floor(os.time()) )

   -- make the first cell
   cells = init()

   -- grow another 7 cells
   for i = 1, 7 do
      grow( cells )
   end

   -- print the complete thing
   print( output( cells ) )

end

Metadata

(TXON)

DC:`
   title:`A Software Engineering Symbol`
   creator:`Harrison Ainsworth`

   date:`2011-02-18`
   date:`2009-01-25`

   description:`A symbol for software engineering, evolved from the hacker emblem.`
   subject:`logos, visual identity, software engineering, programming`

   language:`en-GB`
   type:`article`
   relation:`http://www.hxa.name/`
   identifier:`http://www.hxa.name/articles/content/software-engineering-symbol_hxa7241_2009.html`
   rights:`Creative Commons BY-SA 3.0 License`
`