73,649 research outputs found
A Multilevel Analysis of Implicit and Explicit CSR in French and UK Professional Sport
Research question: This paper examines the ways in which French and UK professional sports clubs implement and communicate their CSR policies. In addition to identifying similarities and differences between CSR practices in the two countries, our analysis extends and adapts the implicit-explicit CSR framework to the field of sport.
Research methods: We used a mixed methods approach to analyse qualitative and quantitative data on the CSR strategies of 66 professional rugby union (Top 14, Aviva Premiership Rugby) and football (Ligue 1, Premier League) clubs over the 2017-2018 season.
Results and findings: We found major differences in CSR communication between France and the UK. Communication by French clubs tends to highlight sport’s values, involve few media channels, whereas communication by UK clubs explicitly vaunts their social responsibility and involves numerous channels. In the case of CSR implementation, there are similarities between French and UK clubs, especially in the fields their CSR initiatives cover (e.g., health, diversity), as well as differences. However, the scope of initiatives varies more between sports than between countries, with football demonstrating a more international outlook than rugby.
Implications: This article expands Matten and Moon’s (2008) implicit-explicit CSR framework by identifying the influence of interactions between sectorial/field-level factors and national/macro-level factors on CSR practices, and by distinguishing between CSR communication and CSR implementation. Our results throw light on the shift from implicit to explicit CSR in French professional sport
On Decidable Growth-Rate Properties of Imperative Programs
In 2008, Ben-Amram, Jones and Kristiansen showed that for a simple "core"
programming language - an imperative language with bounded loops, and
arithmetics limited to addition and multiplication - it was possible to decide
precisely whether a program had certain growth-rate properties, namely
polynomial (or linear) bounds on computed values, or on the running time.
This work emphasized the role of the core language in mitigating the
notorious undecidability of program properties, so that one deals with
decidable problems.
A natural and intriguing problem was whether more elements can be added to
the core language, improving its utility, while keeping the growth-rate
properties decidable. In particular, the method presented could not handle a
command that resets a variable to zero. This paper shows how to handle resets.
The analysis is given in a logical style (proof rules), and its complexity is
shown to be PSPACE-complete (in contrast, without resets, the problem was
PTIME). The analysis algorithm evolved from the previous solution in an
interesting way: focus was shifted from proving a bound to disproving it, and
the algorithm works top-down rather than bottom-up
Loop Quasi-Invariant Chunk Motion by peeling with statement composition
Several techniques for analysis and transformations are used in compilers.
Among them, the peeling of loops for hoisting quasi-invariants can be used to
optimize generated code, or simply ease developers' lives. In this paper, we
introduce a new concept of dependency analysis borrowed from the field of
Implicit Computational Complexity (ICC), allowing to work with composed
statements called Chunks to detect more quasi-invariants. Based on an
optimization idea given on a WHILE language, we provide a transformation method
- reusing ICC concepts and techniques - to compilers. This new analysis
computes an invariance degree for each statement or chunks of statements by
building a new kind of dependency graph, finds the maximum or worst dependency
graph for loops, and recognizes if an entire block is Quasi-Invariant or not.
This block could be an inner loop, and in that case the computational
complexity of the overall program can be decreased. We already implemented a
proof of concept on a toy C parser 1 analysing and transforming the AST
representation. In this paper, we introduce the theory around this concept and
present a prototype analysis pass implemented on LLVM. In a very near future,
we will implement the corresponding transformation and provide benchmarks
comparisons.Comment: In Proceedings DICE-FOPARA 2017, arXiv:1704.0516
Dynamically typed languages
Dynamically typed languages such as Python and Ruby have experienced a rapid grown in popularity in recent times. However, there is much confusion as to what makes these languages interesting relative to statically typed languages, and little knowledge of their rich history. In this chapter I explore the general topic of dynamically typed languages, how they differ from statically typed languages, their history, and their defining features
Programming with Quantum Communication
This work develops a formal framework for specifying, implementing, and
analysing quantum communication protocols. We provide tools for developing
simple proofs and analysing programs which involve communication, both via
quantum channels and exhibiting the LOCC (local operations, classical
communication) paradigm
Tight polynomial worst-case bounds for loop programs
In 2008, Ben-Amram, Jones and Kristiansen showed that for a simple programming language - representing non-deterministic imperative programs with bounded loops, and arithmetics limited to addition and multiplication - it is possible to decide precisely whether a program has certain growth-rate properties, in particular whether a computed value, or the program's running time, has a polynomial growth rate. A natural and intriguing problem was to move from answering the decision problem to giving a quantitative result, namely, a tight polynomial upper bound. This paper shows how to obtain asymptotically-tight, multivariate, disjunctive polynomial bounds for this class of programs. This is a complete solution: whenever a polynomial bound exists it will be found. A pleasant surprise is that the algorithm is quite simple; but it relies on some subtle reasoning. An important ingredient in the proof is the forest factorization theorem, a strong structural result on homomorphisms into a finite monoid
- …