## NOOL 2015

I know there are some secret and not so secret object lovers here, so this workshop might be of interest. In particular, I think OO research needs a big kick in the butt: objects are still quite useful but our entrenched OO languages and systems leave much to be desired, it is up to the research community (as well as enlightened practitioners) to show the world that there is hope in objects yet! Info:

The 0th Workshop on New Object-Oriented Languages (NOOL) 2015

NOOL-15 is a new unsponsored workshop to bring together users and implementors of new(ish) object oriented systems. Through presentations, and panel discussions, as well as demonstrations, and video and audiotapes, NOOL-15 will provide a forum for sharing experience and knowledge among experts and novices alike.

## Aggregations (e.g., sets) in Logic Programs

Prolog and its derivatives have lacked adequate ways to compute with aggregations, e.g., sets.

For example, suppose there is a ground-complete predicate Link[aNode, anotherNode, aCost]
that is true exactly when there is a path from aNode to anotherNode with aCost.

When ⊩ Path[aNode, aNode, aCost]→ // when a goal is set for a cost between aNode and itself
⊢ aCost=0▮           // assert that the cost from a node to itself is 0



The following goal-driven Logic Program works forward from start to find the cost to finish:


When ⊩ Path[start, finish, aCost]→
⊢ aCost=Minimum {nextCost + remainingCost
| ⊨ Link[start, next≠start, nextCost], Path[next, finish, remainingCost]}▮
// a cost from start to finish is the minimum of the set of the sum of the
// cost for the next node after start and
// the cost from that node to finish


The following goal-driven Logic Program works backward from finish to find the cost from start:

When ⊩ Path[start, finish, aCost]→
⊢ aCost=Minimum {remainingCost + previousCost
|⊨ Link[previous≠finish, finish, previousCost], Path[start, previous, remainingCost]}▮
// the cost from start to finish is the minimum of the set of the sum of the
// cost for the previous node before finish and
// the cost from start to that Node


Note that the above Logic Programs work together concurrently providing information to each other.

## adopt convention to define local sense of word in footnote?

I wonder whether we can develop a few simple conventions that clarify what we mean by words when we use them, so a single post has fewer ambiguities, and so we might edit a post later for clarification without substantially altering the original post. The idea would be to define the sense of a specific word used in a post. I'll give an example below, involving channel, since that was the word motivating this train of though. But first I'll expand a bit on my general point.

A word can mean something very specific, or very general, often with both a technical computing sense as well as plain English language sense. In particular, a technical sense often shadows the plain language sense, as if technical meanings have closer lexical scope, so you can't use a more general sense by default unless a reader is forgiving. Sometimes I mean both: a specific technical sense and the general idea too, at the same time, because I expect a reader to bind to as many as works, as if executing a search query on a word database (e.g. all the meanings of channel that work here, for example).

A realistic way to approach the problem is to use footnote format, appending a postscript paragraph to a post that explores the sense of a word used, like a dictionary entry, but biased toward exactly what was intended locally in the current post. The first time channel appears it might be shown in italics, with a paragraph at the end repeating the word again in italics, along with a local clarification of the scope of word meaning as used in the original post.

(An unrealistic but funny way to approach the problem is with new text styles, so the way a word is highlighted might imply whether intended meaning is specific or very general, with the latter especially useful when a word has a narrow technical sense.)

channel - means of getting something to occur: a knob to read and/or write an interface to access data or controls, encompassing things as different as dereferencing a variable, accessing an array member, reading or writing streams, calling functions, or using a datatype named "channel" in a language or computing system.

## PLATEAU 2015 - Call for Papers

---------------------------------------------------------------------------
6th Workshop on the Evaluation and Usability of Programming Languages and Tools (PLATEAU)

Co-located with SPLASH 2015
Pittsburgh, PA, USA

CALL FOR PAPERS

Programming languages exist to enable programmers to develop software
effectively. But how efficiently programmers can write software
depends on the usability of the languages and tools that they develop
with. The aim of this workshop is to discuss methods, metrics and
techniques for evaluating the usability of languages and language
tools. The supposed benefits of such languages and tools cover a large
space, including making programs easier to read, write, and maintain;
allowing programmers to write more flexible and powerful programs;
and restricting programs to make them more safe and secure.

PLATEAU gathers the intersection of researchers in the programming
language, programming tool, and human-computer interaction communities
to share their research and discuss the future of evaluation and
usability of programming languages and tools.

TOPICS

Some particular areas of interest are:

- empirical studies of programming languages
- methodologies and philosophies behind language and tool evaluation
- software design metrics and their relations to the underlying language
- user studies of language features and software engineering tools
- visual techniques for understanding programming languages
- critical comparisons of programming paradigms
- tools to support evaluating programming languages
- psychology of programming
- domain specific language (e.g. database languages, security/privacy
languages, architecture description languages) usability and evaluation

SUBMISSIONS

PLATEAU encourages submissions of three types of papers:

Research and Position papers: We encourage papers that describe
work-in-progress or recently completed work based on the themes
and goals of the workshop or related topics, report on experiences
gained, question accepted wisdom, raise challenging open problems,
or propose speculative new approaches. We will accept two types of
papers: research papers up to 8 pages in length; and position papers
up to 2 pages in length.

Hypotheses papers: Hypotheses papers explicitly identify beliefs of
the research community or software industry about how a programming
language, programming language feature, or programming language tool
affects programming practice. Hypotheses can be collected from mailing
lists, blog posts, paper introductions, developer forums, or
interviews. Papers should clearly document the source(s) of each
hypothesis and discuss the importance, use, and relevance of the
hypotheses on research or practice. In addition, we invite language
designers to share some of the usability reasoning that influenced
their work. These will serve as an important first step in advancing
our understanding of how language design supports programmers.Papers
may also, but are not required to, review evidence for or against the
hypotheses identified. Hypotheses papers can be up to 4 pages in
length.

Format: Submissions should use the SIGPLAN Proceedings Format, 10
point font. Note that by default the SIGPLAN Proceedings Format
produces papers in 9 point font. If you are formatting your paper
using LaTeX, you will need to set the 10pt option in the
\documentclass command. If you are formatting your paper using Word,
you may wish to use the provided Word template that supports this font
preprint option in the LaTeX \documentclass command generates page
printed on a black and white printer. In particular, please check that
colors remain distinct and font sizes are legible.

All types of papers will be published in the ACM Digital Library at
the authors’ discretion.

Paper Format: http://www.sigplan.org/Resources/Author/
Submission site: https://easychair.org/conferences/?conf=plateau2015

KEYNOTE

Mary Beth Rosson
Professor at Penn State
College of Information Sciences and Technology
Pennsylvania, USA

IMPORTANT DATES

PROGRAM COMMITTEE
Andrew Begel, Microsoft Research, USA
Jeff Carver, University of Alabama, USA
Ronald Garcia, University of British Columbia, Canada
Stefan Hanenberg, University of Duisburg-Essen, Germany
Stephen Kell, University of Cambridge, UK
Brad Myers, Carnegie Mellon University, USA
James Noble, Victoria University of Wellington, New Zealand
Chris Parnin, North Carolina State University, USA
Romain Robbes, University of Chile, Chile
Janet Siegmund, University of Passau, Germany
Andreas Stefik, University of Nevada, Las Vegas, USA

ORGANIZERS
Craig Anslow, Middlesex University, UK
Thomas LaToza, George Mason University, USA
Joshua Sunshine, Carnegie Mellon University, USA
---------------------------------------------------------------------------

## Are Actors a Good Model for Computation.

Actors seem to allow messages to be recieved in a different order from which they were sent. This sounds a lot like the problems with simultaneity that occur with relativity, effectively messages may take different paths from sender to receiver.

Being an electronics engineer as well as a software developer, the actor model sounds a lot like an asynchronous circuit, which are really difficult to design so they work properly. There is a reason why synchronous design dominates computer architecture, and even this is hard to get right. In synchronous design all messages sent are received at the next clock tick, messages form a stream over pipes. Even so when designing chips we often build a model in 'C' to test the chip against because its so much easier to get sequential code correct.

The ideal solution is to take sequential code like 'C' and compile it to a parallel implementation. The reason, from experience, is that humans are just not good at parallel design. This is even more true of asynchronous design compared to synchronous design.

I am not disputing that actors model communicating processes running on different nodes of a distributed network well. My concern is more that this architecture is only used for very regular problems where a common kernel (or a few different node types as in a map/reduce machine) are distributed because it is difficult to program this way.

Are actors a good model for general computation, or should they only be used when necessary (and when might it be necessary)?

## Implementing the communication semantics of actors

It would be interesting to see an implementation of the actor semantics for communication and concurrency. Personally I would like to see a description of the execution flow that is concrete enough to show any similarities and differences from other models. There have been some threads on LtU that have languished on these details. Generally it appears (to me, at least) that there is an interest in seeing a description detailed enough that it could serve as the basis of an implementation.

In particular, if I squint a little at the SimpleCounter example (which sadly I cannot cut and paste here directly) then I see a FSM with access to an RNG, a timer, and a message queue. In previous discussions (from memory) I believe that Carl has stated several times that there is no queue. It seems a little unclear exactly what kind of RNG would be used, with respect to fairness and justice. In order to examine the semantics of the message passing and execution flow within an actor - that is erase all value computations and look only at an abstract model of concurrency and communication - then I would sketch out the following as a starting point:

Each actor is a set of message handlers and a set of incoming messages.

• To send a message is an asynchronous operation - add the message to the target message set.

• To start a computation is a synchronous operation - fire the asynchronous message and start a timer.

The execution of an actor proceed locally as is a series of steps in which either:

• A timer has expired and a synchronous computation propagates failure instead of receiving a value.

• Pick a random message from the set and process it.
• If the message handler returns a value then fire it back as an asynchronous message.

From this starting point I would then ask:

• Is this an accurate description - are these true statements about how the system behaves, and where they are not how does the system differ in behaviour?
• Is this a complete description - where are the holes in this description that allow a diverge from the behaviour of actors?

## Functor

Functor Group AB, with its subsidiaries Functor AB and Functor Consulting AB, is a spin-off company, founded in early 2011, from Uppsala University, KTH, Stockholm University, University of Cambridge and Oxford University. Functor offers a new combined static analysis and hybrid testing tool and method (over 50% of bugs in C code can prevented) and a meta language modelling tool for domain engineering and DSL programming. Functor unleashes the next programming paradigm (STEW 2012) with zero learning curve.

Anyone know what this company is about? I see two products, Prevent and Scalor, some mentioning of C, Ocaml, Haskell, LLVM. But little detail.

Note: You can run one of their tools, Prevent, on a github project.

## Moderation on LtU

I thought more about the issue of moderation of LtU. I think a reasonable compromise would be to let me moderate the topics I created myself -- this means mostly removing posts I find insulting or otherwise unfit for a polite, constructive discussion. This is both less work than trying to moderate a whole website, less opportunities for making bad choices (those that strongly dislike moderation can think of it as restricted damage), and it makes a kind of sense (if you think of LtU as a distributed blog, as it purported to be at the beginning, letting authors moderate their own blog posts is something reasonable).

Would the LtU community agree with this compromise?
(If so, I can try to find what are the technical buttons that need to be pushed to provide a Drupal-98 moderation interface.)

## "Prep" in programming languages

"Prep" is a neglected topic in programming languages. Consider the following example of unbounded nondeterminism:

CreateUnbounded.[ ]:Integer ≡
Let aCounter ←  SimpleCounter.[ ]｡    // let aCounter be a new Counter
Prep □aCounter.go[ ]｡  // send aCounter a go message and concurrently
□aCounter.stop[ ]▮ // return the result of sending aCounter a stop message


CreateUnbounded.[ ] is an unbounded integer.

As a notational convenience, when an Actor receives message then it can send an arbitrary message to itself by prefixing it with “..” as in the following example:

Actor SimpleCounter[ ]
count ≔ 0,   // the variable count is initially 0
continue ≔ True｡
implements Counter using
stop[ ] →
count  // return count
afterward continue ≔ False¶ // continue is updated to False for the next message received
go[ ] →
continue �
True ⦂ Prep count ≔ count+1⚫｡    // increment count
hole ..go[ ] ⍌  // In a hole of the cheese, send go[ ] to this counter
False ⦂ Void▮  // if continue is False, return Void

Interface Counter with
stop[ ] ↦ Integer,
go[] ↦ Void▮



## SPLASH 2015 - Workshops Combined Call for Papers

/************************************************************************************/
ACM Conference on Systems, Programming, Languages, and Applications:
Software for Humanity (SPLASH'15)

Pittsburgh, Pennsylvania, USA
25th-30th October, 2015

/************************************************************************************/
CALL FOR WORKSHOP PAPERS AND PARTICIPATION

/************************************************************************************/

SPLASH'15 workshops address a rich variety of well-known and newly emerging research areas and provide a creative and collaborative environment to discuss and solve challenge problems with attendees from industry and research organizations from all over the world. Submission deadlines vary from workshop to workshop. Some workshops will be published in the ACM Digital Library. The current SPLASH'15 workshops program is listed below and the abstracts at the end.

**************************************************************

CURRENT WORKSHOP PROGRAM

AGERE! - Workshop on Programming based on Actors, Agents, and Decentralized Control
http://2015.splashcon.org/track/agere2015
Abstracts: August 1, 2015,
Submissions: August 7, 2015,
Position/work-in-progress Papers and Demos: September 7, 2015

DSM - Workshop on Domain-Specific Modeling
http://2015.splashcon.org/track/dsm2015
Submissions: August 7, 2015

ETX - Eclipse Technology eXchange Workshop
http://2015.splashcon.org/track/etx2015
Paper Registration: July 31, 2015
Submissions: August 7, 2015

FPW - Future Programming Workshop
http://2015.splashcon.org/track/fpw2015
Submissions: August 7, 2015

MobileDeLi - Workshop on Mobile Development Lifecycle
http://2015.splashcon.org/track/mobiledeli2015
Submissions: August 7, 2015

PLATEAU – Workshop on Evaluation and Usability of Programming Languages and Tools
http://2015.splashcon.org/track/plateau2015
Submissions: August 7, 2015

PROMOTO – Workshop on Programming for Mobile and Touch
http://2015.splashcon.org/track/promoto2015
Submissions: August 7, 2015

Parsing@SLE - Workshop on Parsing Programming Languages
http://2015.splashcon.org/track/ParsingAtSLE2015
Submissions: August 7, 2015

REBLS - Workshop on Reactive and Event-based Languages & Systems
http://2015.splashcon.org/track/rebls2015
Submissions: August 7, 2015

SEPS - Workshop on Software Engineering for Parallel Systems
http://2015.splashcon.org/track/seps2015
Submissions: August 7, 2015

SMART - Smart Software Strategies
http://conf.researchr.org/track/SmartSoftwareStrategies2015/SmartSoftwareStrategies2015
Submissions: October 2, 2015

WODA - Workshop on Dynamic Analysis
http://2015.splashcon.org/track/woda2015
Submissions: August 7, 2015

**************************************************************
ANNEX: WORKSHOP ABSTRACTS AND DATES
**************************************************************
AGERE! 5th International Workshop on Programming based on Actors, Agents, and Decentralized Control
http://2015.splashcon.org/track/agere2015

Abstracts: August 1, 2015
Submissions: August 7, 2015
Position/work-in-progress Papers and Demos: September 7, 2015

- Organizers:
Elisa Gonzalez Boix, Vrije Universiteit Brussel, Belgium
Philipp Haller, KTH Royal Institute of Technology, Sweden
Alessandro Ricci, University of Bologna, Italy
Carlos Varela, Rensselaer Polytechnic Institute

- Abstract:
The AGERE! workshop is aimed at focusing on programming systems, languages and applications based on actors, active/concurrent objects, agents and – more generally – high-level programming paradigms promoting a mindset of decentralized control in solving problems and developing software. The workshop is designed to cover both the theory and the practice of design and programming, bringing together researchers working on models, languages and technologies, and practitioners developing real-world systems and applications.

**************************************************************
DSM - Domain-Specific Modeling workshop
http://2015.splashcon.org/track/dsm2015

Submissions: August 7, 2015

- Organizers:
Jeff Gray, University of Alabama, USA
Jonathan Sprinkle, University of Arizona, USA
Juha-Pekka Tolvanen, MetaCase, Finland
Matti Rossi, Aalto University School of Economics, Finland

- Abstract:
Domain-specific languages provide a viable and time-tested solution for continuing to raise the level of abstraction, and thus productivity, beyond coding, making systems development faster and easier. When accompanied with suitable automated modeling tools and generators it delivers to the promises of continuous delivery and devops. In Domain-Specific Modeling (DSM) the models are constructed using concepts that represent things in the application domain, not concepts of a given programming language. The modeling language follows the domain abstractions and semantics, allowing developers to perceive themselves as working directly with domain concepts. Together with frameworks and platforms, DSM can automate a large portion of software production. This automation is possible because of domain-specificity: both the modeling language and code generators fit to the requirements of a narrowly defined domain, often inside one organization only.

**************************************************************
ETX - Eclipse Technology eXchange Workshop
http://2015.splashcon.org/track/etx2015

Abstracts: July 31, 2015
Submissions: August 7, 2015

- Organizers:
Tim Verbelen, Ghent University - iMinds, Belgium
Michael Burke, Rice University, USA

- Abstract:
The Eclipse platform (http://www.eclipse.org) was originally designed for building integrated development environments for object-oriented applications. Over the years it has developed into a vibrant ecosystem of platforms, toolkits, libraries, modeling frameworks, and tools that support various languages and programming styles. The goal of the ETX workshop is to bring together researchers and practitioners to exchange ideas about potential new uses of Eclipse and how Eclipse technology can be leveraged, improved, and/or extended for research and education. After successful editions of the ETX workshop in 2003-2007, we revived the ETX workshop in 2014 and are now up for another edition. ETX 2015 invites original and unpublished contributions about potential new uses of Eclipse and how Eclipse technology can be leveraged, improved, and/or extended for research and education.

**************************************************************
FPW - Future Programming Workshop
http://2015.splashcon.org/track/fpw2015

Submissions: August 7, 2015

- Organizers:
Jonathan Edwards, MIT CSAIL, USA
Richard Gabriel, IBM Research, USA
Alex Payne, Emerging Languages Camp, USA

- Abstract:
The Future Programming Workshop (FPW) invites ambitious visions, new approaches, and early-stage work of all kinds seeking to improve software development. Participants will present their work at SPLASH in Pittsburgh and optionally at Strange Loop in St. Louis, culminating in a writers’ workshop at SPLASH. FPW fosters a supportive and inspirational community of researchers and practitioners working at the frontiers of software. We are looking for transformative ideas outside the academic and industrial mainstream - ideas with potentially large impacts on how we will build software in the future. We embrace early-stage work, when it is most in need of constructive criticism, and offer a safe and effective environment in which to receive such criticism.

**************************************************************
MobileDeLi - Workshop on Mobile Development Lifecycle
http://2015.splashcon.org/track/mobiledeli2015

Submissions: August 7, 2015

- Organizers:
Aharon Abadi, IBM Haifa Research Lab, Israel
Lori Flynn, CERT, USA
Jeff Gray, University of Alabama, USA

- Abstract:
Mobile application usage and development is experiencing exponential growth. According to Gartner, by 2016 more than 200 billion total apps will have been downloaded. The mobile domain presents new challenges to software engineering. Mobile platforms are rapidly changing, including diverse capabilities as GPS, sensors, and input modes. Applications must be omni-channel and work on all platforms.
Activated on mobile platforms, modern applications must be elastic and scale on demand according to the hardware abilities. Applications often need to support and use third-party services. Therefore, during development, security and authorization processes for the dataflow must be applied. Bring your own device (BYOD) policies bring new security data leaks challenges. Developing such applications requires suitable practices and tools e.g., architecture techniques that relate to the complexity at hand; improved refactoring tools for hybrid applications using dynamic languages and polyglot development and applications; and testing techniques for applications that run on different devices. This workshop aims at establishing a community of researchers and practitioners to share their work and lead further research in the mobile development area.

**************************************************************
PLATEAU – 6th Workshop on Evaluation and Usability of Programming Languages and Tools
http://2015.splashcon.org/track/plateau2015

Submissions: August 7, 2015

- Organizers:
Thomas LaToza, UC Irvine, USA
Joshua Sunshine, Carnegie Mellon University, USA
Craig Anslow, Middlesex University, UK

- Abstract:
Programming languages exist to enable programmers to develop software effectively. But how efficiently programmers can write software depends on the usability of the languages and tools that they develop with. The aim of this workshop is to discuss methods, metrics and techniques for evaluating the usability of languages and language tools. The supposed benefits of such languages and tools cover a large space, including making programs easier to read, write, and maintain; allowing programmers to write more flexible and powerful programs; and restricting programs to make them more safe and secure. PLATEAU gathers the intersection of researchers in the programming language, programming tool, and human-computer interaction communities to share their research and discuss the future of evaluation and usability of programming languages and tools.

**************************************************************
Parsing - Parsing@SLE 2015
http://2015.splashcon.org/track/ParsingAtSLE2015

Submissions: August 7, 2015

- Organizers:
Ali Afroozeh,
Loek Cleophas, Umea University, Sweden

- Abstract:
Parsing@SLE is a workshop on parsing programming languages, now in its third edition. The intended participants are the authors of parser generation tools and parsers for programming languages and other software languages. For the purpose of this workshop parsing’’ is a computation that takes a sequence of characters as input and produces a syntax tree or graph as output. This possibly includes tokenization using regular expressions, deriving trees using context- free grammars, and mapping to abstract syntax trees. The goal is to bring together today’s experts in the field of parsing, in order to explore open questions and possibly forge new collaborations. The topics may include algorithms, implementation and generation techniques, syntax and semantics of meta formalisms (BNF), etc.

**************************************************************
PROMOTO – 3rd Workshop on Programming for Mobile and Touch
http://2015.splashcon.org/track/promoto2015

Submissions: August 7, 2015

- Organizers:
Steven D. Fraser, Innoxec, USA
Alberto Sillitti, Center for Applied Software Engineering Bolzano, Italy

- Abstract:
Today, easy-to-use mobile devices like smartphones and tablets are becoming more prevalent than traditional PCs and laptops. New programming languages are emerging to enable programmers to develop software easily—leveraging the exciting advances in existing hardware, and providing abstractions that fit the capabilities of target platforms with multiple sensors, touch and cloud capabilities. PROMOTO brings together researchers who have been exploring new programming paradigms, embracing the new realities of always connected, touch-enabled mobile devices. PROMOTO 2015 would like to invite contributions covering technical aspects of cross-platform computing, cloud computing, social applications and security. Submissions for this event are invited in the general area of mobile and touch-oriented programming languages and programming environments, and teaching of programming for mobile devices.

**************************************************************
REBLS - Workshop on Reactive and Event-based Languages & Systems
http://2015.splashcon.org/track/rebls2015

Submissions: August 7, 2015

- Organizers:
Wolfgang De Meuter, Vrije Universiteit, Belgium
Patrick Eugster, Purdue University, USA
Lukasz Ziarek, State University of New York (SUNY) Buffalo, USA

Reactive programming and event-based programming are two closely related programming styles that are becoming ever more important with the advent of advanced HPC technology and the ever increasing requirement for our applications to run on the web or on collaborating mobile devices. A number of publications on middleware and language design — so-called reactive and event-based languages and systems (REBLS) — have already seen the light, but the field still raises several questions. For example, the interaction with mainstream language concepts is poorly understood, implementation technology is in its infancy and modularity mechanisms are almost totally lacking. Moreover, large applications are still to be developed and patterns and tools for developing reactive applications is an area that is vastly unexplored.

**************************************************************
SEPS - 2nd Workshop on Software Engineering for Parallel Systems
http://2015.splashcon.org/track/seps2015

Papers: August 7, 2015

- Organizers:
Ali Jannesari, Technical University of Darmstadt, Germany
Siegfried Benkner, University of Vienna, Austria
Xinghui Zhao, Washington State University, USA
Yukionri Sato, Tokyo Institute of Technology, Japan

- Abstract:
The increased complexity of parallel applications on modern parallel platforms (e.g. multicore/manycore, distributed or hybrid) requires more insight into development processes, and necessitates the use of advanced methods and techniques supporting developers in creating parallel applications or parallelizing and reengineering sequential legacy applications. We aim to advance the state of the art in different phases of parallel software development, covering software engineering aspects such as requirements engineering and software specification; design and implementation; program analysis, profiling and tuning; testing and debugging.

**************************************************************
SMART - Workshop on Smart Software Strategies
http://conf.researchr.org/track/SmartSoftwareStrategies2015/SmartSoftwareStrategies2015

Papers: October 2, 2015

- Organizers:
Steven D. Fraser, Independent Consultant, USA
Dennis Mancl, Alcatel-Lucent, USA
Bill Opdyke, JP Morgan Chase & Co, USA

- Abstract:
We should learn from the past – to use what we learn for the next problem. What can we learn from the experiences of Y2K? There are some lessons about software design and software maintenance that we might apply to the next wave of software and technology:

Y2K bugs: In the late 1990s, software developers and managers were furiously working to analyze and fix potential “Y2K bugs.” We all knew that there were software applications that might fail on January 1, 2000, but no one was sure how we would manage to fix all of these defects in time.
Today’s “smart” technologies: Fifteen years later, we are at the threshold of a new era of software – smart phones, wearable technology, digital currency, smart automobiles, smart power grids, smart appliances. How should we prepare for this wave? Should we be thinking ahead, should we be anticipating some of the potential risks and latent defects in our smart applications and smart support software for a software-driven future world?
What advances in software analysis, design, coding, and testing will we need to do reduce our exposure to defects, unintended side effects, and malicious mischief? We might look to the past – to the biggest concentrated effort to clean up and modernize software on a worldwide scale. Are there some lessons we can learn from “Y2K remediation activities” of the 1990s?

**************************************************************
WODA - 13th International Workshop on Dynamic Analysis
http://2015.splashcon.org/track/woda2015