Digital Twin Survey

Together with my colleagues Prof Ruth Breu and Dr Philipp Zech from the University of Innsbruck, I am interested in finding out the types, applications and maturity of Digital Twins across a broad sector of Industry and Academia. We have constructed a survey:

https://umfrage.uibk.ac.at/limesurvey/allgemein/index.php/273288?lang=en

It seeks to acquire information that will will allow us to report on the current situation and hopefully to make useful recommendations.

If you have any interest in Digital twins please take a few minutes to complete the survey.

Head of School Informatics and Digital Engineering

An exciting opportunity at Aston University - come and join our team in the College of Engineering and Physical Sciences: 

https://www.jobs.ac.uk/job/CIA669/head-of-school-informatics-and-digital-engineering

Towards the AI-native Enterprise

Please consider submitting to our workshop at the PoEM Conference. Details below.

Enterprises of the future will be complex system of systems of socio-cyber-physical actors, that operate in dynamic and uncertain environments. They will need to continue delivering on their goals in the face of unforeseen changes and events (such as global pandemics) along multiple dimensions. The goals they aim to meet are also likely to evolve rapidly as enterprises look to exploit opportunities as they emerge in their ever changing environment.

These dynamics will play out at multiple levels, requiring a cohesive response across three key planes of enterprise, namely: the intent plane concerned with the purpose of the enterprise, the processes plane concerned with the processes needed to realise the purpose, and the organisational plane concerned with the organization of the (socio-cyber-physical) actors (and infrastructures) that enact the different processes. All of this facing continuously shrinking time windows. This puts hitherto unseen demands on enterprises as regards responsive decision-making with partial information in the face of uncertainty and swift adaptation to support continuous transformation while optimizing stakeholder value. 

Meanwhile, wave after wave of information technologies, such as (statistical) AI, IoT, Digital Twins, Low-Code, No-Code, etc, bring the promise of enabling enterprises to be more intelligent, more efficient, more flexible, and even more agile. As a consequence, it is to be expected that future enterprises will be increasingly model-guided, AI-powered and data-fueled; giving birth to what we prefer to call AI-native enterprises. 

The emergence of AI-native enterprises, however, also raises fundamental design challenges: How to ensure coherent design of such enterprises? How to balance change and stability? How to manage uncertainty? How remain (just enough) compliant to regulations? What about ethics and privacy? 

Furthermore, what is the future role of existing disciplines such as Enterprise Modelling, Enterprise Engineering & Architecting, Modelling & Simulation, Process Engineering, Knowledge Engineering, and AI towards the emergence of AI-native enterprises? How do fundamental concepts such as actor-network theory, multi-agent system theory, and control theory fit? Can novel technologies, such as Machine Learning, Adaptive Software, Digital Twins, and Reinforced Learning, further enable the emergence of AI-native enterprises? 

The workshop aims to discuss these, and other relevant, issues across the entire gamut ranging over the state of art and practice, limitations and lacunae, possible means to overcome them, case studies illustrating the line of attack, and future work. As such, the goal of the AInE workshop is to bring together leading researchers across different relevant fields, in order to (1) explore the challenges facing the emergence of AI-native enterprises, and (2) exchange and discuss ideas, concepts, approaches that aim to meet these challenges. 

Topics

Topics relevant for submission, but not limited to:

• Modelling Data-driven Organizations
• Enterprise Engineering and Architecting
• Modelling and Simulation
• Multi-perspective Business Processes
• Modelling Enterprise Security, Risk, Privacy and Regulatory Compliance
• Modelling in Industry 4.0, Cyber-Physical Systems, and Digital Twins
• Adaptive Software
• Knowledge Management and Enterprise Modelling
• Human Aspects in Enterprise Modelling
• Large Scale Organizational Structures and Enterprise Ecosystems

Workshop website and submission site

https://conf.researchr.org/home/ai-ne-2021#Call-for-Papers

https://easychair.org/conferences/?conf=poem2021 Please remember to select  " AI-native Enterprise" Track.

Important dates

• Submission via EasyChair: end of Sun Oct 3 AoE
• Reviews Due: end of Fri Oct 22 AoE
• Decision communicated to authors: Tue Oct 26.

Workshop Chairs 

Vinay Kulkarni, Tony Clark, Henderik A. Proper, and Sreedhar Reddy

Advanced Digital Architectures for Model-Driven Adaptive Enterprises

Please check out our new book. It has been developed with colleagues Vinay Kulkarni and Sreedhar Reddy (TCS Research) and Balbir Barn (Middlesex University). You can read more about how TCS are using the approach here. An overview of the book is:

The five digital forces (mobility and pervasive computing, cloud, big data, artificial intelligence and robotics, and social media) are poised to bring great academic and industrial breakthroughs. All stakeholders want to understand how to best harness these forces to their advantage. While literature exists for understanding each force independently, there is a lack of knowledge on how to utilise all the forces together to realise future enterprises. 

Advanced Digital Architectures for Model-Driven Adaptive Enterprises is an essential reference source that explores the potential in unifying the five digital forces to achieve increased levels of agility, efficiency, and scale. Featuring coverage on a wide range of topics including socio-technical systems, adaptive architectures, and enterprise modeling, this book is ideally designed for managers, executives, programmers, designers, computer engineers, entrepreneurs, tool builders, digital practitioners, researchers, academicians, ands students at the graduate level.

Topics Covered

The many academic areas covered in this publication include, but are not limited to:

• Adaptive Architectures
• Adoption Issues
• Complex Systems of Systems
• Digital Enterprise
• Digital Thread
• Digital Twin
• Enterprise Decision Making
• Enterprise Modeling
• Entrepreneurship
• Investing
• Security and Privacy
• Socio-Technical Systems

Innovations in Software Engineering 2021: Call for Papers

Innovations in Software Engineering Conference
ISEC 2021
Call for Papers
Main Conference - Research Track

 

ISEC is the annual conference of iSOFT, the India chapter of ACM SIGSOFT India. The 14^th edition of the conference will be held at KIIT University, Bhubaneswar, Odisha, India. The goal of the conference is to provide a forum for researchers and practitioners from both academia and industry to meet and share problems, experiences, and cutting-edge advancements in the field of software and systems engineering.

ISEC 2021 invites the submission of technical papers describing original and unpublished results of foundational, theoretical, empirical, and applied software and systems engineering research. Submissions are invited in all areas of software and systems engineering, including but not limited to the following:

 

Software Engineering Methods Agile Methods Business Process Design and Deployment Requirements Engineering Empirical Software Engineering Safety-Critical Software Verification and Validation Engineering for Quality Requirements Human Factors Mobile and Web Applications Model Driven Development Software Product Lines Self-Adaptive Systems Software Analytics System Modeling and Simulation Program Comprehension and Visualization End User Development Software Metrics Globally Distributed Teams System Debugging Component Based Software Engineering  Security and Privacy System Architecture   Responsible Software Engineering Trust, Fairness and Ethics Green software engineering

Software Deployment and Operations DevOps Container Based Software Artifacts Dynamic Discovery & Version Management Handling Container Image Sprawl Fault Isolation and Repair Software Evolution and Maintenance   Software for the Cloud Data Obfuscation Application Driven Resource Allocation Cross Cloud Deployment Performance Engineering in the Cloud    Software Engineering Specialisms Service Based Technologies Programming Languages Mining Software Repositories Software Economics and Metrics Software Engineering Education Automated Software Engineering Software Engineering & Machine Learning Software Engineering & AI Software Engineering and Law Formal Methods Traceability Virtual, Augmented and Mixed Reality Blockchain

 

 

Submission Details

Submissions should present the most recent and significant technical contributions to the field of Software and Systems Engineering. We invite high quality submissions to be evaluated against the following criteria:

·       Soundness: The extent to which contributions are supported by rigorous application of appropriate research methods.

·       Significance: Demonstrating that contributions are novel, original, and important, with respect to the existing body of knowledge.

·       Verifiability: The presentation of sufficient information to support independent verification or replication of the claimed contributions,

·       Presentation: Achieving clear descriptions and explanations, adequate use of the English language, absence of major ambiguity, clearly readable figures and tables, and adherence to the formatting instructions provided below.

This year, we invite submissions under three categories: Regular, Short, Poster:

·       Regular papers should not exceed 11 pages, 10 pages for the main text (including figures, appendix etc.) and 1 page for references in standard ACM format. Regular papers contain full descriptions that constitute contributions to knowledge and are evaluated against the criteria given above.

·       Short papers should not exceed 5 pages, including references in standard ACM format. Short papers should clearly demonstrate that the work is a contribution to knowledge, but may be incomplete in terms of being able to demonstrate one or more of soundness, significance, or verifiability.

·       Poster papers should not exceed 2 pages. A poster paper is intended to describe work that is at an early stage in development. Accepted poster papers will be provided with an opportunity to display a poster and to discuss the ideas with delegates during a dedicated session of the conference.

Regular paper submissions are expected to contain in-depth descriptions of the new ideas along with detailed evaluation, and when relevant rigorously consider reasonable broader impacts, both positive and negative, e.g. in a separate "Broader Impacts" section (refer to the blog post: https://acm-fca.org/2018/03/29/negativeimpacts/). 

Submissions may take the form of experience reports or case studies. In particular we would welcome such submissions from Industry. Experience reports and case studies should address the application of software engineering practices (which may include work on principles, techniques, tools, methods, processes) to a specific business domain or to the development of a substantial software platform/system. Each paper should describe the context of a problem of practical importance and provide plausible solutions. Please take care to cover the following issues: innovation of the approach and the solution, the methodology, assessment of the benefits, risks and lessons learned.

Short papers may contain, for example, new interesting ideas which may not be evaluated extensively, tool descriptions or case studies. 

Submissions must comply with the ACM plagiarism policy and procedures. In particular, it must not have been published elsewhere and must not be under review elsewhere while under review for ISEC. The submission must also comply with the IEEE Policy on Authorship.

Accepted papers in all categories will be published in the ACM Digital Library and indexed by DBLP. If a submission is accepted, at least one author of the paper is required to attend the conference and present the paper in person.

Submission Template: https://www.acm.org/publications/proceedings-template

Submission Link: https://easychair.org/conferences/?conf=isec2021

Program Co-Chairs

·       Tony Clark, Aston University, UK.                    

·       Alpana Dubey, Accenture Labs, India.

Important Dates

·       ISEC 2021 Conference: 25 -27 Febuary, 2021

·       Paper submission deadline: 20 September 2020, AoE

·       Paper notification: 04 December 2020, AoE

·       Camera ready due: 25 December 2020, AoE

Programme Committee

TBC

Cyber Security Posts in Computer Science at Aston

Despite what it currently says here: https://www.jobs.ac.uk/job/BXB915/academic-appointment-in-cyber-security-at-any-level-including-chair, we have several posts in Cyber Security. The information about the posts is copied below:

Aston University’s mission is to be the UK’s leading university for students aspiring to succeed in business and the professions where original research, enterprise and inspiring teaching deliver local and global impact. Aston University was awarded Gold in the 2017 Teaching Excellence Framework. We have developed a bold strategy around our beneficiaries because their future success is important to us. We define our beneficiaries as those who the University exists to serve; students, external organisations, and our region and society.

The School of Engineering and Applied Science (EAS) has a tradition of quality and reputation for cutting edge research, offering students excellent opportunities to join in the process of discovery and creativity, and prepare for an increasingly diverse and technological world. EAS was recently awarded the Silver Athena Swan Award in 2018. One of the academic groups within EAS is Computer Science, which focuses on creatively solving the problems of business and industry through advanced software engineering. The group’s strengths include software engineering and process, distributed computing, knowledge representation and engineering, pattern analysis, AI, robotics, machine learning, natural language processing, HCI, computing education and digital health. We also deliver distinctive and innovative programmes at undergraduate and Masters levels that achieve some of the highest employability rates for Computer Science graduates in the UK.

We are now seeking to appoint a full-time academic in cyber security at any level including Chair to develop and contribute to an internationally-recognised research programme in Cyber Security or closely-related field, that has significant impact in the field. S/he will also contribute to the development of the new BSc in Cyber Security and contribute to the delivery of teaching as part of the BSc in Cyber Security, and potentially other Computer Science programmes. A PhD in Computer Science or related discipline is essential. The appointee will have a proven track record of sustainable research in cyber security or closely-related discipline. S/he will have a track record in successfully securing research funding, experience of engaging with industry partners and have considerable teaching experience with evidence of module or programme development, innovation and good student satisfaction. Applications from individuals with senior technical roles in cyber security in industry or business will also be considered.

For further details, including job description, person specification and information on how to apply, please see https://candidates.perrettlaver.com/vacancies/ quoting reference 4192. For informal enquiries about the role, please contact Nataliya Mykhalchenko via email at Nataliya.Mykhalchenko@perrettlaver.com or on +44 (0)20 7340 6237.

The closing date for applications is midday on Sunday 2^nd February 2020.

Popularity of Programming Languages

Fascinating video showing the popularity of programming languages over the years:

Reinforcement Q-Learning in ESL

The language ESL merges Actors with Function Programming and other features to make the construction of highly concurrent applications as easy as possible. ESL is currently in development and we are developing support for Machine Learning, and Reinforcement Learning in particular.

A form of Reinforcement Learning is called Q-Learning (described here). A simple example is a Predator-Prey situation in a grid-world where a predator can move horizontally and vertically in the grid and must navigate to a randomly placed prey. To start off, the predator has no knowledge of how to do this, it just moves randomly in the world. When it catches the prey, the predator gets a reward. Q-Learning will then back-up the reward along the path that led to the goal being achieved thereby reinforcing that policy the next time it is encountered but he predator. If this is repeated a sufficient number of times, the resulting policy will allow the predator to catch the randomly placed prey every time, even though the hard-coded behaviour for the predator has no knowledge of such a strategy.

The video below shows three things:

1. An implementation of a generalised Q-Learning policy creation function mkPolicy in ESL.
2. A Predator-Prey example that consisting of a world and an independent predator actor. The predator actor uses mkPolicy to create a policy, and then supplies information to improve the policy.
3. A run of the example showing two phases: the learning phase followed by a stable phase. The learning phase starts the predator and prey in random positions and uses the current version of the policy (which is initially random) until the predator finds the prey. During the learning phase the policy is updated with information about the world and gradually improves. The stable phase does not change the policy: it just uses it. You can see that the learning phase involves lots of random movement (although it gets less random towards the end) and the stable phase is very directed.

To see the source code, you may need to halt the video play or you can download the files policy.esl and policy_pred.esl.

Segregation

ESL is an actor-based language that is currently in development. Actors are like objects with their own computational thread. As part of development we are keen to stress test the number of actors that can concurrently exist.  Schelling’s [Schelling TC (1969) Models of segregation. Am Econ Rev 59:488–493] is a classic model of residential segregation that lends itself to an actor-based application. Residents are either red or blue and like to be co-located with residents of their own colour. If they find themselves in a neighbourhood that is overwhelmed by the opposite colour then they move to a random empty location. Residents can be implemented as actors that independently move around until they feel secure. The video below shows a 400 by 200 grid of ESL actors starting with random allocations and moving towards a stable system:

Here is a snapshot of a 1000 by 600 grid of ESL actors (takes much longer to get to a stable position):

The ESL code for the implementation is as follows:

export main;

// Behaviour types:
// Main runs the application.
// Agent exists at a location in the world.
// Grid is an external Java actor for the display.

type Main = Act { Time(Int); }

type Agent = Act { Turn; }

type Grid = Act { SetColour(Int,Int,Str); }

// External functions...

intToFloat::(Int)->Float = builtin[(Int)->Float]('runtime.actors.Builtins','intToFloat',1);
round::(Float)->Int = builtin[(Float)->Int]('runtime.actors.Builtins','round',1);

// Basic list-processing...

occurrences[T](x::T,l::[T])::Int =
  case l {
    [][T] -> 0;
    h::T:t::[T] when h=x -> 1 + occurrences[T](x,t);
    h::T:t::[T] -> occurrences[T](x,t);
  }

flatten[T](lists::[[T]])::[T] =
  case lists {
    h::[T];
    t::[[T]];
    h:t -> h+flatten[T](t);
    [][[T]] -> [][T];
  }

nth[T](l::[T],n::Int)::T =
  case l {
    h::T;
    t::[T];
    h:t    -> if n = 0 then h; else nth[T](t,n-1);
    [][T]  -> throw[T]('cannot take nth element.');
  }
  
replaceNth[T](l::[T],n::Int,x::T)::[T] = 
  case l {
    [][T] -> throw[[T]]('cannot replace nth of []');
    h::T:t::[T] when n=0 -> x:t;
    h::T:t::[T] -> h:replaceNth[T](t,n-1,x);
  }

// Parameters that control the application:

similarpc::Int = 70;       // 70% of neighbours should be the same colour.
width::Int     = 1000;     // Number of locations wide.
height::Int    = 600;      // Number of locations high.
redpc::Int     = 60;       // Starting with 60% red population.
emptypc::Int   = 10;       // 10% of locations hould be empty.
empty::Int     = 0;        // The encoding for an empty location.
red::Int       = 1;        // The encoding for a red location.
blue::Int      = 2;        // The encoding for a bloue location.
limit::Int     = 1000000;  // A millisecond time limit.

// The locations are represented on a width*height matrix represented as nested lists...

opp(c::Int)::Int = if c = red then blue; else red;
colour(c::Int)::Str = if c = red then 'red'; else if c = empty then 'white'; else 'blue';

legalx(x::Int)::Bool = (x = 0) or (x = width) or ((x > 0) and (x < width));
legaly(y::Int)::Bool = (y = 0) or (y = height) or ((y > 0) and (y < height));

population::[[Int]] = 
  [ [ probably(100-emptypc)::Int { 
        probably(redpc)::Int red; else blue; 
      } else empty 
    | w::Int <- 0..width ] 
  | h::Int <- 0..height ];

popEl(x::Int,y::Int)::Int = nth[Int](nth[[Int]](population,y),x);

popElp(x::Int,y::Int)::[Int] = [popEl(x%width,y%height)];
  
popSet(x::Int,y::Int,c::Int)::Void = {
  population := replaceNth[[Int]](population,y,replaceNth[Int](nth[[Int]](population,y),x,c));
  grid <- SetColour(x,y,colour(c));
}

popSim(x::Int,y::Int)::Int =
  let surround::[Int] = flatten[Int]([ popElp(x0,y0) | x0::Int <- (x-1)..(x+2), y0::Int <- (y-1)..(y+2), ?not((x0 = x) and (y0 = y)) ]);
      colour::Int = popEl(x,y);
  in let sim::Int = occurrences[Int](colour,surround);
         diff::Int = occurrences[Int](opp(colour),surround);
     in round((intToFloat(sim)/(intToFloat(sim+diff)))* 100.0);
     
     // An external Java actor that deals with the graphics...
  
grid::Grid = new 'esl.grid.Grid'[Grid](width,height,1);

act agent(x::Int,y::Int)::Agent {

  // An agent lives at (x,y) and wants to live in a neighbourhood
  // of agents with a similar colour...
  
  findEmpty(x0::Int,y0::Int)::Void = 
    if popEl(x0,y0) = empty
      then {
      popSet(x0,y0,popEl(x,y));
      popSet(x,y,empty);
      x := x0;
      y := y0;
    } else findEmpty(random(width),random(height));
    
  Turn -> { 
    grab(population) {
      // If the neighbours are less than the required
      // similarity then find an empty location and
      // move to it...
      if popSim(x,y) < similarpc
      then {
        findEmpty(random(width),random(height));
      } else {}
    }
    self <- Turn;
  }
}

act main::Main {
  // Create the agents, send their initial colour to the
  // GUI and then send them a Turn message to start the
  // simulation
  agents::[Agent] = [][Agent];
   -> {
    for y::Int in 0..height do {
      for x::Int in 0..width do {
        if popEl(x,y) <> empty
        then {
          let a::Agent = new agent(x,y);
          in {
            agents := a:agents;
            grid <- SetColour(x,y,colour(popEl(x,y)));
            a <- Turn;
          }
        } else {}
      }
    }
  }
 
  Time(n::Int) when n > limit -> { 
    print[Str]('STOP ' + n + ' ' + limit);
    stopAll();
  }
  
  Time(n::Int) -> {} 
}

Software Engineering Winter and AI Summer

At ISEC there was a panel discussion chaired by Vasudeva Varma who posed the question: `are we facing a Software Engineering Winter and an AI Summer?'. The motivating observation is the resurgence of AI after the boom in the 1980s and the AI Winter that followed it. Vasudeva challenged the panel audience to compare the number of movies made about AI compared to those made about SE. The panel went on to discuss how AI and SE can (and probably will) merge so that intelligence in various forms becomes part of conventional applications and their associated development methods and technologies. In particular, Machine Learning provides an opportunity for engineered software applications to benefit from their histories, to be become intelligent, resilient and adaptive: features that are typically omitted from software requirements. This sounds like a grand challenge for Software Engineers.

Value Based Tracking

This looks like an interesting way to track your activities: work out the value to you and the value to others of each task you do. Avoid the bottom left-hand corner! More details are found in an article by Jurgen Appelo. Jurgen claims: The two-by-two grid is visually pleasing, and, when used on a software platform, it opens opportunities for gamification and social interaction.

Cyber Security Challenge

JxBrowser

I am working with colleagues on implementing an actor-based language called ESL: https://github.com/TonyClark/ESL (contact me at t.clark@shu.ac.uk if you are interested). ESL is a VM written in Java. Part of the tool support exports actor-histories encoded in SVG. I tried a number of technical solutions to embed a browser in Swing in order to visualise and interact with the SVG. By far the easiest and technically superior solution is JxBrowser - it worked straight to out of the box without any problems at all.

International Women's Day

Tuesday 8 March marks International Women's Day (IWD). Observed since 1909 it is a global celebration of respect, appreciation and recognition of women, while continuing to call for greater equality. Thousands of events occur to mark the economic, political and social achievements of women and Sheffield Hallam University is an active participant. In support of this year's theme of 'Pledge for Parity' staff and students who have been nominated by colleagues share their inspirational stories.

• Click here for staff profiles.

• Click here for student profiles.

Halloween Cake

It's cake-o'clock!

IBM 2015 Innovation and Ada Lovelace Celebration

Students from the Computing Department of Sheffield Hallam University on a recent visit to IBM. This included the first Women in IT event. Thanks to the IBM staff who are mentoring around 30 of our students and to Dr Andy Hirst, Teaching Fellow in Work Based Learning at Sheffield Hallam who organised the event.

Applied Metamodelling: A Foundation for Language Driven Development (Third Edition)

The book Applied Metamodelling: A Foundation for Language Driven Development continues to be cited in scholarly articles (here is a list since 2014) even though there is no official means of referencing it. A third edition has been created and registered with arXiv (identifier 1505.00149) to provide a permanent record of the book that can be cited:

@ARTICLE{2015arXiv150500149C,
   author = {{Clark}, T. and {Sammut}, P. and {Willans}, J.},
   title = "{Applied Metamodelling: A Foundation for Language Driven Development (Third Edition)}",
   journal = {ArXiv e-prints},
   archivePrefix = "arXiv",
   eprint = {1505.00149},
   primaryClass = "cs.SE",
   keywords = {Computer Science - Software Engineering},
   year = 2015,
   month = may,
   adsurl = {http://adsabs.harvard.edu/abs/2015arXiv150500149C},
   adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}

Is your degree worth it? It depends what you study, not where.

This is an interesting article from The Economist:

Quote: "A new report from PayScale, a research firm, calculates the returns to a college degree. Its authors compare the career earnings of graduates with the present-day cost of a degree at their alma maters, net of financial aid. College is usually worth it, but not always, it transpires. And what you study matters far more than where you study it. Engineers and computer scientists do best, earning an impressive 20-year annualised return of 12% on their college fees (the S&P 500 yielded just 7.8%). Engineering graduates from run-of-the-mill colleges do only slightly worse than those from highly selective ones. Business and economics degrees also pay well, delivering a solid 8.7% average return. Courses in the arts or the humanities offer vast spiritual rewards, of course, but less impressive material ones. Some yield negative returns. An arts degree from the Maryland Institute College of Art had a hefty 20-year net negative return of $92,000, for example."

Systematic Literature Reviews

Literature reviews are the 'meat and potatoes' of academic research. In some disciplines the process of creating a review has become systematic, for example in Cochrane for medical research. In Software Engineering there has been an attempt to provide a process that is described and analysed here. A couple of years ago we (Balbir Barn, Franco Raimondi, Lalith Athappian and myself) were awarded some JISC funding to implement a tool to support the construction of an SLR. The first version of our SLR tool has attracted over 100 registered users from academic institutions  across the world. The process that is supported by the tool is based on Cochrane and is described in a up-coming paper in ICEIS 2014. The process is described below:

Our aim is to  create a tool that is 'model driven' in that users can create their own SLR process model and the tool will adapt to that. We have not reached that stage yet, but would be interested to get feedback from anyone who has used the current version of the tool to see how it could be improved.

Computer Science: An Approach to Teaching and Learning

In 2012 we decided to completely review our Computer Science BSc. We are in the process of delivering the First Year of the degree at the moment. Our First Year aims are to:

• Support each student to develop an appreciation of the key topics of the discipline through practical problem led holistic sessions that aim to reflect the way that CS occurs in the real world.
• Integrate programming throughout the year and to use programming as a basis to engage with as many of the foundational aspects as possible.
• Invert the locus of control for teaching and learning by allowing students to dictate the pace at which learning outcomes are demonstrated.

In order to support the First Year we made two decisions. The first was to use Racket as the programming technology. There were various reasons for this including the support Racket provides in terms of the Dr Racket tool, referential transparency, interaction through REPL, and the ability of Lisp-based languages to have a close association with foundational concepts such as sets, functions and data structures with the minimum of boiler-plate.

The second decision relates to course coherence and assessment. Under normal circumstances in the UK, a course is decomposed into a number of modules each of which  has its own syllabus and assessment processes. This imposes fire-walls around the different aspects of the overall year and makes it difficult to let the learning process naturally spread without over-assessment. For example, a First Year will normally contain modules for Architecture, Programming, Fundamentals etc. Topics such as graphs, events, or binary representation can occur as important features in any or all of these modules. If module apartheid is imposed then modules can tend to be overstuffed or there is a danger that topics might be missed. Furthermore, passing the year tends to require a minimum success in a range of assessments, usually 40% across the modules (typically with some minimum threshold in each). This raises the question: what does a student who has achieved 40% actually know? 40% of what? 

Our plan for the First Year is to introduce a sequence of examples, challenges, mini-projects, case-studies that provide an opportunity for multiple topics to be introduced and investigated and thereby  provide the opportunity for students to demonstrate the acquisition of knowledge and skills. Each of the key CS topics might occur multiple times throughout the year. A student is free (within reason) to choose how to do certain challenges and thereby when to demonstrate the learning.

Of course such a free-wheeling approach introduces a significant overhead regarding managing the learning portfolio of each student. This led to the second decision: the CS First Year is supported by a tool that manages Student Observable Behaviours (SOBs). The key topics are decomposed into a collection of SOBs that can be measured by a member of academic staff interacting with a student in a number of ways including labs, group sessions, observing presentations, or one-to-one tutorials. 

SOBs are tagged as: threshold, typical, or excellent. All essential foundational topics in CS are covered by threshold-level SOBs and to pass the year a student must have demonstrated all threshold SOBs. This ensures that the 40% problem described above does not arise: all student who pass the year have acquired a minimum knowledge of CS for all topics. The typical-level SOBs might introduce more in-depth or specialist knowledge and skills. Excellent-level SOBs provide an opportunity for students to demonstrate advanced standing through activities such as mini-projects.

Our SOB tool provides a platform for managing the student portfolios, but also has the benefit of providing a number of reports for both the students and the staff. Students can see their performance to date against what is expected (SOBs have demonstration time-windows that identify where the teaching team have planned opportunities for demonstration, although students are not tied to these) and against the rest of the cohort. Our experience to date is that this real-time reporting provides a beneficial incentive to maximise performance through competition within the cohort.

A screen-shot of the tool showing the current progress of students against threshold-level SOBs is shown below. The black line shows the expected progress. Actual progress is better than expected although most are around the 12-18 threshold SOB mark which is about right. The fact that there are quite a few ahead of the game is consistent with our experience that the approach has improved student engagement over previous versions of the CS First Year.

Here is a screen-shot of the typical and excellent level SOBs:

                                                       

The year is organised as a sequence of 3 blocks each of which has a different academic team. Each team organises labs and workshops around the SOB framework and sets a single holistic block-challenge. The first challenge uses an Arduino connected to Racket to build a collection of traffic lights. The second challenge is to use data structures in Racket to build a simple dungeon game. The third challenge is to build a robot using Racket and a Raspberry Pi.

The block 2 challenge handout is shown below. It uses a series of simple games implemented in Racket: dungeon_rooms.rkt, moving_about.rkt, monsters_attack.rkt, command_language.rkt, items.rkt.

Although we are only half-way through the first run of our new design, it seems to be working. Student engagement is very good with many students determined to 'get ahead of the game' by demonstrating SOBs as early as possible. Although many of the excellent SOBs are designed to be very challenging, as shown above some students are keen to try them. The use of Racket has gone well, although the small number of textbooks for Racket, and the dry nature of the on-line documentation, is a problem for introductory-level students who want to go further through self-study. However, in practice this appears to be a very minor issue. 

The SOB-tool is working better than we could have expected. It has been developed in-house but is not tied to CS or any course in particular. We would be happy to chat with anyone who might be interested in using the SOB-tool or finding out more details about how the CS First Year has been designed and delivered.

Call for Papers: Towards the Model Driven Organization

The First International Workshop

TowArds the Model DrIveN Organization 

(AMINO 2013 http://www.cs.colostate.edu/remodd/v1/amino2013)

29 Sept 2013

As part of the ACM/IEEE 16th International Conference on 

 Model Driven Engineering Languages and Systems (MODELS 2013)

Miami Florida USA 29 September 2013 through 4 October 2013

 http://www.modelsconference.org

Overview

Modern organizations are faced with the very challenging problem of rapidly responding to continual external business pressures in order to sustain their competitiveness or to effectively perform mission-critical services. Difficulties arise because the continual evolution of systems and operational procedures that are performed in response to the external pressures eventually leads to suboptimal configurations of the systems and processes that drive the organization.

The management of continuous business change is complicated by the current lack of effective mechanisms for rapidly responding to multiple change drivers. The use of inadequate change management methods and technologies introduces accidental complexities that significantly drive up the cost, risk, and effort of making changes. These problems provide opportunities for developing and applying organization modeling approaches that seek to improve an organization's ability to effectively evolve in response to changes in its business environment. Modeling an organization to better support organizational evolution leads to what we call a Model Driven Organization (MDO), where an MDO is an organization in which models are the primary means for interacting with and evolving the systems that drive an organization.

DEF: A Model Driven Organization uses models in the analysis, design, simulation, delivery, operation, and maintenance of systems to address its strategic, tactical and operational needs and its relation to the wider environment.

An organization's Enterprise Systems (ES) support a wide-range of business activities including planning, business intelligence, operationalization, and reporting. ES are thus pivotal to a company's competitiveness. Modelling technologies and approaches that address the development, analysis, deployment and maintenance of ES have started to emerge. Such technologies and approaches must support a much broader collection of use-cases than traditional technologies for systems design modeling. Current ES architectures do not adequately address the growing demands for inter-organisational collaboration, flexibility and advanced decision support in organizations.

Realizing the MDO vision will require research that cross-cuts many areas, including research on enterprise architectures, business process. and workflow modeling, system requirements and design modeling, metamodeling, and models@runtime. This workshop seeks to bring together researchers and practitioners from a variety of MDD research domains to discuss the need, feasibility challenges and proposed realizations of aspects of the MDO vision.

The full-day workshop aims to provide a forum to report and discuss advances and current research questions in applying modelling technologies to organizations in order to substantially improve their flexibility and economics. The aim is to integrate various areas of research such as: models at runtime, (meta-) modelling, modelling tools, enterprise architecture, architecture modelling and business processes.  The workshop is a full-day and will include an invited speaker, paper presentations and a discussion on a research roadmap that will contribute to achieving Model Driven Organizations.

Scope

Submissions are solicited in areas that are related to this aim, and that address model-based approaches to the following non-exhaustive list of topics:

• Frameworks for the Model Driven Organization.
• Enterprise analysis including risk analysis and resource planning.
• Stakeholder support through multiple perspectives.
• Domain specific languages for enterprise modelling.
• Patterns and best practice for enterprise modelling.
• Modelling technologies for the Model Driven Organization.
• Case studies.
• Maturity models for the Model Driven Organization.
• Enterprise simulation.
• Enterprise-wide socio-technical issues.
• Applying information systems theory to the Model Driven Organization.
• Enterprise use-cases including:
• Business change.
• Regulatory compliance.
• Mergers and acquisitions.
• Business goal alignment.
• Outsourcing.
• Business intelligence.

Submissions must be in the scope of the workshop as described above. Submission process will be managed by Easychair: https://www.easychair.org/conferences/?conf=amino2013. All submissions will be required to conform to LNCS format: http://www.springer.de/comp/lncs/authors.html

Submissions are invited in the following categories:

• research papers reporting on completed research activities. (15 pages + up to 2 pages for references).
• short papers describing work in progress (8 pages + up to 2 pages for references).
• position papers describing a new approach to a research question (8 pages + up to 2 pages for references).
• case-study papers reporting on real-life case studies (8 pages + up to 2 pages for references).

Publication

Publication of the accepted workshop papers will be organised via the MODELS workshop chairs in a formal digital library. In addition the workshop organisers are planning to invite selected papers to be extended and submitted to a publication (via collections such as LNCS or LNBIP) of selected works describing research contributing to the aim of the Model Driven Organization. 

Registration

See  the MODELS 2013 web site http://modelsconference.org/ for registration.

Committees

Organizing Committee

• Balbir Barn, Middlesex University, London, UK, http://www.mdx.ac.uk/aboutus/staffdirectory/balbir-barn.aspx
• Tony Clark, Middlesex University, London, UK, http://www.eis.mdx.ac.uk/staffpages/tonyclark/
• Robert France, Colorado State University, Colorado, USA, http://www.cs.colostate.edu/~france
• Ulrich Frank, Universty of Dusibirg-Essen, Essen, Germany, http://www.wi-inf.uni-duisburg-essen.de/FGFrank/
• Vinay Kulkarni, Tata Consultancy Services, India, http://www.tcs-trddc.com/
• Dan Turk, Colorado State University, Colorado, USA, http://biz.colostate.edu/facultyResearch/sat/profile.aspx?profileId=Busdom\DanT

Program Committee:

• Erik Proper, Public Research Centre Henri Tudor, http://www.erikproper.eu
• John Mylopoulos, University of Toronto, http://www.cs.toronto.edu/~jm/
• Martin Gogolla, Database Systems Group, University of Bremen, http://www.db.informatik.uni-bremen.de
• Marite Kirikova, Riga Technical University.
• Florian Matthes, Technische Universität München, http://wwwmatthes.in.tum.de
• Joseph Barjis, Delft University of Technology, http://www.josephbarjis.com/
• Christian Huemer, Vienna University of Technology, http://www.big.tuwien.ac.at/staff/huemer
• Gregor Engels, University of Paderborn, http://www.upb.de/cs/engels.html
• Jennifer Horkoff, DISI, University of Trento, http://www.cs.utoronto.ca/~jenhork
• John Krogstie, IDI, NTNU
• Detlef Seese, Karlsruhe Institute of Technology
• Philippe Collet, Université Nice Sophia Antipolis, http://www.i3s.unice.fr/~collet
• Richard Paige, University of York, http://www.cs.york.ac.uk/~paige
• Robert Lagerström, KTH the Royal Institute of Technology, http://www.ics.kth.se
• .. invitations pending..

Important Dates

• Workshop Paper Submission Deadline: 15 July 2013
• Workshop Paper Notification to Authors: August 2013
• Workshop Dates: 29 Sept 2013

Contacts

Contact the workshop organisers using: amino2013@CS.ColoState.EDU