The document provides best practices for developing code generators using Acceleo. It covers topics such as naming conventions, project architecture, writing good modules, using Java services, and testing generators. Specific recommendations include using camel case for names, organizing packages by functionality, preferring polymorphism over long if/else chains, wrapping Java services in queries, and having a single entry point for generations. The best practices aim to help developers structure Acceleo projects effectively and avoid common issues.
This document contains information about Patrick Barel, an Oracle consultant and author. It includes his contact details, areas of expertise, blogs and websites to read, plugins available for download, and upcoming training events he will be presenting. Some key points are:
- Patrick Barel has been working with Oracle technologies like PL/SQL, APEX, and OCA certification since 1997.
- He maintains blogs on technology.amis.nl and blog.bar-solutions.com about Oracle topics.
- Plugins for tools like PL/SQL Developer and APEX can be downloaded from his websites.
- Upcoming events include a Steven Feuerstein masterclass on PL/SQL best practices and new
This deck provides an overview of key concepts in Objective-C including MVC architecture, classes, instances, methods, properties, delegates and protocols, Xcode IDE, and common classes and terms. It explains that MVC separates applications into modular and replaceable models, views, and controllers. Classes define properties and methods while instances contain property values. Methods are messages sent to objects. Properties use accessor methods. Header files define public interfaces while implementation files contain private code. Delegates and protocols allow communication between decoupled components.
The document discusses the building blocks of a SystemVerilog testbench. It describes the program block, which encapsulates test code and allows reading/writing signals and calling module routines. Interface and clocking blocks are used to connect the testbench to the design under test. Assertions, randomization, and other features help create flexible testbenches to verify design correctness.
From Monolith to Modules - breaking apart a one size fits all product into mo...Robert Munteanu
This document summarizes a meetup on modularizing monolithic applications. It discusses benefits of modularization like slimmer, simpler code with reduced bugs and clear dependencies. Costs include complex API governance and fragmented deployments. Decoupling patterns for OSGi and content are presented, like glue bundles, optional dependencies, overlays, and feature extraction. Modularized testing is also discussed as a combinatorial nightmare to optimize.
The document provides an overview of Eclipse, an open-source integrated development environment (IDE). It discusses that Eclipse is built on an extensible plugin framework called OSGi/Equinox that allows new functionality to be easily added without disrupting existing features. It also describes key components of the Eclipse platform including SWT for cross-platform user interface elements, JFace for common UI tasks, and the workbench for the Eclipse environment. The document highlights that Eclipse can be used as not just an IDE but also as a general application framework and tools framework through its extensibility.
The document introduces Java collections and generics. It defines a collection as an object representing a group of objects. Collections enable objects to be manipulated independently of implementation details. Using collections offers advantages like reduced programming effort and increased performance. The collection framework uses generics to provide type safety and prevent casting errors. Common type parameters are <E>, <T>, and <K,V> used in maps. Wildcards like ? extend and ? super are also discussed along with examples demonstrating generics.
Here is how we can implement this using the Prototype pattern:
1. Define an abstract Car class with Clone() method
2. Define concrete classes like SportsCar, Sedan etc extending Car
3. Each car stores its design configuration as properties
4. Application maintains a registry of car prototypes
5. When user wants to copy, app clones the prototype and returns new instance
6. User can independently customize cloned car without affecting original
This allows dynamic object copying and meets the requirements. Prototype pattern helps avoid complex object creation and gives flexibility to user for experimenting with different designs efficiently.
The document discusses tools and techniques for making Java development more enjoyable. It recommends using libraries like Mockito, Guice and Guava to simplify testing and dependency injection. It also suggests using builder patterns, writing concise yet descriptive unit tests, and avoiding string-typing in favor of object-oriented types.
This document contains information about Patrick Barel, an Oracle consultant and author. It includes his contact details, areas of expertise, blogs and websites to read, plugins available for download, and upcoming training events he will be presenting. Some key points are:
- Patrick Barel has been working with Oracle technologies like PL/SQL, APEX, and OCA certification since 1997.
- He maintains blogs on technology.amis.nl and blog.bar-solutions.com about Oracle topics.
- Plugins for tools like PL/SQL Developer and APEX can be downloaded from his websites.
- Upcoming events include a Steven Feuerstein masterclass on PL/SQL best practices and new
This deck provides an overview of key concepts in Objective-C including MVC architecture, classes, instances, methods, properties, delegates and protocols, Xcode IDE, and common classes and terms. It explains that MVC separates applications into modular and replaceable models, views, and controllers. Classes define properties and methods while instances contain property values. Methods are messages sent to objects. Properties use accessor methods. Header files define public interfaces while implementation files contain private code. Delegates and protocols allow communication between decoupled components.
The document discusses the building blocks of a SystemVerilog testbench. It describes the program block, which encapsulates test code and allows reading/writing signals and calling module routines. Interface and clocking blocks are used to connect the testbench to the design under test. Assertions, randomization, and other features help create flexible testbenches to verify design correctness.
From Monolith to Modules - breaking apart a one size fits all product into mo...Robert Munteanu
This document summarizes a meetup on modularizing monolithic applications. It discusses benefits of modularization like slimmer, simpler code with reduced bugs and clear dependencies. Costs include complex API governance and fragmented deployments. Decoupling patterns for OSGi and content are presented, like glue bundles, optional dependencies, overlays, and feature extraction. Modularized testing is also discussed as a combinatorial nightmare to optimize.
The document provides an overview of Eclipse, an open-source integrated development environment (IDE). It discusses that Eclipse is built on an extensible plugin framework called OSGi/Equinox that allows new functionality to be easily added without disrupting existing features. It also describes key components of the Eclipse platform including SWT for cross-platform user interface elements, JFace for common UI tasks, and the workbench for the Eclipse environment. The document highlights that Eclipse can be used as not just an IDE but also as a general application framework and tools framework through its extensibility.
The document introduces Java collections and generics. It defines a collection as an object representing a group of objects. Collections enable objects to be manipulated independently of implementation details. Using collections offers advantages like reduced programming effort and increased performance. The collection framework uses generics to provide type safety and prevent casting errors. Common type parameters are <E>, <T>, and <K,V> used in maps. Wildcards like ? extend and ? super are also discussed along with examples demonstrating generics.
Here is how we can implement this using the Prototype pattern:
1. Define an abstract Car class with Clone() method
2. Define concrete classes like SportsCar, Sedan etc extending Car
3. Each car stores its design configuration as properties
4. Application maintains a registry of car prototypes
5. When user wants to copy, app clones the prototype and returns new instance
6. User can independently customize cloned car without affecting original
This allows dynamic object copying and meets the requirements. Prototype pattern helps avoid complex object creation and gives flexibility to user for experimenting with different designs efficiently.
The document discusses tools and techniques for making Java development more enjoyable. It recommends using libraries like Mockito, Guice and Guava to simplify testing and dependency injection. It also suggests using builder patterns, writing concise yet descriptive unit tests, and avoiding string-typing in favor of object-oriented types.
Object-oriented programming (OOP) with Complete understanding modulesDurgesh Singh
The document provides an overview of object-oriented programming concepts in C# such as classes, objects, encapsulation, inheritance, polymorphism, and reusability. It discusses class definitions, constructors, destructors, access modifiers, and provides examples of creating classes and class libraries. Key topics covered include defining fields and methods, instantiating objects, using constructors, creating partial and static classes, and building class library components for reuse across applications.
Gallio is a test automation platform that aims to provide integration between different testing frameworks. It started as a spin-off from MbUnit, a testing framework. Gallio uses a common object model and supports many workflows to unite various testing tools, rather than control them. Implementation challenges include dealing with hostile test code, differences between how frameworks define tests, and mismatches between extensibility models of tools. Gallio's architecture includes abstract test and reflection models to enable polymorphism between frameworks.
Undertaking gate level simulation can put you on the fast track to confusion, frustration, and language more colorful than an X infested simulation waveform. This paper will look at the reasons for doing gate level simulation anyway, describe design and library "features" that can cause gate level simulation problems, and discuss potential solutions to these problems.
This document provides instructions for several StreamSets Academy labs:
1. The "Lab: Set Up a Deployment" lab guides the user to create a deployment in StreamSets Cloud, generate an install script, and register execution engines to the deployment from their lab environment.
2. The "Lab: First Pipeline to Test Deployment" lab has the user build a simple pipeline with a dev data generator origin and trash destination to test their new deployment.
3. The "Lab: Build a Pipeline" lab modifies the first pipeline to connect to real data from the Zomato dataset using a directory origin and adds a stream selector processor and local FS destination.
4. The "Lab: Run a
Petrel Ocean wizards and developers tools 2013SohrabRoshan
The document provides information about tools in Visual Studio for creating Ocean plug-ins and modules. It describes the Ocean Wizard for generating plug-in and module projects. The key steps covered include:
- Creating an Ocean plug-in project using the wizard
- Adding processes and worksteps to a plug-in project
- Adding menu extensions to Petrel menus
- Adding tree extensions to the Petrel tree
The wizard simplifies the creation of various module elements like windows, worksteps, menus, and tree extensions. It generates the necessary class files and registration code.
Symfony HTTP Kernel for refactoring legacy apps: the eZ Publish case study - ...Gaetano Giunta
This document summarizes a presentation about migrating an existing 10-year old content management system built with eZ Publish to Symfony2. Key points discussed include:
- The existing codebase has high maintenance costs and technical debt that makes it difficult to support new features.
- Symfony2 is chosen as the new framework due to its support for features needed like dependency injection, routing, and caching.
- Backwards compatibility is a major challenge to ensure existing customers are not upset by changes in the new system. The new system will maintain the same database schema and support including legacy templates.
PVS-Studio Is Now in Chocolatey: Checking Chocolatey under Azure DevOpsAndrey Karpov
The document discusses integrating the PVS-Studio static code analyzer with Azure DevOps and Chocolatey. It provides steps to configure a build pipeline in Azure DevOps to install PVS-Studio using Chocolatey, run analysis on a project, and publish the results. The analysis found several potential bugs in the Chocolatey code including logical errors, redundant checks, and null reference issues. Integrating PVS-Studio with these tools helps improve code quality.
Templates and Exception Handling in C++Nimrita Koul
This document discusses templates and exception handling in C++. It provides an overview of templates, including why they are used for generic programming and how to define function and class templates. Exception handling in C++ uses try, catch, and throw blocks. The try block contains code that may throw exceptions, catch blocks handle specific exceptions, and throw explicitly throws an exception. The document contains examples of templates, exception handling, and derived class exceptions. It also discusses opportunities available at the School of CIT at Reva University.
This document provides an overview of Backbone.js, a lightweight JavaScript library that adds structure to client-side code. It discusses that Backbone.js is commonly used to create single-page applications and explains some of its key features and components. Models contain data and logic, views handle presentation, and collections manage sets of models. It also touches on events, listening to events, and Backbone's dependencies on other libraries like Underscore.js.
The Ring programming language version 1.8 book - Part 95 of 202Mahmoud Samir Fayed
The document provides code examples for creating a GUI application with Ring that includes two buttons. It shows how to create a main window and two buttons, set their properties like geometry, text, and click events. It also shows how to call a function from a button click event and create a second window.
Kamailio World 2018 - Workshop: kamailio-testsGiacomo Vacca
This document discusses kamailio-tests, a testing framework for Kamailio. It aims to provide unit tests for Kamailio's core and module functionality to reduce the need for end-to-end testing. The framework uses Docker to allow tests to run across different operating systems and distributions. Unit tests are contained in directories and test scripts, and a control script can run all tests or specific ones. The document outlines the project structure, current test units, and future development plans to expand testing.
The document discusses and compares two popular ActionScript frameworks: PureMVC and Robotlegs. It provides an overview of why frameworks are used, describes some common design patterns implemented in frameworks, and highlights key features and strengths/weaknesses of PureMVC and Robotlegs.
Creating Realistic Unit Tests with TestcontainersPaul Balogh
** Recording available at https://www.youtube.com/watch?v=sX4s1HqPZcw **
Sometimes, unit tests with mocked services just aren't enough. We'd like to be able to run repeatable tests against the real thing without fear of corrupting data or affecting others.
With Testcontainers, there is no need for mocks or complicated environment configurations. We can define our target environment in code and then run our tests against ephemeral containers. Java developers have had this ability for several years, but now Go developers have this similar ability!
Enjoy the discussion and demonstration of this open-source project created by the folks at AtomicJar, recently acquired by Docker.
Level Up Your Integration Testing With TestcontainersVMware Tanzu
The document discusses Testcontainers, a Java library that makes it easy to create lightweight, disposable Docker containers to support integration testing. Testcontainers allows developers to start containers for databases, browsers, and other services via simple annotations and eliminates the need to manage complex Docker configurations and container lifecycles manually. It integrates with JUnit and handles starting a new container before each test and cleaning it up afterwards, improving testing fidelity by mimicking production environments.
javagruppen.dk - e4, the next generation Eclipse platformTonny Madsen
After 13 years, the Eclipse framework gets it second make-over. The new work is termed e4 and will be included in Eclipse 4.0.
In the first make-over the run-time was replaced in Eclipse 3.0 with OSGi to get a better and more stable foundation for plug-ins. This time the user interface and contributions are modernized for use in Eclipse 4.0.
In this session, we will see some of the insides of the new paradigms in e4.
Agenda
Setting up an angular app.
Introduction to tools - Babel, Webpack
Alternative to Gulp, Grunt & Bower.
Writing Controllers, Services, Directives etc..
Testing Javascript with Jasmine.
Setting up Karma with Webpack.
Let’s understand code coverage.
An alternative: JEST
Top 7 Angular Best Practices to Organize Your Angular AppKaty Slemon
Learn about Angular best practices to improve the performance of your existing Angular application. Tried and tested clean code checklist for your Angular app.
The document discusses developing replication plugins for Drizzle, an open source database. It provides an overview of Drizzle's architecture and replication system. Key points include that Drizzle uses a plugin model where most features are built as plugins, and that replication is based on transmitting "Transaction" messages between plugins using Google Protocol Buffers for serialization.
This document discusses object-oriented programming concepts in Objective-C, including classes and objects, properties, methods, interfaces, implementations, memory management, and properties. It provides code examples for defining a Car class with properties like model and methods like drive(). It demonstrates creating instances of the Car class, setting properties, and calling methods.
This document provides an overview of OCL syntax for navigating objects and collections. It discusses how to access attributes of an object using "self.attribute" and navigate to the opposite end of an association using role names. It provides examples of navigating from a Company context to retrieve employees and from a Person context to retrieve their employer. It also discusses OCL types like PrimitiveType, CollectionType, and operations available on collections like select, reject, collect, iterate, and examples of using these operations.
Este documento presenta una guía sobre CSS. Explica tres formas de escribir código CSS: dentro del archivo HTML, en un archivo CSS externo o dentro de una etiqueta HTML. Luego describe conceptos como selectores, IDs, clases y cómo usar propiedades CSS como color, tipografía, tamaño de fuente, alineación de texto y estilos de lista y borde. El objetivo es enseñar los fundamentos de CSS para dar estilo a páginas web.
Object-oriented programming (OOP) with Complete understanding modulesDurgesh Singh
The document provides an overview of object-oriented programming concepts in C# such as classes, objects, encapsulation, inheritance, polymorphism, and reusability. It discusses class definitions, constructors, destructors, access modifiers, and provides examples of creating classes and class libraries. Key topics covered include defining fields and methods, instantiating objects, using constructors, creating partial and static classes, and building class library components for reuse across applications.
Gallio is a test automation platform that aims to provide integration between different testing frameworks. It started as a spin-off from MbUnit, a testing framework. Gallio uses a common object model and supports many workflows to unite various testing tools, rather than control them. Implementation challenges include dealing with hostile test code, differences between how frameworks define tests, and mismatches between extensibility models of tools. Gallio's architecture includes abstract test and reflection models to enable polymorphism between frameworks.
Undertaking gate level simulation can put you on the fast track to confusion, frustration, and language more colorful than an X infested simulation waveform. This paper will look at the reasons for doing gate level simulation anyway, describe design and library "features" that can cause gate level simulation problems, and discuss potential solutions to these problems.
This document provides instructions for several StreamSets Academy labs:
1. The "Lab: Set Up a Deployment" lab guides the user to create a deployment in StreamSets Cloud, generate an install script, and register execution engines to the deployment from their lab environment.
2. The "Lab: First Pipeline to Test Deployment" lab has the user build a simple pipeline with a dev data generator origin and trash destination to test their new deployment.
3. The "Lab: Build a Pipeline" lab modifies the first pipeline to connect to real data from the Zomato dataset using a directory origin and adds a stream selector processor and local FS destination.
4. The "Lab: Run a
Petrel Ocean wizards and developers tools 2013SohrabRoshan
The document provides information about tools in Visual Studio for creating Ocean plug-ins and modules. It describes the Ocean Wizard for generating plug-in and module projects. The key steps covered include:
- Creating an Ocean plug-in project using the wizard
- Adding processes and worksteps to a plug-in project
- Adding menu extensions to Petrel menus
- Adding tree extensions to the Petrel tree
The wizard simplifies the creation of various module elements like windows, worksteps, menus, and tree extensions. It generates the necessary class files and registration code.
Symfony HTTP Kernel for refactoring legacy apps: the eZ Publish case study - ...Gaetano Giunta
This document summarizes a presentation about migrating an existing 10-year old content management system built with eZ Publish to Symfony2. Key points discussed include:
- The existing codebase has high maintenance costs and technical debt that makes it difficult to support new features.
- Symfony2 is chosen as the new framework due to its support for features needed like dependency injection, routing, and caching.
- Backwards compatibility is a major challenge to ensure existing customers are not upset by changes in the new system. The new system will maintain the same database schema and support including legacy templates.
PVS-Studio Is Now in Chocolatey: Checking Chocolatey under Azure DevOpsAndrey Karpov
The document discusses integrating the PVS-Studio static code analyzer with Azure DevOps and Chocolatey. It provides steps to configure a build pipeline in Azure DevOps to install PVS-Studio using Chocolatey, run analysis on a project, and publish the results. The analysis found several potential bugs in the Chocolatey code including logical errors, redundant checks, and null reference issues. Integrating PVS-Studio with these tools helps improve code quality.
Templates and Exception Handling in C++Nimrita Koul
This document discusses templates and exception handling in C++. It provides an overview of templates, including why they are used for generic programming and how to define function and class templates. Exception handling in C++ uses try, catch, and throw blocks. The try block contains code that may throw exceptions, catch blocks handle specific exceptions, and throw explicitly throws an exception. The document contains examples of templates, exception handling, and derived class exceptions. It also discusses opportunities available at the School of CIT at Reva University.
This document provides an overview of Backbone.js, a lightweight JavaScript library that adds structure to client-side code. It discusses that Backbone.js is commonly used to create single-page applications and explains some of its key features and components. Models contain data and logic, views handle presentation, and collections manage sets of models. It also touches on events, listening to events, and Backbone's dependencies on other libraries like Underscore.js.
The Ring programming language version 1.8 book - Part 95 of 202Mahmoud Samir Fayed
The document provides code examples for creating a GUI application with Ring that includes two buttons. It shows how to create a main window and two buttons, set their properties like geometry, text, and click events. It also shows how to call a function from a button click event and create a second window.
Kamailio World 2018 - Workshop: kamailio-testsGiacomo Vacca
This document discusses kamailio-tests, a testing framework for Kamailio. It aims to provide unit tests for Kamailio's core and module functionality to reduce the need for end-to-end testing. The framework uses Docker to allow tests to run across different operating systems and distributions. Unit tests are contained in directories and test scripts, and a control script can run all tests or specific ones. The document outlines the project structure, current test units, and future development plans to expand testing.
The document discusses and compares two popular ActionScript frameworks: PureMVC and Robotlegs. It provides an overview of why frameworks are used, describes some common design patterns implemented in frameworks, and highlights key features and strengths/weaknesses of PureMVC and Robotlegs.
Creating Realistic Unit Tests with TestcontainersPaul Balogh
** Recording available at https://www.youtube.com/watch?v=sX4s1HqPZcw **
Sometimes, unit tests with mocked services just aren't enough. We'd like to be able to run repeatable tests against the real thing without fear of corrupting data or affecting others.
With Testcontainers, there is no need for mocks or complicated environment configurations. We can define our target environment in code and then run our tests against ephemeral containers. Java developers have had this ability for several years, but now Go developers have this similar ability!
Enjoy the discussion and demonstration of this open-source project created by the folks at AtomicJar, recently acquired by Docker.
Level Up Your Integration Testing With TestcontainersVMware Tanzu
The document discusses Testcontainers, a Java library that makes it easy to create lightweight, disposable Docker containers to support integration testing. Testcontainers allows developers to start containers for databases, browsers, and other services via simple annotations and eliminates the need to manage complex Docker configurations and container lifecycles manually. It integrates with JUnit and handles starting a new container before each test and cleaning it up afterwards, improving testing fidelity by mimicking production environments.
javagruppen.dk - e4, the next generation Eclipse platformTonny Madsen
After 13 years, the Eclipse framework gets it second make-over. The new work is termed e4 and will be included in Eclipse 4.0.
In the first make-over the run-time was replaced in Eclipse 3.0 with OSGi to get a better and more stable foundation for plug-ins. This time the user interface and contributions are modernized for use in Eclipse 4.0.
In this session, we will see some of the insides of the new paradigms in e4.
Agenda
Setting up an angular app.
Introduction to tools - Babel, Webpack
Alternative to Gulp, Grunt & Bower.
Writing Controllers, Services, Directives etc..
Testing Javascript with Jasmine.
Setting up Karma with Webpack.
Let’s understand code coverage.
An alternative: JEST
Top 7 Angular Best Practices to Organize Your Angular AppKaty Slemon
Learn about Angular best practices to improve the performance of your existing Angular application. Tried and tested clean code checklist for your Angular app.
The document discusses developing replication plugins for Drizzle, an open source database. It provides an overview of Drizzle's architecture and replication system. Key points include that Drizzle uses a plugin model where most features are built as plugins, and that replication is based on transmitting "Transaction" messages between plugins using Google Protocol Buffers for serialization.
This document discusses object-oriented programming concepts in Objective-C, including classes and objects, properties, methods, interfaces, implementations, memory management, and properties. It provides code examples for defining a Car class with properties like model and methods like drive(). It demonstrates creating instances of the Car class, setting properties, and calling methods.
This document provides an overview of OCL syntax for navigating objects and collections. It discusses how to access attributes of an object using "self.attribute" and navigate to the opposite end of an association using role names. It provides examples of navigating from a Company context to retrieve employees and from a Person context to retrieve their employer. It also discusses OCL types like PrimitiveType, CollectionType, and operations available on collections like select, reject, collect, iterate, and examples of using these operations.
Este documento presenta una guía sobre CSS. Explica tres formas de escribir código CSS: dentro del archivo HTML, en un archivo CSS externo o dentro de una etiqueta HTML. Luego describe conceptos como selectores, IDs, clases y cómo usar propiedades CSS como color, tipografía, tamaño de fuente, alineación de texto y estilos de lista y borde. El objetivo es enseñar los fundamentos de CSS para dar estilo a páginas web.
Este diagrama muestra las relaciones entre países, provincias, ciudades y continentes. Indica que los países contienen provincias y ciudades, las provincias limitan con otros países y provincias y contienen ciudades, y las ciudades están dentro de provincias.
Esta figura describe las propiedades básicas de varias formas geométricas comunes como triángulos, elipses, cuadrilateros, rectángulos, cuadrados y círculos. También incluye polígonos más generales y define los conceptos fundamentales de puntos y lados que comparten todas las figuras.
El documento presenta una discusión sobre el concepto de administración. Define administración desde la perspectiva de varios autores y destaca que involucra procesos como la planeación, organización, ejecución y control para lograr los objetivos de una organización de manera eficiente a través del uso de personas y recursos. Explica que la administración es importante para optimizar recursos, maximizar la productividad, eficiencia y calidad, y mejorar la competitividad de una organización.
Este documento resume los conceptos clave sobre la administración y los roles de los gerentes. Explica que los gerentes coordinan y supervisan el trabajo de los empleados para lograr los objetivos de la organización, mientras que los empleados realizan tareas directas sin supervisar a otros. Además, describe las funciones de los gerentes según Fayol y los roles interpersonales, informativos y decisorios de los gerentes según Mintzberg, así como las habilidades gerenciales clave según Katz.
La planeación es el proceso de establecer objetivos y estrategias para lograrlos en el futuro. Incluye definir una misión, visión, objetivos, metas, estrategias, políticas, programas, procedimientos y presupuestos. Requiere tomar decisiones sobre cursos de acción futuros. La planeación da sentido de dirección, facilita el control y reduce la incertidumbre. Existen planes estratégicos, operacionales, por alcance, horizonte temporal, especificidad y frecuencia de uso.
This document discusses proper sentence structure when writing research papers in English. It explains that sentences can have smaller clauses or "boxes" within the overall structure. Two examples are provided to illustrate sentences with one or two subjects. The first has a single clause with the structure of subject + verb + predicate. The second contains a second, smaller subject + verb + predicate clause within the main predicate. Proper referents are emphasized to clearly link clauses without ambiguity.
Poultry interventions have the potential to improve livelihoods for poor women in developing nations. Poultry production provides an entry point for accumulating social and financial capital. This can help women and their families escape the "deprivation trap" of multidimensional poverty. Improved poultry production also enhances family nutrition by providing micronutrients through consumption of meat, eggs, and liver. A research project in Tanzania and Zambia aims to reduce childhood undernutrition by analyzing opportunities to strengthen household nutrition through more efficient integration of poultry and crop production.
ViewShift: Hassle-free Dynamic Policy Enforcement for Every Data LakeWalaa Eldin Moustafa
Dynamic policy enforcement is becoming an increasingly important topic in today’s world where data privacy and compliance is a top priority for companies, individuals, and regulators alike. In these slides, we discuss how LinkedIn implements a powerful dynamic policy enforcement engine, called ViewShift, and integrates it within its data lake. We show the query engine architecture and how catalog implementations can automatically route table resolutions to compliance-enforcing SQL views. Such views have a set of very interesting properties: (1) They are auto-generated from declarative data annotations. (2) They respect user-level consent and preferences (3) They are context-aware, encoding a different set of transformations for different use cases (4) They are portable; while the SQL logic is only implemented in one SQL dialect, it is accessible in all engines.
#SQL #Views #Privacy #Compliance #DataLake
State of Artificial intelligence Report 2023kuntobimo2016
Artificial intelligence (AI) is a multidisciplinary field of science and engineering whose goal is to create intelligent machines.
We believe that AI will be a force multiplier on technological progress in our increasingly digital, data-driven world. This is because everything around us today, ranging from culture to consumer products, is a product of intelligence.
The State of AI Report is now in its sixth year. Consider this report as a compilation of the most interesting things we’ve seen with a goal of triggering an informed conversation about the state of AI and its implication for the future.
We consider the following key dimensions in our report:
Research: Technology breakthroughs and their capabilities.
Industry: Areas of commercial application for AI and its business impact.
Politics: Regulation of AI, its economic implications and the evolving geopolitics of AI.
Safety: Identifying and mitigating catastrophic risks that highly-capable future AI systems could pose to us.
Predictions: What we believe will happen in the next 12 months and a 2022 performance review to keep us honest.
Learn SQL from basic queries to Advance queriesmanishkhaire30
Dive into the world of data analysis with our comprehensive guide on mastering SQL! This presentation offers a practical approach to learning SQL, focusing on real-world applications and hands-on practice. Whether you're a beginner or looking to sharpen your skills, this guide provides the tools you need to extract, analyze, and interpret data effectively.
Key Highlights:
Foundations of SQL: Understand the basics of SQL, including data retrieval, filtering, and aggregation.
Advanced Queries: Learn to craft complex queries to uncover deep insights from your data.
Data Trends and Patterns: Discover how to identify and interpret trends and patterns in your datasets.
Practical Examples: Follow step-by-step examples to apply SQL techniques in real-world scenarios.
Actionable Insights: Gain the skills to derive actionable insights that drive informed decision-making.
Join us on this journey to enhance your data analysis capabilities and unlock the full potential of SQL. Perfect for data enthusiasts, analysts, and anyone eager to harness the power of data!
#DataAnalysis #SQL #LearningSQL #DataInsights #DataScience #Analytics
Unleashing the Power of Data_ Choosing a Trusted Analytics Platform.pdfEnterprise Wired
In this guide, we'll explore the key considerations and features to look for when choosing a Trusted analytics platform that meets your organization's needs and delivers actionable intelligence you can trust.
06-04-2024 - NYC Tech Week - Discussion on Vector Databases, Unstructured Data and AI
Discussion on Vector Databases, Unstructured Data and AI
https://www.meetup.com/unstructured-data-meetup-new-york/
This meetup is for people working in unstructured data. Speakers will come present about related topics such as vector databases, LLMs, and managing data at scale. The intended audience of this group includes roles like machine learning engineers, data scientists, data engineers, software engineers, and PMs.This meetup was formerly Milvus Meetup, and is sponsored by Zilliz maintainers of Milvus.
The Building Blocks of QuestDB, a Time Series Databasejavier ramirez
Talk Delivered at Valencia Codes Meetup 2024-06.
Traditionally, databases have treated timestamps just as another data type. However, when performing real-time analytics, timestamps should be first class citizens and we need rich time semantics to get the most out of our data. We also need to deal with ever growing datasets while keeping performant, which is as fun as it sounds.
It is no wonder time-series databases are now more popular than ever before. Join me in this session to learn about the internal architecture and building blocks of QuestDB, an open source time-series database designed for speed. We will also review a history of some of the changes we have gone over the past two years to deal with late and unordered data, non-blocking writes, read-replicas, or faster batch ingestion.
STATATHON: Unleashing the Power of Statistics in a 48-Hour Knowledge Extravag...sameer shah
"Join us for STATATHON, a dynamic 2-day event dedicated to exploring statistical knowledge and its real-world applications. From theory to practice, participants engage in intensive learning sessions, workshops, and challenges, fostering a deeper understanding of statistical methodologies and their significance in various fields."
1. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 1/16
Acceleo Best Practices
Need help to develop your code generators?
These best practices reflect the expertise (/services/code-generation-tools) of Obeo engineers who have
developped Acceleo.
They can help you develop or tune your own Acceleo-based code generators.
Contact us (/en/contact)
The following best practices apply to Acceleo 3.0.x and Acceleo 3.1.x.
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
2. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 2/16
A. Naming conventions
B. Architecture of an Acceleo project
C. Writing a good module
D. Usage of Java services
E. Preventing problems with traceability information
F. Testing an Acceleo generator
G. Managing user code
A. Naming conventions
An Acceleo project is an Eclipse plugin project and as such it should be named following this structure:
<domain><project name (optional)><kind of input (optional)><input metamodel name>gen<output language name>
Example: com.mydomain.myproject.pim.uml.gen.java
The kind of input being "pim (http://en.wikipedia.org/wiki/Platform-independent_model)" (Platform Independent
Model), "psm (http://en.wikipedia.org/wiki/Platform-specific_model)" (Platform Specific Model) or "dsl
(http://en.wikipedia.org/wiki/Domain-specific_language)" (Domain Specific Language).
A. 1. Modules, templates and queries
Acceleo modules, templates queries and variables must use camel case name starting with a lower case character.
Example: myModule, myAmazingTemplate, etc.
A. 2. Variables
Variables should also be named using a camel case name starting with a lower case "a" or "an" and followed by the
name of the type or the name of the feature.
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
3. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 3/16
Example: aVariable, anElement, anOwnedComment.
A. 3. Reserved Keywords
Do not use any OCL or Acceleo keyword for the name of your modules, templates, queries or variables.
Acceleo keywords: module, import, extends, template, query, public, private, protected, guard, init,overrides,
each, before, after, for, if, elseif, else, let, elselet, trace, macro,file, mode, text_explicit, code_explicit, super,
stdout
OCL keywords: and, body, context, def, derive, else, end, if, endpackage, false, if, implies, in, init, inv, invalid,
let, not, null, or, package, post, pre, self, static, then, true, xor
B. Architecture of an Acceleo project
B. 1. Root package
The root package of an Acceleo project should share the same name as the project.
Example: com.mydomain.myproject.pim.uml.gen.java
B. 2. Organization of the packages
Every Acceleo project should contain several key packages.
main (this package contains all the module with main templates and their matching launcher class)
files (this package contains all the module that will generate a file)
common (this package contains all the utility modules)
request (this packages contains all the modules that contains utility requests on the input model)
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
4. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 4/16
services (this package contains all the modules that wrapped Java classes)
properties (this packages contains all the properties files)
(/images/products/screenshots/acceleo/ProjectStructure.png)
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
5. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 5/16
Example: the module generating a Java class could be named "classFile" and it should be in the package named
"files". All the other modules related to the generation of the Java class can be contained in the package
"common.classfile" for example "imports.mtl", "attributes.mtl", methods.mtl" etc.
B. 3. Exporting packages
The main package, the properties package and the service package should be exported. Java services will not work
when the generator is deployed if the package containing those package is not exported in the MANIFEST.MF
(runtime tab). It is recommended to export all the other packages but to keep them "hidden from all the plugins".
C. Writing a good module
When writing an Acceleo module, there are some rules that should be respected:
C. 1. Null in Acceleo
In Acceleo and in OCL, "null" is "OclUndefined", when you are testing for a "null" variable, you should use
"isOclUndefined()".
C. 2. Let block
In Acceleo, the "let" block is strictly equals to an 'if instanceof". For example, those two expressions are equals: "[let
x: Type = myExpression]|x.doSomething()/][/let]" and "[if (myExpression.oclIsKindOf(Type))]
[myExpression.oclAsType(Type).doSomething()/][/if]". Keep in mind that if your expression initializing the "let
variable" returns null, then Acceleo will not enter the "let block".
C. 3. Features named as a reserved keyword
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
6. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 6/16
Do not use Acceleo or OCL keywords in your expressions, for example, if you have to manipulate a feature named
body, instead of [myElement.body/] you should use [myElement._body/] since body is an OCL keyword.
C. 4. Context in Acceleo blocks
Do not use the implicit context to call an operation [myOperation()], always use an explicit variable
[myVariable.myOperation()/]. In this example, you can see what Acceleo will call with implicit variable. The result may
not be what you had in mind.
(/images/products/screenshots/acceleo/Implicit.png)
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
7. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 7/16
C. 5. Implicit variables
you should always use Acceleo operation with an explicit source for the operation
[myExplicitSource.myOperation(myFirstParameter, mySecondParameter)/] and not an implicit source
[myOperation(myFirstParameter, mySecondParameter)/]. If the operation does not have an implicit source, you may
not easily know which template or query will be called as you can see it in this example.
(/images/products/screenshots/acceleo/ImplicitSource.png)
C. 6. Documentation
Acceleo 3.1 has introduced a documentation block, it should be use to write the documentation of the templates,
queries, modules and variables.
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
8. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 8/16
(http://api.ning.com:80/files/BMK20lP7yF1**OY25c0CFc*1tnxa9IrvUQ3lZku6BJ*vBfCpaMo-
4oVIEY7LaBpXpdW1ALPLh50Im8eq2C8uU1WjJMhTd*ct/Documentation.png)
(/images/products/screenshots/acceleo/Documentation.png)
C. 7. Metrics
An Acceleo module should follow the same conventions regarding its metric as a Java class. It is thus not
recommended to have an Acceleo module with more than 30 templates and queries or with several thousands lines.
C. 8. Use of the qualified name to import or extend a module.
All the "import" or "extend" declaration should always use the qualified name of the imported or extended module
[import com::mydomain::myproject:: (...) ::myModule/] and not the simple name [myModule/]. If you use the simple
name, the first module found with the same simple name will be used.
(/images/products/screenshots/acceleo/Imports.png)
C. 9. Polymorphism
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
9. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 9/16
Polymorphism should be preferred to "[for ()] [if (a.oclIsKindOf(A))][elseif (a.oclIsKindOf(B))][elseif (a.oclIsKindOf(C))]
[/if] [/for]". If the common parent of all the type concerned by the polymorphism on a template does not generate
anything, it should at least generate a comment indicating that the given element is not taken into account.
(/images/products/screenshots/acceleo/Polymorphism.png)
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
10. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 10/16
C. 10. Generated file name
When generating a file, the path of the file should be calculated by a query. It is recommended to use queries to
calculate repetitive piece of code because a query will keep its result in cache (if you call the query again with the
same parameter, Acceleo will not re-evaluate the query, it will return the result of the query during the previous
evaluation with the same parameter).
C. 11. Granularity of an Acceleo module
While writing a module, you should think about the re-use of your generator. As such, it is recommended to have a
very small granularity for your templates even if it seems trivial. In the following example, you can see a template to
generate the name of any NamedElement. One would imagine that a template like this would be useless but if you
want to change the naming convention of all the element of your generator, you just have one template to change or
to override.
C. 12. Usage of the visibility of templates and queries
Templates and queries have a visibility, it is recommended to use as much as possible the private and protected
visibility in order to minimize the amount of template and queries in the API of the generator.
C. 13. Parenthesis in "for" and "let" blocks
Parenthesis in the "if" and "for" block should always be used.
C. 14. Entry point of a generation
It is strongly recommended to start a generation with only one entry point. In order to improve performances, there
should be at best only one main module with only one main template and this main template should take the whole
model to prevent several call to this main template. Each call to a main template by Acceleo will launch a new
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
11. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 11/16
initialization of the context of the generation and it can have an impact on the generation (the cache of the queries is
cleared, the cross referencer used for "eInverse()" is cleared too, etc).
C. 15. New cast to EObject except while generating on Ecore
If you are not generating on the Ecore metamodel (http://www.eclipse.org/2002/Ecore
(http://www.eclipse.org/2002/Ecore)), you should not try to cast anything to one of Ecore classes. If you want to
define a very generic template, you should use OclAny as the type of your variables.
C. 16. Comparing enumeration literals
In order to compare an enumeration literal, you have to do: MyObject.myEnumValue =
MyEumeration::myEnumerationLiteral.
C. 17. Manipulation of the result of a Java services
It is highly recommanded not to manipulate directly the result of an "invoke" but instead, to return the raw result as
the result of the query and then manipulate the result of the query. In the following screenshot, the result of the
query seems to be a Sequence of String while it is in reality a Sequence of Sequence of String.
The operation will return a Sequence of String (List<String> in the Java operation) but the Acceleo parser uses the
signature of the operation invoke, as such the result is "OclAny" (the engine will make sure that this OclAny is a
Sequence of String in reality). By using the type OclAny, the parser sees OclAny->asSequence() and thus the
operation is compiled as Set(OclAny)->asSequence(). When the engine executes the call to "invoke", its result
"replaces" the OclAny and as a result we obtain a Set(Sequence(String)) which is then pass to "->asSequence()" and
the final result is "Sequence(Sequence(String))".
C. 18. Defining constants
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
12. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 12/16
In order to define constants for an Acceleo generator, it is recommended to use properties files. If you want to know
more about properties files, have a look at the properties files guide (http://www.obeonetwork.com/page/acceleo-
properties-files) for Acceleo 3.1.1+
C. 19. Performances
Some operations in Acceleo can be time consuming and as such it is recommended to embed them inside of a query
to take advantage of the cache of the query. Among those operations, you can find "eAllContents()",
"eAllContents(OclType)" which are both iterating on the whole subtree of the current model element and "eInverse()"
which needs to initialize a cross referencer on the whole model the first time it is used.
D. Usage of Java services
D. 1. Role of Java services
Java services should be used to query the model and to filter the element of the model. It is not recommended to
use Java services to return large amount of text. The text should be generated by Acceleo templates.
D. 2. Java services and queries
Java services should be wrapped in a query in order to minimize their impact in the generation by having a cache of
their result and so as to only manipulate Acceleo concepts (templates and queries) in most of the generator.
D. 3. Java services and primitive type
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
13. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 13/16
It is recommended to minimize the use of Acceleo primitive as input parameter or output of Java services.
D. 4. Integration of Java services
Java services should not be called directly from a template without being wrapped in a query.
E. Preventing problems with traceability
information
In order to prevent problems with the traceability information calculated by Acceleo some conventions need to be
followed.
E. 1. Modification of the generated code
The generated text should not be heavily modified. Any modification of the generated code will create problems with
the traceability information calculated by Acceleo. Obeo Traceability can handle some modifications of the
generated code but a massive change of the generated code like the use of a formatter on the generated code
would create massive gaps between the traceability information and the code. The formatting of the generated code
should be handle by formatting correctly the Acceleo templates.
E. 2. Java services and traceability information
It is recommended not to use Java services to generated code. Java services should be use to query the model and
return one or several model elements. The code should be generated by Acceleo templates. Java services that are
taking primitive types as parameter (int, string, float, char, etc.) and that are returning a primitive type too can create
problems to the traceability information. In order to link the values returned by a Java service it is recommended to
use at least one element from the model.
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
14. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 14/16
E. 3. Parameters of templates an queries
The use of templates or queries without any parameters is also not recommended. In order to link the generated
text with a model element, Acceleo needs a model element as a parameter of the template or the query.
F. Testing an Acceleo generator
Like any project, a code generator evolves and to make sure that regression are detected it is recommended to
maintain along with the generator a test project with a non regression model. This non regression model should
contain all the type of model elements that are being handled by the generator. The test project should also contain
the code generated form this non regression model with the generator. When a modification of the generator is
done, the new generator should be launched once again with the non regression model as its input and then the
new generated code should be compared with the old generated code to ensure that no features of the code
generator has broke.
G. Managing user code
One of the key best practices in code generation is to generate code as if you would write it manually.
Nevertheless, mixing generated code and hand-written code in the same file is one of the main causes of
desynchronization between model and generated code. The traceability functionnality reduces this risk, but it can't
solve all the cases of desynchronization.
To minimize this risk, when it does not alter the quality or the performance of the code, you can break the rule
mentionned previously, by separating generated code and hand-written code in different files. There exists several
patterns depending on the implementation language (subclassing generated classes by hand-written classes in java,
partial classes in C#).
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)
15. 21/9/22, 15:33 Acceleo Best Practices - Obeo
https://www.obeosoft.com/en/acceleo-best-practices 15/16
/ Home (/en/) / Acceleo Best Practices
Solutions (/en/solutions)
Systems Engineering (/en/solutions/systems-
engineering)
Enterprise Architecture (/en/solutions/digital-
transformation)
Software Development (/en/solutions/software-
factories)
Other Domains
(https://www.obeodesigner.com/en/services)
Products (/en/products)
Obeo SmartEA (http://www.obeosmartea.com)
Obeo Designer (http://www.obeodesigner.com)
Team for Capella (/en/capella-professional-
offer#collaboration)
Sirius
(http://www.obeodesigner.com/product/sirius)
Acceleo (http://www.eclipse.org/acceleo)
UML Designer (http://www.umldesigner.org)
M2Doc (http://www.m2doc.org/)
Obeo Enterprise for POOSL (/en/obeo-enterprise-
for-poosl)
Information System Designer (/en/products/is-
designer)
Services (/en/services)
Training (/en/services/training)
Coaching (/en/services/coaching)
Custom Development (/en/services/custom-
development)
Support & Maintenance (/en/services/support-
maintenance)
Modeling Tools
(https://www.obeodesigner.com/en/services)
Code Generation Tools (/en/services/code-
generation-tools)
Eclipse Plug-ins (/en/services/plugins)
Ressources (/fr/communaute)
Blog (https://blog.obeosoft.com)
Videos
(https://www.youtube.com/user/obeocorp)
Presentations
(https://fr.slideshare.net/Obeo_corp/clipboards)
Github - Obeo Network
(https://github.com/ObeoNetwork)
Company (/en/company)
About us (/en/company#about-us)
Customers (/en/company/customers)
Partners (/en/company/partners)
ter.com/obeo_corp)
youtube.com/user/obeocorp)
.obeosoft.com)
ontact)