This document summarizes a presentation given by Olivier Le Goaër on executable modeling and dynamic adaptation. It provides a short biography of Le Goaër, discusses domain-specific languages and different shapes they can take, and how models are taking on a more dynamic role at runtime. It explores controversies around executable models and components of executable modeling built with model-driven engineering. Finally, it discusses approaches to executable modeling, model adaptation, and implementation choices for adaptive executable modeling.
Model-Driven Development in the context of Software Product LinesMarkus Voelter
Domain specific languages, together with code generation or interpreters (a.k.a. model-driven development), are becoming more and more important. Since there is a certain overhead involved in building languages and processors, this approach is especially useful in environments where a spe-cific set of languages and generators can be reused many times. Product lines are such an environment. Consequently, the use of domain specific languages (DSLs) for Software Product Line Engi-neering (SPLE) is becoming more relevant. However, exploiting DSLs in the context of product lines involves more than just defining and using languages. This tutorial explains the differences as well as commonalities between model-driven development (MDD) and SPLE and shows how the two approaches can be combined. In this tutorial we will first recap/introduce feature modeling and model-driven development. We then build a simple textual DSL and a code generator based on Eclipse openArchitectureWare (oAW). Based on this language we’ll discuss the kinds of variability expressible via DSLs versus those expressible via feature modeling, leading to a discussion about ways to combine the two. In the next demo slot we’ll do just that: we’ll annotate a model with feature dependencies. When generating code, the elements whose features are not selected will be removed, and hence no code will be generated. Finally we’ll discuss and demo the integration feature dependencies into code generators to con-figure the kind of code generated from the model.
A presentation I gave in Expert Days 2012. In this presentations I explain how most of the features in the C# language work, including Iterators, Lambdas, Linq, Dynamics, and more.
Model-Driven Development in the context of Software Product LinesMarkus Voelter
Domain specific languages, together with code generation or interpreters (a.k.a. model-driven development), are becoming more and more important. Since there is a certain overhead involved in building languages and processors, this approach is especially useful in environments where a spe-cific set of languages and generators can be reused many times. Product lines are such an environment. Consequently, the use of domain specific languages (DSLs) for Software Product Line Engi-neering (SPLE) is becoming more relevant. However, exploiting DSLs in the context of product lines involves more than just defining and using languages. This tutorial explains the differences as well as commonalities between model-driven development (MDD) and SPLE and shows how the two approaches can be combined. In this tutorial we will first recap/introduce feature modeling and model-driven development. We then build a simple textual DSL and a code generator based on Eclipse openArchitectureWare (oAW). Based on this language we’ll discuss the kinds of variability expressible via DSLs versus those expressible via feature modeling, leading to a discussion about ways to combine the two. In the next demo slot we’ll do just that: we’ll annotate a model with feature dependencies. When generating code, the elements whose features are not selected will be removed, and hence no code will be generated. Finally we’ll discuss and demo the integration feature dependencies into code generators to con-figure the kind of code generated from the model.
A presentation I gave in Expert Days 2012. In this presentations I explain how most of the features in the C# language work, including Iterators, Lambdas, Linq, Dynamics, and more.
Standards-Based Executable UML: Today's Reality and Tomorrow's PromiseEd Seidewitz
This webinar demonstrates the practical realization of standards-based executable modeling in UML, showing its importance for moving forward in a number of, perhaps, unexpected areas, including agile development methods, multi-core programming and model-based system engineering. Today’s Executable UML is based on the OMG’s Foundational UML (fUML) standard, for executable object-oriented and activity modeling, and the Action Language for fUML (Alf) standard, which defines a corresponding textual representation. But this is only the beginning. Additional Executable UML standards are being built on this foundation, including recent ones for composite structure and state machines.
This is an overview of C++ (based on 1999 / 2003 standard) and its use in Object Oriented Programming. The presentation assumes that the audience knows C programming.
Programming is hard. Programming correct C and C++ is particularly hard. Indeed, both in C and certainly in C++, it is uncommon to see a screenful containing only well defined and conforming code.Why do professional programmers write code like this? Because most programmers do not have a deep understanding of the language they are using.While they sometimes know that certain things are undefined or unspecified, they often do not know why it is so. In these slides we will study small code snippets in C and C++, and use them to discuss the fundamental building blocks, limitations and underlying design philosophies of these wonderful but dangerous programming languages.
This content has a CC license. Feel free to use it for whatever you want. You may download the original PDF file from: http://www.pvv.org/~oma/DeepC_slides_oct2012.pdf
Simon Peyton Jones: Managing parallelismSkills Matter
If you want to program a parallel computer, it obviously makes sense to start with a computational paradigm in which parallelism is the default (ie functional programming), rather than one in which computation is based on sequential flow of control (the imperative paradigm). And yet, and yet ... functional programmers have been singing this tune since the 1980s, but do not yet rule the world. In this talk I’ll say why I think parallelism is too complex a beast to be slain at one blow, and how we are going to be driven, willy-nilly, towards a world in which side effects are much more tightly controlled than now. I’ll sketch a whole range of ways of writing parallel program in a functional paradigm (implicit parallelism, transactional memory, data parallelism, DSLs for GPUs, distributed processes, etc, etc), illustrating with examples from the rapidly moving Haskell community, and identifying some of the challenges we need to tackle.
EuGENia is a tool that automatically generates the .gmfgraph, .gmftool and .gmfmap models needed to implement a GMF editor from a single annotated Ecore metamodel. EuGENia provides high-level annotations that shield you from the complexity of GMF and lowers the entrance barrier for creating your first GMF editor. While EuGENia is very useful for getting started with GMF, it doesn't stop there and can be used all the way to the final polished version of your editor.
Object-Oriented Programming in Modern C++. Borislav Stanimirov. CoreHard Spri...corehard_by
Object-oriented programming has been criticized a lot. Every now and then some article or talk appears denouncing it and proclaiming that it's dead. This talk will do the opposite. It defends OOP and presents many modern libraries and concepts to show that it's very much alive and kicking.
Standards-Based Executable UML: Today's Reality and Tomorrow's PromiseEd Seidewitz
This webinar demonstrates the practical realization of standards-based executable modeling in UML, showing its importance for moving forward in a number of, perhaps, unexpected areas, including agile development methods, multi-core programming and model-based system engineering. Today’s Executable UML is based on the OMG’s Foundational UML (fUML) standard, for executable object-oriented and activity modeling, and the Action Language for fUML (Alf) standard, which defines a corresponding textual representation. But this is only the beginning. Additional Executable UML standards are being built on this foundation, including recent ones for composite structure and state machines.
This is an overview of C++ (based on 1999 / 2003 standard) and its use in Object Oriented Programming. The presentation assumes that the audience knows C programming.
Programming is hard. Programming correct C and C++ is particularly hard. Indeed, both in C and certainly in C++, it is uncommon to see a screenful containing only well defined and conforming code.Why do professional programmers write code like this? Because most programmers do not have a deep understanding of the language they are using.While they sometimes know that certain things are undefined or unspecified, they often do not know why it is so. In these slides we will study small code snippets in C and C++, and use them to discuss the fundamental building blocks, limitations and underlying design philosophies of these wonderful but dangerous programming languages.
This content has a CC license. Feel free to use it for whatever you want. You may download the original PDF file from: http://www.pvv.org/~oma/DeepC_slides_oct2012.pdf
Simon Peyton Jones: Managing parallelismSkills Matter
If you want to program a parallel computer, it obviously makes sense to start with a computational paradigm in which parallelism is the default (ie functional programming), rather than one in which computation is based on sequential flow of control (the imperative paradigm). And yet, and yet ... functional programmers have been singing this tune since the 1980s, but do not yet rule the world. In this talk I’ll say why I think parallelism is too complex a beast to be slain at one blow, and how we are going to be driven, willy-nilly, towards a world in which side effects are much more tightly controlled than now. I’ll sketch a whole range of ways of writing parallel program in a functional paradigm (implicit parallelism, transactional memory, data parallelism, DSLs for GPUs, distributed processes, etc, etc), illustrating with examples from the rapidly moving Haskell community, and identifying some of the challenges we need to tackle.
EuGENia is a tool that automatically generates the .gmfgraph, .gmftool and .gmfmap models needed to implement a GMF editor from a single annotated Ecore metamodel. EuGENia provides high-level annotations that shield you from the complexity of GMF and lowers the entrance barrier for creating your first GMF editor. While EuGENia is very useful for getting started with GMF, it doesn't stop there and can be used all the way to the final polished version of your editor.
Object-Oriented Programming in Modern C++. Borislav Stanimirov. CoreHard Spri...corehard_by
Object-oriented programming has been criticized a lot. Every now and then some article or talk appears denouncing it and proclaiming that it's dead. This talk will do the opposite. It defends OOP and presents many modern libraries and concepts to show that it's very much alive and kicking.
Apprenez à écrire vos macros pour le tableur Excel en Visual Basic. Cette formation couvre les rudiments de programmation ainsi que la découverte de l'API Excel
Ma critique de cette technologie sur http://olegoaer.developpez.com/cours/vba/
Le cryptage RSA est-il intrinsèquement inviolable ? Pour le savoir, nous essayons de comprendre comment il fonctionne et sur quelles mathématiques il s'appuie.
Une révision des principaux concepts du langage JavaScript : variables, fonctions, types, fermetures (closures), objets et prototypes, format JSON. De nombreux exemples téléchargeables sur GitHub.
Support de cours utilisé lors de la formation d'élèves en licence informatique. Cette formation porte sur les technologies JavaScript : de la découverte du langage aux notions avancées, en passant par la stack/architecture MEAN (MongoDB, Express, Angular, Node.js), jQuery et d'autres technologies du moment.
Plus d'informations sur mon profil Linkedin : https://fr.linkedin.com/in/guillaumemorelbailly
Efficient and Advanced Omniscient Debugging for xDSMLs (SLE 2015)Benoit Combemale
Talk given at the 8th ACM SIGPLAN Int'l Conf. on Software Language Engineering (SLE 2015), Pittsburgh, PA, USA on October 27, 2015. Preprint available at https://hal.inria.fr/hal-01182517
This presentation describes some key features of Scala uses in the creation of machine learning algorithms:
1 Functorial definition of tensors for learning non-linear models (manifolds)
2. Monads to compose of explicit kernel functions in Euclidean space
3. Implicit class to extends Scala standard library
4. Stackable traits and dependency injection to build formal models and dynamic workflows
5. Tail recursion to implementation dynamic programming techniques
6. Streaming to reduce memory consumption for big data
7. Control of back pressure in data flows
http://patricknicolas.blogspot.com
http://bit.ly/12GjRu9
EclipseCon Eu 2015 - Breathe life into your Designer!melbats
You have your shiny new DSL up and running thanks to the Eclipse Modeling Technologies and you built a powerful tooling with graphical modelers, textual syntaxes or dedicated editors to support it. But how can you see what is going on when a model is executed ? Don't you need to simulate your design in some way ? Wouldn't you want to see your editors being animated directly within your modeling environment based on execution traces or simulator results?
The GEMOC Research Project designed a methodology to bring animation and execution analysis to DSLs. The companion technologies required to put this in action are small dedicated components (all open-source) at a "proof of concept" maturity level extending proven components : Sirius, Eclipse Debug, Xtend making such features within the reach of Eclipse based tooling. The general intent regarding those OSS technologies is to leverage them within different contexts and contribute them to Eclipse once proven strong enough. The method covers a large spectrum of use cases from DSLs with a straightforward execution semantic to a combination of different DSLs with concurrent execution semantic. Any tool provider can leverage both the technologies and the method to provide an executable DSL and animated graphical modelers to its users enabling simulation and debugging at an early phase of the design.
This talk presents the approach, the technologies and demonstrate it through an example: providing Eclipse Debug integration and diagram animation capabilities for Arduino Designer (EPL) : setting breakpoints, stepping forward or backward in the execution, inspecting the variables states... We will walk you through the steps required to develop such features, the choices to make and the trade-offs involved. Expects live demos with simulated blinking leds and a virtual cat robot !
Distributed data-intensive systems are increasingly designed to be only eventually consistent. Persistent data is no longer processed with serialized and transactional access, exposing applications to a range of potential consistency and concurrency anomalies that need to be handled by the application itself. Controlling concurrent data access in monolithic systems is already challenging, but the problem is exacerbated in distributed systems. To make it worse, only little systematic engineering guidance is provided by the software architecture community regarding this issue.
Susanne shares her experiences from different case studies with industry clients, and novel design guidelines developed by using action research. You will learn settled and novel approaches to tackle consistency- and concurrency related design challenges.
Detachable user interfaces consist of graphical user interfaces whose parts or whole can be detached at run-time from their host, migrated onto an- other computing platform while carrying out the task, possibly adapted to the new platform and attached to the target platform in a peer-to-peer fashion. De- taching is the property of splitting a part of a UI for transferring it onto another platform. AttAaching is the reciprocal property: a part of an existing interface can be attached to the currently being used interface so as to recompose another one on-demand, according to user's needs, task requirements. Assembling inter- face parts by detaching and attaching allows dynamically composing, decom- posing and re-composing new interfaces on demand. To support this interaction paradigm, a development infrastructure has been developed based on a series of primitives such as display, undisplay, copy, expose, return, transfer, delegate, and switch. We exemplify it with QTkDraw, a painting application with attach- ing and detaching based on the development infrastructure.
SiriusCon 2015 - Breathe Life into Your Designer!melbats
You have your shiny new DSL up and running thanks to the Eclipse Modeling Technologies and you built a powerful tooling with graphical modelers, textual syntaxes or dedicated editors to support it. But how can you see what is going on when a model is executed ? Don't you need to simulate your design in some way ? Wouldn't you want to see your editors being animated directly within your modeling environment based on execution traces or simulator results?
The GEMOC Research Project designed a methodology to bring animation and execution analysis to DSLs. The companion technologies required to put this in action are small dedicated components (all open-source) at a "proof of concept" maturity level extending proven components : Sirius, Eclipse Debug, Xtend making such features within the reach of Eclipse based tooling. The general intent regarding those OSS technologies is to leverage them within different contexts and contribute them to Eclipse once proven strong enough. The method covers a large spectrum of use cases from DSLs with a straightforward execution semantic to a combination of different DSLs with concurrent execution semantic. Any tool provider can leverage both the technologies and the method to provide an executable DSL and animated graphical modelers to its users enabling simulation and debugging at an early phase of the design.
This talk presents the approach, the technologies and demonstrate it through an example: providing Eclipse Debug integration and diagram animation capabilities for Arduino Designer (EPL) : setting breakpoints, stepping forward or backward in the execution, inspecting the variables states... We will walk you through the steps required to develop such features, the choices to make and the trade-offs involved. Expects live demos with simulated blinking leds and a virtual cat robot ! This talks presents also xCapella an industrial use case onwhich the Gemoc methodology was applied.
This talks was presented at SiriusCon 2015 in collaboration with Jérôme Le Noir from Thales.
The Arduino Designer documentation is available on : https://github.com/mbats/arduino/wiki/Documentation
Software development effort reduction with Co-oplbergmans
This talks explains the motivations for the Co-op technology: what are the challenges it addresses, in particular focusing on reducing accidental complexity, where it comes from, and a general vision on how to resolve it. Then we continue to show practical application of Co-op, including experience figures from large-scale application of a previous generation of this technology. Show a little bit about its realization, and conclude with an evaluation of the technology.
Extending Rotor with Structural Reflection to support Reflective Languagesfranciscoortin
Presentation of the results of the project "Extending Rotor with Structural Reflection to support Reflective Languages" at Microsoft Research, Redmond, Washington (USA)
The road to "green code" is paved with good intentions, but few solutions are actionable to date. This talk gives the keys to understanding sustainable software development (mobile in particular) and shows how code quality control with SonarQube™ can help meet the challenge of global limits.
PowDroid: Energy Profiling of Android Applications (ASE 2021 [Workshop] SUSTA...Olivier Le Goaër
While the energy efficiency of mobile apps is receiving considerable attention in recent years, Android developers have little tools to assess the energy footprint of their applications. In this paper, we introduce PowDroid, our tool to estimate the energy consumption of Android application. It uses system-wide metrics and does not require access to applications' source code. We run PowDroid on a use-case scenario comparing the energy footprint of applications in different categories.
Nowadays, energy efficiency is recognized as a core quality attribute of applications (apps) running on Android-powered devices constrained by their battery. Indeed, energy hogging apps are a liability to both the end-user and software developer. Yet, there are very few tools available to help developers increase the quality of their native code by ridding it of energy-related bugs. Android Studio is the official IDE for millions of developers worldwide and there's no better place to enforce green coding rules in everyday projects. Indeed, Android Studio provides a code scanning tool called Android lint that can be extended with lacking green checks in order to foster the design of more eco-responsible apps.
GREEN PAUWARE - For a power-thrifty mobile app marketplaceOlivier Le Goaër
Energy-intensive mobile applications are a burden for both end users and devel-opers, and ultimately are harmful to the planet. The objective of the GREEN PAUWARE project is to break these bad habits by creating an energy label for applications (ranging from A to G), as exists in other areas. Many authors agree on the necessity of an eco-score or ranking within the mobile apps market, but research is hampered by the complexity and lack of available tools.
This presentation proposes milestones to achieve this objective. In particular, it introduces an ecological bonus-malus system applied to Android development projects to try to give a score to applications. Then, it shows how to use a static code analysis tool like Android Lint to implement such a system. Finally, it features a distributed software architecture to collect scores and push labels towards end users so they can make informed decisions when installing applica-tions on their Android-powered devices.
How to Position Your Globus Data Portal for Success Ten Good PracticesGlobus
Science gateways allow science and engineering communities to access shared data, software, computing services, and instruments. Science gateways have gained a lot of traction in the last twenty years, as evidenced by projects such as the Science Gateways Community Institute (SGCI) and the Center of Excellence on Science Gateways (SGX3) in the US, The Australian Research Data Commons (ARDC) and its platforms in Australia, and the projects around Virtual Research Environments in Europe. A few mature frameworks have evolved with their different strengths and foci and have been taken up by a larger community such as the Globus Data Portal, Hubzero, Tapis, and Galaxy. However, even when gateways are built on successful frameworks, they continue to face the challenges of ongoing maintenance costs and how to meet the ever-expanding needs of the community they serve with enhanced features. It is not uncommon that gateways with compelling use cases are nonetheless unable to get past the prototype phase and become a full production service, or if they do, they don't survive more than a couple of years. While there is no guaranteed pathway to success, it seems likely that for any gateway there is a need for a strong community and/or solid funding streams to create and sustain its success. With over twenty years of examples to draw from, this presentation goes into detail for ten factors common to successful and enduring gateways that effectively serve as best practices for any new or developing gateway.
Experience our free, in-depth three-part Tendenci Platform Corporate Membership Management workshop series! In Session 1 on May 14th, 2024, we began with an Introduction and Setup, mastering the configuration of your Corporate Membership Module settings to establish membership types, applications, and more. Then, on May 16th, 2024, in Session 2, we focused on binding individual members to a Corporate Membership and Corporate Reps, teaching you how to add individual members and assign Corporate Representatives to manage dues, renewals, and associated members. Finally, on May 28th, 2024, in Session 3, we covered questions and concerns, addressing any queries or issues you may have.
For more Tendenci AMS events, check out www.tendenci.com/events
Quarkus Hidden and Forbidden ExtensionsMax Andersen
Quarkus has a vast extension ecosystem and is known for its subsonic and subatomic feature set. Some of these features are not as well known, and some extensions are less talked about, but that does not make them less interesting - quite the opposite.
Come join this talk to see some tips and tricks for using Quarkus and some of the lesser known features, extensions and development techniques.
Large Language Models and the End of ProgrammingMatt Welsh
Talk by Matt Welsh at Craft Conference 2024 on the impact that Large Language Models will have on the future of software development. In this talk, I discuss the ways in which LLMs will impact the software industry, from replacing human software developers with AI, to replacing conventional software with models that perform reasoning, computation, and problem-solving.
Paketo Buildpacks : la meilleure façon de construire des images OCI? DevopsDa...Anthony Dahanne
Les Buildpacks existent depuis plus de 10 ans ! D’abord, ils étaient utilisés pour détecter et construire une application avant de la déployer sur certains PaaS. Ensuite, nous avons pu créer des images Docker (OCI) avec leur dernière génération, les Cloud Native Buildpacks (CNCF en incubation). Sont-ils une bonne alternative au Dockerfile ? Que sont les buildpacks Paketo ? Quelles communautés les soutiennent et comment ?
Venez le découvrir lors de cette session ignite
Listen to the keynote address and hear about the latest developments from Rachana Ananthakrishnan and Ian Foster who review the updates to the Globus Platform and Service, and the relevance of Globus to the scientific community as an automation platform to accelerate scientific discovery.
Accelerate Enterprise Software Engineering with PlatformlessWSO2
Key takeaways:
Challenges of building platforms and the benefits of platformless.
Key principles of platformless, including API-first, cloud-native middleware, platform engineering, and developer experience.
How Choreo enables the platformless experience.
How key concepts like application architecture, domain-driven design, zero trust, and cell-based architecture are inherently a part of Choreo.
Demo of an end-to-end app built and deployed on Choreo.
Gamify Your Mind; The Secret Sauce to Delivering Success, Continuously Improv...Shahin Sheidaei
Games are powerful teaching tools, fostering hands-on engagement and fun. But they require careful consideration to succeed. Join me to explore factors in running and selecting games, ensuring they serve as effective teaching tools. Learn to maintain focus on learning objectives while playing, and how to measure the ROI of gaming in education. Discover strategies for pitching gaming to leadership. This session offers insights, tips, and examples for coaches, team leads, and enterprise leaders seeking to teach from simple to complex concepts.
Providing Globus Services to Users of JASMIN for Environmental Data AnalysisGlobus
JASMIN is the UK’s high-performance data analysis platform for environmental science, operated by STFC on behalf of the UK Natural Environment Research Council (NERC). In addition to its role in hosting the CEDA Archive (NERC’s long-term repository for climate, atmospheric science & Earth observation data in the UK), JASMIN provides a collaborative platform to a community of around 2,000 scientists in the UK and beyond, providing nearly 400 environmental science projects with working space, compute resources and tools to facilitate their work. High-performance data transfer into and out of JASMIN has always been a key feature, with many scientists bringing model outputs from supercomputers elsewhere in the UK, to analyse against observational or other model data in the CEDA Archive. A growing number of JASMIN users are now realising the benefits of using the Globus service to provide reliable and efficient data movement and other tasks in this and other contexts. Further use cases involve long-distance (intercontinental) transfers to and from JASMIN, and collecting results from a mobile atmospheric radar system, pushing data to JASMIN via a lightweight Globus deployment. We provide details of how Globus fits into our current infrastructure, our experience of the recent migration to GCSv5.4, and of our interest in developing use of the wider ecosystem of Globus services for the benefit of our user community.
Globus Connect Server Deep Dive - GlobusWorld 2024Globus
We explore the Globus Connect Server (GCS) architecture and experiment with advanced configuration options and use cases. This content is targeted at system administrators who are familiar with GCS and currently operate—or are planning to operate—broader deployments at their institution.
Exploring Innovations in Data Repository Solutions - Insights from the U.S. G...Globus
The U.S. Geological Survey (USGS) has made substantial investments in meeting evolving scientific, technical, and policy driven demands on storing, managing, and delivering data. As these demands continue to grow in complexity and scale, the USGS must continue to explore innovative solutions to improve its management, curation, sharing, delivering, and preservation approaches for large-scale research data. Supporting these needs, the USGS has partnered with the University of Chicago-Globus to research and develop advanced repository components and workflows leveraging its current investment in Globus. The primary outcome of this partnership includes the development of a prototype enterprise repository, driven by USGS Data Release requirements, through exploration and implementation of the entire suite of the Globus platform offerings, including Globus Flow, Globus Auth, Globus Transfer, and Globus Search. This presentation will provide insights into this research partnership, introduce the unique requirements and challenges being addressed and provide relevant project progress.
Enterprise Resource Planning System includes various modules that reduce any business's workload. Additionally, it organizes the workflows, which drives towards enhancing productivity. Here are a detailed explanation of the ERP modules. Going through the points will help you understand how the software is changing the work dynamics.
To know more details here: https://blogs.nyggs.com/nyggs/enterprise-resource-planning-erp-system-modules/
We describe the deployment and use of Globus Compute for remote computation. This content is aimed at researchers who wish to compute on remote resources using a unified programming interface, as well as system administrators who will deploy and operate Globus Compute services on their research computing infrastructure.
Globus Compute wth IRI Workflows - GlobusWorld 2024Globus
As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.
OpenFOAM solver for Helmholtz equation, helmholtzFoam / helmholtzBubbleFoamtakuyayamamoto1800
In this slide, we show the simulation example and the way to compile this solver.
In this solver, the Helmholtz equation can be solved by helmholtzFoam. Also, the Helmholtz equation with uniformly dispersed bubbles can be simulated by helmholtzBubbleFoam.
Cyaniclab : Software Development Agency Portfolio.pdfCyanic lab
CyanicLab, an offshore custom software development company based in Sweden,India, Finland, is your go-to partner for startup development and innovative web design solutions. Our expert team specializes in crafting cutting-edge software tailored to meet the unique needs of startups and established enterprises alike. From conceptualization to execution, we offer comprehensive services including web and mobile app development, UI/UX design, and ongoing software maintenance. Ready to elevate your business? Contact CyanicLab today and let us propel your vision to success with our top-notch IT solutions.
Navigating the Metaverse: A Journey into Virtual Evolution"Donna Lenk
Join us for an exploration of the Metaverse's evolution, where innovation meets imagination. Discover new dimensions of virtual events, engage with thought-provoking discussions, and witness the transformative power of digital realms."
2. 2/31
A short bioA short bio
Positions
● Ph.D in 2009 – AeLoS team, LINA
● Associate Professor since 2010 – MOVIES team, LIUPPA
Research topics
● Software Evolution/Adaptation
● Software Architecture
● Model-Driven Engineering
Hobbies
● Mobile technologies
● Web technologies
3. 3/31
Domain-specific languages (DSL)Domain-specific languages (DSL)
General Purpose Languages
● Not targeted to a particular kind of problem, but to any kinds of
software problem
Domain-Specific Languages
● Targeted to a particular kind of problem
– with dedicated notations (textual or graphical), support (editor, checkers, etc.)
● Promises: more « efficient » languages for resolving a set of
specific problems in a domain
● Each concern described in its own language
– For software developpers (modeling, programming, querying, building,
documenting, ...), for software architects (ADL), for statisticians (R), for biologists, for
sociologists, ...
4. 4/31
Shapes for a DSLShapes for a DSL
Internal
● Hosted by a
GPL
External
● Stand-alone
Implicit
● API-like
C# & Linq SQL Querydsl SQL
Java API
QCustomer customer;
customer = new QCustomer("c");
SQLQuery<?> query =
new SQLQuery<Void>(connection);
List<String> lastNames =
query.select(customer.lastName)
.from(customer)
.where(customer.firstName.eq("Bob"))
.fetch();
System.out.print(lastNames);
SELECT lastName
FROM customer
WHERE firstName = 'Bob';
var queryBobCustomers =
from cust in customer
where cust.firstName == "Bob"
select cust.lastName;
foreach (var n in queryBobCustomers)
{
Console.WriteLine(n);
}
5. 5/31
Shapes for a DSLShapes for a DSL
Internal
● Hosted by a
GPL
External
● Stand-alone
Implicit
● API-like
C# & Linq SQL Querydsl SQL
Java API
QCustomer customer;
customer = new QCustomer("c");
SQLQuery<?> query =
new SQLQuery<Void>(connection);
List<String> lastNames =
query.select(customer.lastName)
.from(customer)
.where(customer.firstName.eq("Bob"))
.fetch();
System.out.print(lastNames);
SELECT lastName
FROM customer
WHERE firstName = 'Bob';
var queryBobCustomers =
from cust in customer
where cust.firstName == "Bob"
select cust.lastName;
foreach (var n in queryBobCustomers)
{
Console.WriteLine(n);
}
6. 6/31
Models are taking a new roleModels are taking a new role
« marauders map » – Harry Potter
Model playing a static role
(design-time)
Model playing a dynamic role
(run-time)
● Tells us about the
structure of the castle
(every classroom,
every hallway, and
every corner)
● Tells us about moving
persons (shows foot
prints)
7. 7/31
Crossing the demarcation lineCrossing the demarcation line
Model of a
system
(conforms to a
metamodel)
S
Running
system
IN
TER
PR
ETATIO
N
Running system
=
model under execution
Design-time
Run-time
C
O
M
PILATIO
N
</xml>
sub{ }
MDA ®
MM
exec(M)exec(M)
8. 8/31
Executable modeling (xModeling)Executable modeling (xModeling)
Compilation
● Translational semantics
– Code generation in a target language
Direct execution (~VM/interpreter)
● Operational semantics
– Using an « action » language
– Using a M2M transformation (rare in practice)
Breathing life into models
● Simulation, V&V, rapid prototyping...
● Ultimately, skip the implementation stage !
9. 9/31
Controversies and debatesControversies and debates
Executable models "can be run, tested,
debugged, and measured for performance"
UML / fUML as prominent examples
● Is a class diagram executable? Alone ?
● Is a paquage diagram executable?
● Is a sequence diagram executable?
Raises the question of an executable nature
● Behavior of a software system captured by a model M
● Ability to define a current execution state within M
● Ability to compute the next state (aka « step ») within M
10. 10/31
xModeling built with MDExModeling built with MDE
Meta-models are just a specific OO data
structures to represent abstract syntax trees
● Operational semantics = computation steps and runtime data
● A VM/interpreter is a program working with such AST and that
implements a given operational semantics
Executable metamodeling
● xMOF (eXecutable MOF)
● Kermeta
● Ecore + body of operation(s) written Java/EMF
● …
12. 12/31
Modeling with StatechartsModeling with Statecharts
--The instance of the finite state machine is unique (root)
context StateMachine inv singleStateMachine:
StateMachine.allInstances()->size() = 1 and self.container.oclIsUndefined()
--All the states are included in composites except the finite state machine herself
context State inv containerForAllStates:
not self.oclIsTypeOf(StateMachine) implies not self.container.oclIsUndefined()
14. 14/31
xModeling with StatechartsxModeling with Statecharts
runToCompletion()
isActive:boolean
0..1
lastKnownActiveState
-- When an history state exists and references a state, the latter must belongs to the composite
context CompositeState inv historyInComposite:
if self.historyState.oclIsUndefined()
then true
else
if self.historyState.referencedState.oclIsUndefined()
then true
else self.states->includes(self.historyState.lastKnownActiveState)
endif
endif
15. 15/31
xModeling with StatechartsxModeling with Statecharts
runToCompletion()
isActive:boolean
0..1
lastKnownActiveState
-- When an history state exists and references a state, the latter must belongs to the composite
context CompositeState inv R3:
if self.historyState.oclIsUndefined()
then true
else
if self.historyState.referencedState.oclIsUndefined()
then true
else self.states->includes(self.historyState.lastKnownActiveState)
endif
endif
//operationnal semantics of UML2
aspect class StateMachine {
operation runToCompletion(e : Event)
is do
// suivre la transition trouvée en activant l'état
// cible et en modifiant en conséquence la hiérarchie d'états actifs
end
}
//operationnal semantics of UML2
aspect class StateMachine {
operation runToCompletion(e : Event)
is do
// suivre la transition trouvée en activant l'état
// cible et en modifiant en conséquence la hiérarchie d'états actifs
end
}
17. 17/31
Model@run.timeModel@run.time
Overloaded term
● Deals originally with software
adaptation issues at runtime
Advantage
● Provides a reasoning support
on a running system
Drawback
● Holding a causal link: M has to
remain the strict reflect of S
MM
SS
adaptation ?
représentation modification
Adaptation
loop
18. 18/31
Model@run.time + xModelingModel@run.time + xModeling
Treats the specific case where the considered
running system is a model under execution
Idea : collapsing the adaptation loop
● Solves the causal link issue...
● ...but the merge may leads to a burdened model M''
M
S = exec(M')S = exec(M')
adaptation ?
représentation modification S = exec(M'')
adaptation ?
modification
collapse
19. 19/31
Non-supervised adaptation (self-*)Non-supervised adaptation (self-*)
Detect a situation requiring adaptation
● Known versus unknown context (e.g. a new signal)
– Green runtime event is sometimes ignored (designer's choice at design-time)
– White runtime event is actually unknown at design-time
Perform adaptation actions
● CRUD operators on any runtime data
Metamodel specialization unlocks adaptation
● Model (sub)typing : adding new metaclasses and new constraints
– Adding new operations accordingly : for (a) detect and (b) perform
● Choosing the right level of specialization is tactful
– Domain adaptations are rare but apply on any model instance of the metamodel
– Business adaptations are frequent but only apply on some models
22. 22/31
Adaptable xModelingAdaptable xModeling
RunToCompletion()*
-- Each state must be associated to a transition for each identified event
context State def: knownEvents : Set(String) = Set{...};
context State inv Completeness:
self.knownEvents -> forAll( e | self.existsTransitionFor(e))
-- A transition tagged with {p, v} leads to a state also tagged with with {p, v}
context StateMachine inv Consistency:
...
...
23. 23/31
Adaptable xModelingAdaptable xModeling
RunToCompletion()*
-- Each state must be associated to a transition for each identified event
context State def: knownEvents : Set(String) = Set{...};
context State inv Completeness:
self.knownEvents -> forAll( e | self.existsTransitionFor(e))
-- A transition tagged with {p, v} leads to a state tagged with with {p, v}
context StateMachine inv Consistency:
...
...
//adaptation operational semantics
aspect class StateMachine {
operation runToCompletion(e : Event)
is do
if not e.isKnown() then
//introduces the new state and transitions thereof
end
//same as usual (nominal behavior)
end
}
//adaptation operational semantics
aspect class StateMachine {
operation runToCompletion(e : Event)
is do
if not e.isKnown() then
//introduces the new state and transitions thereof
end
//same as usual (nominal behavior)
end
}
aspect class Event {
operation isKnown() : Boolean
is do
//checks if an event is unknown or not
end
}
aspect class Event {
operation isKnown() : Boolean
is do
//checks if an event is unknown or not
end
}isKnown()*
24. 24/31
From craft to engineering with MDEFrom craft to engineering with MDE
Modeling
xModeling
Adaptable
xModeling
Metamodel (static)
+ [exec. translational semantics]
Metamodel (static + dynamic)
+ exec. operational semantics
Metamodel (static + dynamic + adaptative) +
adapt. operational semantics
25. 25/31
Adaptation extends executionAdaptation extends execution
Execution semantics
● Deals with the nominal behavior (known context)
● Operation(s) only apply on the dynamic part (the static part is on
read-only mode)
Adaptation semantics
● Is-a-kind-of execution semantics
● Deals with extra-ordinary situation (unknown context)
● Operation(s) may apply on all parts (static, dynamic, adaptation)
The two kinds of semantics are mixed
26. 26/31
Implementation ChoicesImplementation Choices
Classic programming
● Adaptation is tangled into execution
OO programming
● Adaptation overrides execution (and calls « super »)
Contract-based programming
● Adaptation occurs when a precondition of execution is violated
Aspect-oriented programming
● Adaptation is woven into execution
xModeling !
● Adaptation is modeled with a DSL and calls back to execution
27. 27/31
xModeling built without MDExModeling built without MDE
PauWare engine (www.pauware.com)
● Execution engine (VM) for statechart models
● Implements the complete UML2 execution semantics specification
● API written in Java (hence ported effortlessly to Android)
JavaJava
PauWare APIPauWare API
Code/xml that describes the
statechart model to be loaded
Engine that executes the model
loaded (« run-to-completion »)
Free implementation of
the actions
(called by reflection from the engine)
Consumes an
event for each
execution step
28. 28/31
Android + PauWareAndroid + PauWare
SERVICE
BROADCAST
RECEIVER
Android OS
ANDROID
CONNECTOR
e1/foo
e1
public void foo() {
//do something
}
public void bar() {
//do other thing
}
A statechart model
runs-to-completion
starts invokes
PauWare
Execution
Engine
Java
xmi
scxml
29. 29/31
Supervised adaptationSupervised adaptation
Ability to load a new model on-the-fly
● A model is just a runtime data taken as input of the engine
● Actions' implementation have to stay unchanged
SERVICE
BROADCAST
RECEIVER
Android OS
ANDROID
CONNECTOR
events
runs-to-completion
starts invokes
PauWare
Execution
Engine
Model
Server
Google
Cloud
Messaging
Push
Notification
Fresh data retrieval
Adapter
e1/foo
public void foo() {
//do something
}
public void bar() {
//do other thing
}
30. 30/31
World Wide Modeling (wwm)World Wide Modeling (wwm)
MDE-specific URI
● model://host[:port]/M3/M2/M1
– model://localhost/Ecore/UML2/train
– model://localhost/Ecore/OCL/
Commands
● model://host/M3?list
● model://host/M3/M2?info
● model://host/M3/M2/M1#fragment
Getting started (requires )
● $> npm install wwm
● JavaScript API for client-side and server-side programming