JIT programming
Power& tradition holding back progress Contents Overcome reactionaries

JIT programming

Summary
This presentation applies just-in-time methods to computer programming with analysis based on complex adaptive system (CAS) theory. 
Introduction
Have you ever wondered what Just in time (JIT) means when applied to software engineering?  This presentation:
  • Outlines some problems(p.4) induced by the historical process used to develop computer software
  • Describes how analogous problems in manufacturing were overcome by the application of Just in time(p.6) methods
  • Outlines the core techniques(p.7) of Just in time including its leverage of total engagement of personnel
  • Current improvements in computer systems(p.9) are framed with JIT methodology
  • Opportunities and challenges(p.11) to introducing these same techniques in software development are then reviewed

- next page -> (1 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
rhlcontents


<- previous page - - next page -> (2 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
Just in time (JIT) methodology improved quality and reduced waste in JIT manufacturing(p.6)

The lessons can be used to improve the quality of software development

Situation:
  • Computer hardware standardized on implementing a Turing machine using von Neumann's architecture
  • Computer software targeted the von Neumann hardware platforms 
    • Instructions are fetched sequentially from memory to be executed by the processor unless the instruction is a jump
  • Sequential instruction programming methodology was adopted generally to produce code which is easy to write and understand
    • Code fragment 'if x then y else z' is processed in sequence by the computer with a conditional jump to fetch instruction z
    • Sequential instruction programming is used for most applications
    • Event queues and scheduling provide limited parallelism
  • Large software applications were still found to be hard to understand maintain or change - too complex
  • Modularity provided a method for structuring programs to reduce code and testing complexity
    • Eg general sort routine has algorithm, inputs and output form specified so its operation can be
      • Discretely validated and verified
      • Replaced by alternative implementations that conform to the interfaces and algorithm
  • Object orientation was adopted to introduce goals, improve reuse and add support for modularity directly in the compilation tools




<- previous page - - next page -> (3 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
The software development problem:

Software development has a problem - its applications are inflexible, of limited quality, have no inbuilt capacity to learn about and explore their environments, it provides limited support for emergence and it is wasteful
  • Programmers still write software programs as instruction sequences
    • Goals of development are only indirectly represented in the implementation 
    • The programming methodology typically uses procedures with parameters  
      • Parameters undermine emergent reuse of software
    • Typing schemes aim to support correct deployment of the procedure hierarchy
      • Typing undermines emergence and exploration of the programs environment
    • Phenomena are not represented in the programming methodology
  • Requirements, specification, design and operation activities are discrete processes
    • Frequently the source instructions become the only accurate specification and design reference
  • Any change to the software's requirements will need programmers to make equivalent changes to the source code
    • Software is not designed to respond adaptively to any situation
      • My source editor is task specific and reflects the structure of the whole tool chain
  • The runtime code is brittle
    • My Firefox browser fails to restart a previously aborted session
  • Software engineers must provide adaptations but typically have limited visibility of the users operations
    • My friend wonders why her Skype service is not running.  Eventually she reboots her PC in frustration.  The responsible Microsoft engineers are unaware of her problems


<- previous page - - next page -> (4 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
The problem (continued):
  • Designers are required to successfully transform requirements into operational software
    • Top down functional design transforms requirements into specialized data structures and pre-specified instruction flows
      • Knuth's famous book 'Algorithms + Data structures = programs'
      • Need for a programmer to adjust the data structures to extend the program raised the cost of reuse
      • Event services must be explicitly deployed with care taken to avoid deadlocks
    • Alternatively Object orientation packages the data and algorithms into objects
      • Object encapsulation makes the representation invisible from outside the object
      • Designer must decide how to decompose a system into objects
      • Object design patterns support the designer in selecting appropriate objects
        • Application object decomposition still designed specifically for each situation
        • Designer still decides at design time what scenarios are covered and how they are represented and processed
        • Events framed as messages between objects
      • Limited goal action separation is supported through virtual functions and inheritance
  • There is little transparency of when instruction flows are inappropriate to the situation they are operating in
    • Learning(p.15) from problems and potential improvements is not supported by the runtime code
  • Sequential software coding paradigm is brittle, and limits flexibility
    • Parallel code operations can facilitate combining alternative strategic approaches

JIT effectively addressed these same problems in manufacturing transforming quality and eliminating waste


<- previous page - - next page -> (5 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
Introduction to Just in time (JIT) manufacturing methodology
  • JIT was developed to improve flexibility, quality, and reduce waste in manufacturing
  • Removed errors, reduced transportation, stock and waiting times
  • Involved and empowered all employees
  • Encouraged iterative design
  • Cross functional participation helped enrich the perceptions applied in design for manufacture
  • Views manufacturing operation as a network of process and operational flows
    • Operations add value by transforming inputs into desired outputs - non JIT manufacturing focused on operations aiming to
      • Reduce labor costs
      • Automate
    • Processes link the operations together and add no value so JIT aims to minimize them - JIT studies process flows and aims to
      • Restructure to maximize effectiveness of linked operations
      • Reduce the costs of the processes


<- previous page - - next page -> (6 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
JIT core techniques
To improve flexibility and quality JIT:
  • Involves all personnel (agents(p.16)), aligns goals, trains them and then benefits from and responds to insights
  • Encourages a focus on a limited set of outputs
  • Continuously reduces processes
  • Designs iteratively for manufacture and demand
  • Prefers 'small machines' - low capital, little risk if specialize to key flows
  • Prophylactically fix processes
  • Reduce setup
  • Align product mix with layout and flows


<- previous page - - next page -> (7 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
JIT core techniques
To reduce waste JIT:
  • Iteratively improves visibility
  • Reduces inventory
  • Keep operations steadily moving
    • Negative feedback sustains steady flows
    • Redundant capacity is accepted as essential to sustain flows
  • Improves processes
  • Improves scheduling with demand push and final assembly pull (Kanban)
    • Reduce batch sizes
    • Associate flow step with transaction (Kanban card)
    • Operator detected issues stop the flow
      • No detected error is moved on
    • Cells in final assembly can allow a general operation/supplies to specialize late
  • Integrate suppliers


<- previous page - - next page -> (8 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
Programming has successfully integrated a number of JIT techniques to improve flexibility and quality:
  • Open standards processes and open source software allows alignment of goals, and benefits from and responds to insights and source code recombination
  • Facebook, LinkedIn, Amazon, smart phones, tablets and personal computers allow everyone to easily integrate their views
  • Internet and WWW have reduced the cost and delays in finding and connecting services with users 
  • Cloud based services allow scale economized dynamic allocation of operational resources to correspond with demand
  • Computers became 'small machines' allowing with low overhead
    • User's mobile access and personalized interactions with distributed services
    • Developers to compile batches of one 
  • Open source bug tracking can include root cause details
    • The fix can then be applied where ever the root cause exists - up stream distributions of the source
    • The source and bug tracker become the default representation of current state


<- previous page - - next page -> (9 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
Programming has successfully integrated a number of JIT techniques to reduce waste:
  • Open source leverages network connected inspection of source code and updates via source control repositories
  • Inclusive program based organizations allow developers to be linked to integrators, operators and users
  • Over provisioned networks, and server farms ensure users requests flow predictably
  • Batch operations could be augmented with case id
  • Batch programming was augmented with transaction services: 
    • Batch sizes reduced
    • Interleaves transactions, linked by transaction id
    • Transaction environment is validated by business logic
  • Dynamic web pages respond to a request with final assembly and then browser based styling
  • Amazon fulfillment leverages small batches distributed by transaction supported parcel post
  • Each issue must be interpreted and the program source be updated with appropriate changes
  • Risk analysis is used to identify key aspects of the software operations to test


<- previous page - - next page -> (10 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
Current software architecture undermines key aspects of JIT:
  • JIT improves quality and flexibility and reduces waste through its focus on
    • People and aligning their training, and goals
    • Supporting operations by improving the processes they fit within and lowering the process costs
    • Simplifying the upstream network so that it is predictable and changeable
  • Whereas in software development
    • Key operational decisions are performed by instructions, not agents
    • Errors in instruction flow are only indicated to operators and users by unexpected behavior, error messages or crashes
    • Software structure: specialized data structures and sequential coded algorithms limits self-test
    • Typical software product lifecycle represents a necessary complex adaptive system (CAS) network of business and technology focused agents
  • Alternative of agents matches the strategy of including all operatives within the JIT
    • Provides sensors, enables modeling and actions as instructed by schematic structures
    • Uses common data representations allowing self-testing
    • Improves based on retained high value schematic structures


<- previous page - - next page -> (11 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
Program state representation is hard for users and operators to understand
  • JIT manufacturing state is represented by
    • Simple Kanban cards and
    • Operational situation within the JIT assembly line
      • Is well understood by operators
  • Both current and agent-based software strategies are difficult to view and interpret
    • Traditional software integrates state representations with its specific data structures and instruction counter
    • Bug tracking struggles to represent the shifts in significance of a problem over time 
      • Users may raise a problem report and then loose interest having replaced the application or adopted an alternative strategy
    • Agent-based software represents state in epi-genetic structures
      • Complex environments require network representations


<- previous page - - next page -> (12 of 13)
 

Power& tradition holding back progress Contents Overcome reactionaries
Agent-based software architectures have the potential to model their behavior and learn from problems
  • Use of goals telling agents what must be done rather than how to do it enables flexible problem solving
  • Inclusion of this key aspect of JIT should improve the quality and flexibility of software based systems

 


<- previous page - (13)
 

Power& tradition holding back progress Contents Overcome reactionaries
Backup slides follow

- next page -> (backup 14 of 16)
 

Power& tradition holding back progress Contents Overcome reactionaries
Shewhart cycles: Walter Shewhart advocated the use of iterative cycles of: Planning, Doing, Checking and Acting to fix issues (PDCA)
  PDCA cycle emerges naturally in complex adaptive systems
  • Examples include the cell cycle, cell death programme, cell growth programme, Just-In-Time manufacturing
  • Plans in an adaptive system are schematic structures
    • Associated with current environmental state indirectly through modeling
    • Models generate predictions of results of performing each strategy
  • Performing, or 'do'ing, a highly valued strategy will result in some change of state of the agent(p.16) and its environment
  • Agent can compare (check) the result against the models prediction
    • Human agents evolved strategies often avoid checking so a required process supports the formation of the habit
  • If reality differs from the prediction the valuation of the strategy can be adjusted


<- previous page - - next page -> (backup 15 of 16)
 

Power& tradition holding back progress Contents Overcome reactionaries
Agents: schematic aggregates generating action
Agents are emergent aggregations of catalysts.  The aggregations are formed schematically associating programmed control of catalytic actions with different goals and events
  • Agents - association between goals and actions.  They
  • Perform actions (1) by focusing fundamental physical forces, marshaled as accessible stored energylogical agent
  • Respond to
    • Signals from their environment (2)
    • Other agents
    • Their own state (3)
    • From this aggregation goals emerge
  • Constructed from active structures formed from re-combinable building blocks 
  • Utilize a schematic plan (4) to indirectly associate the signals with actions
  • Invoked under operon control
  • Form emergently


<- previous page - (backup 16)