EFL (The Enlightenment Foundation Libraries) were written to support the development of Enlightenment, and ultimately became a complete toolkit for making applications for desktops and especially lower powered devices like phones and tablets. The focus on achieving great effects, ease of programming and lean efficiency has attracted some major players to EFL, such as Samsung Electronics. EFL is being used in development for their next generation devices. Find out about EFL.
Next generation mobile gp us and rendering techniques - niklas smedbergMary Chan
This session provides a detailed analysis of next-generation mobile graphics hardware and points out special caveats and opportunities that are specific to mobile. This is followed by an in-depth explanation of advanced rendering techniques that were previously only considered for high-end PCs or dedicated gaming consoles, but which have now been brought over to mobile devices in Unreal Engine 4 - including features such as physically-based rendering, HDR and image-based lighting.
A presentation on the Unreal Engine, a game engine used for developing games for various platforms like PC, PS4, Xbox1, etc.
For more visit: http://paradoxland.com and http://funfactsabout.net
West Coast DevCon 2014: The Slate UI Framework (Part 1) - IntroductionGerke Max Preussner
Overview of the Slate user interface framework and low-level UI capabilities in Unreal Engine 4. Presented at West Coast Unreal Engine DevCon 2014 in San Francisco and Seattle.
West Coast DevCon 2014: Build Automation - Epic’s Build Tools & InfrastructureGerke Max Preussner
Overview of build tools, build automation, source code management and automated testing infrastructure at Epic Games. Presented at West Coast Unreal Engine DevCon 2014 in San Francisco and Seattle.
Next generation mobile gp us and rendering techniques - niklas smedbergMary Chan
This session provides a detailed analysis of next-generation mobile graphics hardware and points out special caveats and opportunities that are specific to mobile. This is followed by an in-depth explanation of advanced rendering techniques that were previously only considered for high-end PCs or dedicated gaming consoles, but which have now been brought over to mobile devices in Unreal Engine 4 - including features such as physically-based rendering, HDR and image-based lighting.
A presentation on the Unreal Engine, a game engine used for developing games for various platforms like PC, PS4, Xbox1, etc.
For more visit: http://paradoxland.com and http://funfactsabout.net
West Coast DevCon 2014: The Slate UI Framework (Part 1) - IntroductionGerke Max Preussner
Overview of the Slate user interface framework and low-level UI capabilities in Unreal Engine 4. Presented at West Coast Unreal Engine DevCon 2014 in San Francisco and Seattle.
West Coast DevCon 2014: Build Automation - Epic’s Build Tools & InfrastructureGerke Max Preussner
Overview of build tools, build automation, source code management and automated testing infrastructure at Epic Games. Presented at West Coast Unreal Engine DevCon 2014 in San Francisco and Seattle.
West Coast DevCon 2014: The Slate UI Framework (Part 2) - Game UI & Unreal Mo...Gerke Max Preussner
Overview of the Unreal Motion Graphics (UMG) framework in Unreal Engine 4. Presented at West Coast Unreal Engine DevCon 2014 in San Francisco and Seattle.
This is a short presentation Jon gave for the first Ottawa Unity User Group meetup. We share some of the tips and tricks we've discovered at Karman while working with Unity over the past few years.
Use a game engine to create a video game. Its reusable components provide the general functionality. Define resources and building blocks.
What are the key elements of a game engine?
Core Audio, the only media framework available since day one of the public iPhone SDK, offers extremely low latency and powerful access to the device's audio processing system... assuming you can handle what's renowned as one of the hardest APIs on the platform. In iOS 5, Core Audio gets even better, with great new features that had previous been burdensome, if not impossible, to develop on your own. Once the iOS 5 NDA drops, the shiny new bits will be available to all, and this talk will be one of your first chances to learn how they work. Attendees will learn the basics of Core Audio -- the engine APIs that process sound (Audio Queue, Audio Units, and OpenAL) and the helper APIs that get samples into and out of them -- and then look where iOS 5 fills in some of the holes that have existed up to now.
Umbra Ignite 2015: Graham Wihlidal – Adapting a technology stream to ever-evo...Umbra Software
This talk describes some of the pain points and challenges encountered while transitioning Frostbite from a PS3/X360 centric engine built for one game series to numerous games, genres and the PS4/XO launch.
Graham is a senior rendering engineer on the Frostbite engine team, implementing and supporting technology used in many hit games like Battlefield 4, Dragon Age Inquisition, and Star Wars: Battlefront. Prior to Frostbite, Graham was a senior engineer for BioWare for many years, shipping numerous titles including the Mass Effect and Dragon Age trilogies, and Star Wars: The Old Republic. Graham is also the author of Game Engine Toolset Development, and specializes in low level optimizations, engine architecture, GPU driver implementation, and console development.
Third chapter of the lecture Unreal Engine Basics taught at SAE Institute Hamburg.
- Learning how to expose class fields and functions to blueprints
- Writing basic Unreal gameplay code, such as spawning actors, accessing components and listening for events
- Getting familiar with gameplay concepts in the context of Unreal, such as damage and collision
Optimization in Unity: simple tips for developing with "no surprises" / Anton...DevGAMM Conference
Every developer once faces the optimization of their project, but sometimes it happens quite spontaneously and at the wrong time. Developers, especially beginners, often ignore very simple and cheap techniques, which allow to make the optimization process more calm and predictable. This work is devoted to the things you should pay attention in developing to avoid inconvenience in future.
[E-Dev-Day 2014][8/16] The Way How EFL is used in the Tizen, previous, curren...EnlightenmentProject
[E-Dev-Day 2014][8/16] The Way How EFL is used in the Tizen, previous, current and future status
at Enlightenment Developers Day 2014
https://phab.enlightenment.org/w/events/enlightenment_developer_day_2014/
West Coast DevCon 2014: The Slate UI Framework (Part 2) - Game UI & Unreal Mo...Gerke Max Preussner
Overview of the Unreal Motion Graphics (UMG) framework in Unreal Engine 4. Presented at West Coast Unreal Engine DevCon 2014 in San Francisco and Seattle.
This is a short presentation Jon gave for the first Ottawa Unity User Group meetup. We share some of the tips and tricks we've discovered at Karman while working with Unity over the past few years.
Use a game engine to create a video game. Its reusable components provide the general functionality. Define resources and building blocks.
What are the key elements of a game engine?
Core Audio, the only media framework available since day one of the public iPhone SDK, offers extremely low latency and powerful access to the device's audio processing system... assuming you can handle what's renowned as one of the hardest APIs on the platform. In iOS 5, Core Audio gets even better, with great new features that had previous been burdensome, if not impossible, to develop on your own. Once the iOS 5 NDA drops, the shiny new bits will be available to all, and this talk will be one of your first chances to learn how they work. Attendees will learn the basics of Core Audio -- the engine APIs that process sound (Audio Queue, Audio Units, and OpenAL) and the helper APIs that get samples into and out of them -- and then look where iOS 5 fills in some of the holes that have existed up to now.
Umbra Ignite 2015: Graham Wihlidal – Adapting a technology stream to ever-evo...Umbra Software
This talk describes some of the pain points and challenges encountered while transitioning Frostbite from a PS3/X360 centric engine built for one game series to numerous games, genres and the PS4/XO launch.
Graham is a senior rendering engineer on the Frostbite engine team, implementing and supporting technology used in many hit games like Battlefield 4, Dragon Age Inquisition, and Star Wars: Battlefront. Prior to Frostbite, Graham was a senior engineer for BioWare for many years, shipping numerous titles including the Mass Effect and Dragon Age trilogies, and Star Wars: The Old Republic. Graham is also the author of Game Engine Toolset Development, and specializes in low level optimizations, engine architecture, GPU driver implementation, and console development.
Third chapter of the lecture Unreal Engine Basics taught at SAE Institute Hamburg.
- Learning how to expose class fields and functions to blueprints
- Writing basic Unreal gameplay code, such as spawning actors, accessing components and listening for events
- Getting familiar with gameplay concepts in the context of Unreal, such as damage and collision
Optimization in Unity: simple tips for developing with "no surprises" / Anton...DevGAMM Conference
Every developer once faces the optimization of their project, but sometimes it happens quite spontaneously and at the wrong time. Developers, especially beginners, often ignore very simple and cheap techniques, which allow to make the optimization process more calm and predictable. This work is devoted to the things you should pay attention in developing to avoid inconvenience in future.
[E-Dev-Day 2014][8/16] The Way How EFL is used in the Tizen, previous, curren...EnlightenmentProject
[E-Dev-Day 2014][8/16] The Way How EFL is used in the Tizen, previous, current and future status
at Enlightenment Developers Day 2014
https://phab.enlightenment.org/w/events/enlightenment_developer_day_2014/
[EclipseCon France 2017] Language Server Protocol in actionMickael Istria
The Language Server Protocol in a popular IDE-independent and Language-independent interface to provide and consume language edition services - such as code analysis, completion, hyperlinking... It basically lets the language providers implement the protocol as a server, and the IDEs consume the protocol as a client to have the IDEs presenting the language-specific data without having to know about the language.
This protocol already has multiple successful stories. In this talk we’ll demonstrate:
* How a C# language server can be used in Eclipse IDE (thanks to LSP4E) to provide rich C# edition capabilities
* How a Java language server implemented on top of JDT is integrated into VSCode to have VSCode supporting rich Java edition capabilities
* How you can easily write a language server in Java (with LSP4J) and plug it into Eclipse IDE (with LSP4E) and VSCode and demonstrate how easy it becomes to ship additional features for your language in all tools at once.
GEF SVG export in JWT: a newcomer’s rocky ride to EclipseYoann Rodiere
A walkthrough about a pragmatic bug resolution by a junior Eclipse contributor: SVG diagram export in Java Workflow Tooling.
First presented in the Eclipse Juno Democamp in Grenoble, on the 13th ofJuno, 2012.
TensorFlow is the most popular machine learning framework nowadays. TensorFlow Lite (TFLite), open sourced in late 2017, is TensorFlow’s runtime designed for mobile devices, esp. Android cell phones. TFLite is getting more and more mature. One the most interesting new components introduced recently are its GPU delegate and new NNAPI delegate. The GPU delegate uses Open GL ES compute shader on Android platforms and Metal shade on iOS devices. The original NNAPI delegate is an all-or-nothing design (if one of the ops in the compute graph is not supported by NNAPI, the whole graph is not delegated). The new one is a per-op design. When an op in a graph is not supported by NNAPI, the op is automatically fell back to the CPU runtime. I’ll have a quick review TFLite and its interpreter, then walk the audience through example usage of the two delegates and important source code of them.
EcoreTools-Next: Executable DSL made (more) accessibleCédric Brun
Various Eclipse Modeling technologies are trying to empower domain experts in the creation of specific tools. Using EcoreTools and Sirius a domain expert can define languages, graphical modelers and editors without writing a single line of Java code or launching a new Eclipse runtime. However, when come the time to add behaviors to the language structure (e.g., to implement interpreters, compilers, static analysis, refactoring, or generators), the domain expert has to face all the complexity of Eclipse Plugin development, OSGi, Java and much more.
This is a no-go in some contexts and as such there was a sweet spot for a new technology in Eclipse Modeling that support a seamless mechanism to weave behaviors across (Ecore-based) language structure.
This talk will present an integrated approach for weaving behavior of domain specific languages right from the EcoreTools modeler, that can be automatically applied to conforming models while having the following novel characteristics:
Domain experts are able to weave the behaviors across the language structure, seamlessly supporting the definition of a visitors for any kind of purposes.
No need for code generation, any change is instantly reflected and can be tested right away, even on Dynamic Instances
Strong optional validation, fast evaluation
"on demand" extension through Java services
behavior definition which is non-intrusive to the Ecore model
complemented by a first prototype of a dual compiler that seamlessly complement the EMF generation results.
The talk will demo the creation of a DSL and its behavior through the use of these plugins which are extending EcoreTools. The design of the language will also be discussed as it is embeds the Eclipse "aql" query language, leverage union types and type inference and can itself be integrated in other contexts. The audience will leave with a clear understanding of how they could define the behavior of their DSL using this technology, how it compares to approaches like Xcore/Xbase and when it could be part of the Eclipse release.
The technology is currently considered as good enough for experimenting and is being contributed to Eclipse Modeling through the EcoreTool project.
ElixirConf 2017 - Writing an Editor in Elixir - Ian Dugganijcd
Writing An Editor In Elixir -- Elixir for GUIs? Yes, it’s possible. I’m working on a modern editor in Elixir, and I’ll show you how I’m doing it. Topics will include GUI libraries for Elixir, ports, NIFs, interfacing Elixir with other languages (especially Rust), and general design principles for a modern, programmable editor.
https://elixirforum.com/t/14-elixirconf-2017-writing-an-editor-in-elixir-ian-duggan/8950
https://www.youtube.com/watch?v=6lIVWVmuPao
Github: https://github.com/ijcd
Twitter: @ijcd
San Francisco, California
SPEAKER NOTES:
-------------
Why Design UI Tips
I’ve always had an off fascination with editors.
The answer, I believe, as to what makes a good editor, is when it makes us more productive. When it allows us to get into a flow. When it gets out of the way and just lets us create. I have a theory that, for some, it’s what makes you most productive quickly (TextMate, Sublime, Atom) For others, it is what you can control deeply (Emacs, Vi, Atom?). But if they are so hard to learn, why do they persist? Power... the power to control your environment (a true hacker wants to control everything... quote? reference?). But... why don’t people just add to Sublime/Atom/TextMate, etc... because of friction.
My hypothesis is that the reason Emacs is so powerful, is that you can write emacs in emacs without leaving it it can grow as you use it. Others can too, to some extent, but not to the deep level of customizability you can get from Emacs... Not even vim can do this (which is why Spacemacs exsists... some people want the keys of vi with the features of emacs)...
This editor had lisp embedded. It could read email and netnews before your cellphone could make phone calls without being attached to a car.
You could customize it, from the very beginning. DECADES AGO. New editors are adding most of its features, except for the ability to CODE ITSELF WHILE RUNNING.
Why is this a good idea?
1. Emacs <-> Vixen
2. C core, Elisp control <-> Rust core, Elixir control
3. Elisp <-> Elixir
4. Dynamic <-> Dynamic
5. Runtime eval <-> Runtime compile (hot code reload) 6. Macros <-> Macros
7. DSLs <-> DSLs
8. concurre-what? <-> concurrency
9. immuta-maybe? <-> immutable
10. beachballs <-> no beachballs (if designed well)
Rust stuff might mess up your schedulers, Elixir string manipulations might cause GC issues — you need to profile and make a choice. That said, this is an editor and we are using Elixir more for the flexibility than the performance...
Some issues around signals, detecting window size (in escripts) Use tty like iex (have user_drv open it), anoint self as shell
Very much like unix. A process has a process group. IO is sent to the process group session leader. erlang:display goes around this.
editor in control Rust/Termion ruby rust can launch w/out shell and insert ourselves as one can multiplex the shell in our own buffer pty/port-driver combo Telnet Port Driver
GFX Part 1 - Introduction to GPU HW and OpenGL ES specificationsPrabindh Sundareson
Introduction to OpenGL ES and GPU Programming portion of the 7 part session on GFX workshops. Introduces the OpenGL ES specifications from Khronos and provides a perspective of current GPU architectures.
Samsung ARTIK 050 (ARTIK ZERO) Modules Data SheetRyo Jin
Samsung ARTIK is an end-to-end, integrated IoT Platform that transforms the process of developing, launching and managing connected products. The ARTIK 050 module is specifically built to provide secure IoT connectivity for products across vertical markets, including smart home, smart lighting, smart building, manufacturing, and health and wellness.
Introduction to Watch Face Development with Tizen StudioRyo Jin
These materials describe how to develop Gear watch apps for Gear S2 and S3 devices via Tizen Studio, which you can distribute commercially and for free via the Galaxy Apps store.
Tizen 3.0's Window System Integration Layer of OpenGLES/EGL & Vulkan DriverRyo Jin
At XDC2016 Day 1, Samsung R&D talking about Tizen 3.0's Window System Integration Layer of OpenGLES/EGL & Vulkan Driver. Lots of technical details there for those interested in Vulkan and friends.
Panduan Penggunaan Perangkat Wearable TizenRyo Jin
Panduan Penggunaan Perangkat Wearable Tizen ini dibuat dengan tujuan untuk memberi tutorial bagi pengguna baru yang masih asing dengan Tizen khususnya pengguna baru smartwatch yang mulai digemari. Platform wearable yang dipakai adalah Samsung Gear S2 yaitu smartwatch samsung pertama yang menggunakan TIZEN sebagai OS-nya.
Buku berjudul "Cara Menggunakan Smartphone Tizen" ini memberi tutorial bagi penggua baru yang masih asing dengan OS Tizen. Smartphone yang dipakai adalah smartphone komersial Tizen pertama yaitu Samsung Z1.
Now and right here, you can meet diverse watchfaces for Gear Fit2
If you find anything inspiring, share your thoughts
We are looking for your design depicting ‘Sports & Dynamic’.
Tizen experiences explosive growth as #1 platform for IoT
It became a leading independent open platform for all segments
IoT interoperability is the key for rapid growth of Digital Economy
Tizen is guided by Open InterConnect Consortium
Tizen itself is establishing as an Open Independent Project
Tizen Micro profile is an open platform for low-end IoT devices to utilize the Internet and extend their value with Web technology. Tizen Micro profile provides the minimal S/W stack that is necessarily required on IoT devices. It will be common for the every IoT devices in Tizen and address Tizen as OS of Everything.
Tizen merupakan open source project untuk sistem operasi yang berbasis modifikasi Linux Kernel dan WebKit runtime. Dengan Tizen, kita dapat menjalankan aplikasi diatas Smartphone, Wearable ataupun complaisance devices yang mengusung OS Tizen.
Buku Panduan Dasar Pemrograman Tizen dibuat dengan maksud dan tujuan untuk membantu para developer pemula atau developer yang sudah memiliki ketrampilan memprogram aplikasi mobile baik itu Windows Phone, Android ataupun iOS dalam membuat aplikasi mobile diatas platform Tizen.
The Story of Enlightenment, EFL, Tizen and WaylandRyo Jin
Carsten Haitzler (Rasterman) presented at FOSDEM 2016 about Enlightenment on Wayland. As part of that, with Samsung's Tizen environment using Enlightenment, they too are after Wayland as being the superior solution to X11.
There has been an increased support for various profiles and devices on Tizen. As Tizen is a multi/cross platform, device integration will be the main factor of a fluid interface between devices. Whether it is Mobile, Wearable, or TV the scalability and usability will be accessible. These features will allow the users to gain: (1) Easy Access, (2) Content Mash-up, and (3) Multi Device Control. This presentation will introduce the "Tizen Pass" which cover Cross device User Experience & features of Tizen convergence service FW.
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
Generating a custom Ruby SDK for your web service or Rails API using Smithyg2nightmarescribd
Have you ever wanted a Ruby client API to communicate with your web service? Smithy is a protocol-agnostic language for defining services and SDKs. Smithy Ruby is an implementation of Smithy that generates a Ruby SDK using a Smithy model. In this talk, we will explore Smithy and Smithy Ruby to learn how to generate custom feature-rich SDKs that can communicate with any web service, such as a Rails JSON API.
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
Elevating Tactical DDD Patterns Through Object CalisthenicsDorra BARTAGUIZ
After immersing yourself in the blue book and its red counterpart, attending DDD-focused conferences, and applying tactical patterns, you're left with a crucial question: How do I ensure my design is effective? Tactical patterns within Domain-Driven Design (DDD) serve as guiding principles for creating clear and manageable domain models. However, achieving success with these patterns requires additional guidance. Interestingly, we've observed that a set of constraints initially designed for training purposes remarkably aligns with effective pattern implementation, offering a more ‘mechanical’ approach. Let's explore together how Object Calisthenics can elevate the design of your tactical DDD patterns, offering concrete help for those venturing into DDD for the first time!
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
1. EFL
Enlightenment Foundation Libraries
http://www.enlightenment.org
Tizen native display layer – Architecture & Usage
Carsten Haitzler
Enlightenment project lead & founder
Principal Engineer
raster@rasterman.com
c.haitzler@samsung.com
2. What is EFL?
● A collection of libraries
● Built by the same team working on Enlightenment
● Built for the purpose of making E17 (Enlightenment 0.17)
● Always focused on staying lean and still providing fanciness
● Almost all development focus sunk into EFL vs E17
● Cover a wide range of functionality due to broad needs
● 26% of code for E17 is E, rest is EFL.
● E17+EFL make up only 50% of code in SVN though
4. Historical Details
● 1996 – Enlightenment development started
● 1997 – Imaging layer split off into Imlib and Fnlib
● 1997 – Imlib adds GTK+/GDK support
● 1999 – Imlib2 combines images, fonts, alpha channels etc.
● 2001 – Evas (using Imlib2 and OpenGL) first appears
● And then EFL really began as more libs were added:
● Ecore, Ebits (later replaced by Edje), Edb (deprecated in favor
of Eet), Eina, Embryo, Efreet, EDbus, Ethumb, Emotion,
Elementary, Epdf, Eeze.
5. What's inside
● Canvas scene-graph (Evas)
● OpenGL, OpenGL-ES2.0, Software renderer and more
● Core mainloop, connection, input and glue libraries (Ecore)
● Data codec and storage (Eet)
● Bytecode VM (Embryo)
● Pre-made data objects with scripting, animation etc. (Edje)
● Freedesktop.org standards support (Efreet)
6. What's inside
● Data structure, modules and base (Eina)
● Dbus integration and wrapping (Edbus)
● Asynchronous I/O (Eio) (Currently not in Tizen)
● Video playback glue (Emotion)
● Udev hardware detection (Eeze) (Currently not in Tizen)
● Thumbnailer & cacher (Ethumb)
● Widgets & convenience (Elementary)
7. On its way
● Javascript runtime environment (Elev8) (Currently not in Tizen)
● Still in alpha, not complete
● Like Node.js, but for UI.
– Both Node.js and Elev8 highly similar structures & design
– Reaching out to Node.js developers (positive response)
– Harmonizing Elev8 vs Node.js libvu
● Object model enhancements (Currently not in Tizen)
● Expanding performance, threading (Currently not in Tizen)
● Decreasing memory footprint & more (Currently not in Tizen)
8. So why does this matter?
● EFL is the core toolkit being used in Tizen
● EFL is built for performance and low footprint
● Still heavy focus on customization and power
● Tizen is open, just like EFL
● Native apps can use EFL as opposed to shipping their own toolkits
● Smaller footprint for shipping devices
● Continued support
● Provides much of what you need
● It's an open source project, so contributions always welcomed
● API's all in C, thus easily usable from both C and C++
9. Where does it lurk?
HTML5 Apps
Native Applications
Browser and Services
And HTML5 Enlightenment
Runtime (Window Manager & Compositor)
EFL
EFL
libc etc. libpng/jpeg etc. X1 OpenGL, etc.
1, D-Bus, Services
KERNEL
10. Duplo time!
Application, Library, Service
Elementary
(Currently not in Tizen)
Eio Eeze Efreet EDbus Ethumb Emotion Edje
Ecore
Evas
Embryo Eet
Eina
Core OS (Kernel, libc, other system libraries, OpenGL, D-Bus, X1 services etc.)
1,
11. Why EFL?
● Why is EFL being used as opposed to GTK+ or Qt or
something else?
● Speed
– Samsung used GTK+, X1 and DirectFB (in combinations) and once
1
EFL was tried, it soundly beat these hands-down in performance
– Very fast software rendering (for all occasions)
– Solid Accelerated OpenGL and OpenGL-ES2.0 support for many
years
– 60fps+ on common smartphones equaling android with higher
quality
12. Why EFL?
● Why is EFL being used as opposed to GTK+ or Qt or
something else?
● Memory (Ubuntu 1
1.04) beyond base X1 “failsafe” session
1
– Unity – 168Mb
– Enlightenment 0.17 – 65Mb
● Numbers based on “free” minus disk cache and buffers – Base 199Mb
● Both Unity and Enlightenment have roughly similar features
and setup
– Compositor (OpenGL), fullscreen wallpaper, launcher, icons,
filemanager, etc.
13. How is this relevant?
● Mobile devices ship with limited memory
● 128Mb, 256Mb, maybe 512Mb
● These devices almost never use swap
● Flash has limited writes, so swap can hurt device lifespan
● Lower end devices may not have GPU's
● Require decent software rendering to make up for it
● OpenGL has overhead that may not be worth it for all
situations
● Texture atlases to keep speed, but lose memory & more
14. Where do I start?
● On Tizen itself, or packages for several distros
● Some distros EFL based
● Source fetch methods
● http://www.enlightenment.org/p.php?p=download
– Build order and package info etc.
● (Build Elementary and E17 last)
● svn co http://svn.enlightenment.org/svn/e/trunk
– Get everything yourself directly
● http://omicron.homeip.net/projects/easy_17/easy_17.sh
e e
– Fetch from svn and build, install dependencies
16. Core concepts
● Event driven mainloop
● Rendering (UI)
● Application state management
● Small miscellaneous tasks (non-blocking)
● Support for threaded work
● Similar to OSX and iOS with dispatching (Grand Central Dispatch) as
well as manual dispatch and feedback
● Added thread models with mainloop begin/end blocks and mainloop
call dispatch (from threads).
● More on threading
– http://docs.enlightenment.org/auto/elementary/threading.html
17. The Mainloop (Ecore)
CALLBACK
WAKE UP IDLE EXITER
PROCESS TIMEOUTS TIMER/ANIMATOR
Z
Z
SPIN IN OR Z PROCESS EVENTS EVENT HANDLER
IDLERS
PROCESS JOBS JOB
GO TO SLEEP IDLE ENTERER
EVAS RENDERS UPDATES
18. To keep a smooth UI
● Put I/O work or heavy computation into threads
● Use the constructs provided to make this easy
● Keep state in Mainloop consistent
● Only deliver changes as a whole (UI tracks state)
● (automatic within mainloop)
● Use Animators, not Timers for animation
● Remember that mainloop is for keeping application state
● Blocking it blocks state (and UI) updates
19. Threading the Mainloop (Ecore Thread)
Thread Thread Thread
Worker Worker Worker
Results returned to Mainloop
(result functions run inside Mainloop)
Thread
Job
Thread Mainloop
Job
Queue
Thread
Job Mainloop adds thread job
Thread
Job
30. #include <Elementary.h>
}
elm_exit();
Getting fancy
static void on_win_del(void *data, Evas_Object *obj, void *event_info) {
(in C)
static void on_flip(void *data, Evas_Object *obj, void *event_info) {
Evas_Object *flip = data;
elm_flip_go(flip, ELM_FLIP_CUBE_UP);
}
int elm_main(int argc, char **argv) {
Evas_Object *win, *bg, *box, *flip, *label, *button;
win = elm_win_add(NULL, "main", ELM_WIN_BASIC);
elm_win_title_set(win, "Hello Flip");
evas_object_smart_callback_add(win, "delete,request", on_win_del, NULL);
bg = elm_bg_add(win);
elm_bg_file_set(bg, "plant.jpg", NULL);
elm_win_resize_object_add(win, bg);
evas_object_show(bg);
box = elm_box_add(win);
flip = elm_flip_add(win);
elm_box_pack_end(box, flip);
evas_object_show(flip);
label = elm_label_add(win);
elm_object_text_set(label,
"Hello out there world!<br>"
"<br>"
"This is a small ditty I wrote,<br>"
"On the front of this here note,<br>"
"To see what fun there can be,<br>"
"Playing with Elementary.<br>"
"<br>"
"To swoosh, to flip, within this note,<br>"
"Is precisely what the programmer wrote,<br>"
"For candy of the eye to be seen,<br>"
"Compiled to binaries it must have been.");
evas_object_show(label);
elm_flip_content_front_set(flip, label);
button = elm_button_add(win);
elm_object_text_set(button, "Flip");
elm_box_pack_end(box, button);
evas_object_show(button);
evas_object_smart_callback_add(button, "clicked", on_flip, flip);
elm_win_resize_object_add(win, box);
evas_object_show(box);
evas_object_show(win);
31. #include <Elementary.h>
}
elm_exit(); Getting fancy
static void on_win_del(void *data, Evas_Object *obj, void *event_info) {
(in C)
static void on_flip(void *data, Evas_Object *obj, void *event_info) {
Evas_Object *flip = data;
elm_flip_go(flip, ELM_FLIP_CUBE_UP);
}
int elm_main(int argc, char **argv) {
Evas_Object *win, *bg, *box, *flip, *label, *list, *button;
win = elm_win_add(NULL, "main", ELM_WIN_BASIC);
elm_win_title_set(win, "Hello Flip");
evas_object_smart_callback_add(win, "delete,request", on_win_del, NULL);
bg = elm_bg_add(win);
elm_bg_file_set(bg, "plant.jpg", NULL);
elm_win_resize_object_add(win, bg);
evas_object_show(bg);
box = elm_box_add(win);
flip = elm_flip_add(win);
elm_box_pack_end(box, flip);
evas_object_show(flip);
label = elm_label_add(win);
elm_object_text_set(label,
"Hello out there world!<br>"
"<br>"
"This is a small ditty I wrote,<br>"
"On the front of this here note,<br>"
"To see what fun there can be,<br>"
"Playing with Elementary.<br>"
"<br>"
"To swoosh, to flip, within this note,<br>"
"Is precisely what the programmer wrote,<br>"
"For candy of the eye to be seen,<br>"
"Compiled to binaries it must have been.");
evas_object_show(label);
elm_flip_content_front_set(flip, label);
list = elm_list_add(win);
elm_list_item_append(list, "Eye of newt,", NULL, NULL, NULL, NULL);
elm_list_item_append(list, "And toe of frog,", NULL, NULL, NULL, NULL);
elm_list_item_append(list, "Wool of bat,", NULL, NULL, NULL, NULL);
elm_list_item_append(list, "And tongue of dog,", NULL, NULL, NULL, NULL);
elm_list_item_append(list, "Adder's fork,", NULL, NULL, NULL, NULL);
elm_list_go(list);
evas_object_show(list);
elm_flip_content_back_set(flip, list);
button = elm_button_add(win);
elm_object_text_set(button, "Flip");
elm_box_pack_end(box, button);
evas_object_show(button);
evas_object_smart_callback_add(button, "clicked", on_flip, flip);
elm_win_resize_object_add(win, box);
evas_object_show(box);
evas_object_show(win);
32. Getting fancy
(in C)
#include <Elementary.h>
static void on_win_del(void *data, Evas_Object *obj, void *event_info) {
elm_exit();
}
static void on_flip(void *data, Evas_Object *obj, void *event_info) {
Evas_Object *flip = data;
elm_flip_go(flip, ELM_FLIP_CUBE_UP);
}
int elm_main(int argc, char **argv) {
Evas_Object *win, *bg, *box, *flip, *label, *list, *button;
win = elm_win_add(NULL, "main", ELM_WIN_BASIC);
elm_win_title_set(win, "Hello Flip");
evas_object_smart_callback_add(win, "delete,request", on_win_del, NULL);
bg = elm_bg_add(win);
elm_bg_file_set(bg, "plant.jpg", NULL);
elm_win_resize_object_add(win, bg);
evas_object_show(bg);
box = elm_box_add(win);
flip = elm_flip_add(win);
elm_box_pack_end(box, flip);
evas_object_show(flip);
label = elm_label_add(win);
elm_object_text_set(label,
"Hello out there world!<br>"
"<br>"
"This is a small ditty I wrote,<br>"
"On the front of this here note,<br>"
"To see what fun there can be,<br>"
"Playing with Elementary.<br>"
"<br>"
"To swoosh, to flip, within this note,<br>"
"Is precisely what the programmer wrote,<br>"
"For candy of the eye to be seen,<br>"
"Compiled to binaries it must have been.");
evas_object_show(label);
elm_flip_content_front_set(flip, label);
list = elm_list_add(win);
elm_list_item_append(list, "Eye of newt,", NULL, NULL, NULL, NULL);
elm_list_item_append(list, "And toe of frog,", NULL, NULL, NULL, NULL);
elm_list_item_append(list, "Wool of bat,", NULL, NULL, NULL, NULL);
elm_list_item_append(list, "And tongue of dog,", NULL, NULL, NULL, NULL);
elm_list_item_append(list, "Adder's fork,", NULL, NULL, NULL, NULL);
elm_list_go(list);
evas_object_show(list);
elm_flip_content_back_set(flip, list);
button = elm_button_add(win);
elm_object_text_set(button, "Flip");
elm_box_pack_end(box, button);
evas_object_show(button);
evas_object_smart_callback_add(button, "clicked", on_flip, flip);
elm_win_resize_object_add(win, box);
evas_object_show(box);
evas_object_show(win);
elm_run();
}
ELM_MAIN();
34. What is a scene graph? (Evas)
● Tracks state of all display objects
● Position, size, visibility, color, properties etc.
● Handles rendering of each object
● Loading fonts, images, rendering glyphs, scaling, fading etc.
● Handles minimizing of rendering
● Only update areas changed
● If changes obscured, reduce to a NOP
● Optimize rendering
● Abstract to OpenGL, software, or anything else
35. What is a scene graph? (Evas)
● Allows you to build your own composite objects
● Creates parent/child relationship
● Is used throughout EFL to build widgets etc.
● Handles input direction and event callbacks
● Text formatting & layout
36. What is a scene graph? (Evas)
Text Label Text Label Text Label Text Label Text Label Text Label
Text Label Text Label Text Label
OK
43. Abstracting rendering
Hello out there
Input device events Canvas state changes
Canvas core
Image data, fonts etc. Rendering command
General Rendering
Select rendering engine at runtime
Software rendering API OpenGL Rendering API
OUTPUT
(screen/window)
Software core OpenGL core
49. Multiple output paths
● Pure software
● Universal (works everywhere)
● MMX, SSE, SSE3, NEON ASM (runtime detected)
● High quality scaling (super-sampling + linear-interpolation)
● Caching of scaled image data on the fly
● Output rotation and down-convert
50. Multiple output paths
● OpenGL/OpenGL-ES2
● Uses texture atlases where possible
● Defers texture upload and removes duplication where it can
● Multi-pipeline out-of-order rendering optimizing
● Batches up as much geometry as it can for best performance
● Specialized shaders for performance
● Pushes all rendering via GL (not just compositing surfaces)
– Text, polygons too
● Tries to remove texture uploads with zero-copy (if possible)
54. Pre-made objects for designers (Edje)
● Edje allows a designer to store objects in files
● Pre-made layout with rules and reactions to events
● Stored separately to code in binary files for runtime
replacement
● Fast & compact random access designed for realtime use
● All layout, image data, etc. etc. all in 1 file (zero-unpacking)
● Intended for designers & developers to work independently
● Supports scalable and resizeable layouts
● Provides the core ability to re-theme and entire UI or OS
55. How it works
Application
Signal emits
Messages Mainloop
Signal callbacks Controls
Messages Swallows
Queries Text etc.
Edje
Create & control Objects
Evas Edje
Get event callbacks
Layout rules, parameters & states
Images & fonts
Event reaction rules
Edje File
56. collections {
An example
group { name: "hello";
images {
image: "plant.jpg" LOSSY 80;
image: "shadow.png" COMP;
}
parts {
part { name: "bg";
description { state: "default" 0.0;
aspect: 1.0 1.0; aspect_preference: NONE;
image.normal: "plant.jpg";
}
}
part { name: "label"; type: TEXT; scale: true;
description { state: "default" 0.0;
text {
font: "Sans"; size: 20;
text: "Hello World!";
}
}
}
part { name: "shadow";
description { state: "default" 0.0;
image.normal: "shadow.png";
}
}
}
}
}
60. So what is Elementary?
● A widget set built on top of the lower-level EFL layers
● Brings coherent policy and consistency to widgets
● Pre-made common widgets most applications need
● Central theme setup so applications look consistent
● Utilities saving extra footwork by the developer
● Touch friendly design
● Scaling of UI from the get-go
● Also adjusts for input resolution (finger vs mouse etc.)
61. So what is Elementary?
● It can be seamlessly merged with lower level objects
● Programmer can use Elementary containers or hand-
arrange widgets and control them
● Since all objects can be stacked and layered, so can
elementary widgets
● Widgets can be transformed like any object
● Handles dealing with IME (Virtual keyboard) for you
● Does many other useful things to save you time
62. So what is Elementary?
● All widgets can and will be rendered with Hardware
(OpenGL) if that is the engine chosen
● This includes all decorations, text etc. not just compositing
● Elementary helps enforce “finger size” so users can
always easily use your application
● Works on both desktop (keyboard & mouse) as well as
touchscreen and multi-touch
66. Video & Sound in your world
● Gives you a high level API to include video
● Abstracts to different video decode back-ends
● Optimizes decode via YUV paths or video overlay
● Simple to use
68. How it works
Application
Mainloop
Emotion
Media Codec (Gstreamer/Xine/Generic)
Evas Emotion Thread
Decoder
Core thread
Thread Thread
Media file or stream
70. Garbage in, garbage out
Application Text file
(RAM) Stdout
struct Data { group “Data” struct {
const char *name; value “name” string: “Bob”;
... ...
Eet Eet
(Library) (Cmdline)
0100011010101
1 10101
Binary
Data
(File or buffer)
71. XML/JSON … for C programmers
● Parsing text is painful
● Parsing correctly without bugs, overflows is harder
● Most programmers hate parsing
● XML, JSON etc. optimized for editing, not runtime
● Programs read/write data 1000x more than humans
● So optimize for the common use case, not the uncommon one
● Make it as easy 1-liners for C code to load or save data
● Edje, Enlightenment config, Elementary config built on EET
72. Flexible, portable and robust
● Allows you to store data in a file (key/value pair)
● Random access read optimized
● Data can be any binary, image, string or struct encoded
● Compresses separate keys (like zip)
● Allows you to en/decode structs to buffers (for network)
● Provides a protocol buffer handler for decodes
● Files and data all platform agnostic (portable)
● Structs encoded with nested key & types for robustness
74. Declare and save it
Eet_File *ef;
Data data = {
.name = "Bob the blob",
.age = 7,
.address = "7 Blob ave.",
.phone = "+82 10 123 4567"
};
ef = eet_open("data.eet", EET_FILE_MODE_WRITE);
eet_data_write(ef, d, "data", &data, EINA_TRUE);
eet_close(ef);
75. Declare and save it
Data *data2;
ef = eet_open("data.eet", EET_FILE_MODE_READ);
data2 = eet_data_read(ef, d, "data");
eet_close(ef);
76. For debugging, decode to text
$ eet -d data.eet data
group "Data" struct {
value "name" string: "Bob the blob";
value "age" int: 7;
value "address" string: "7 Blob ave.";
value "phone" string: "+82 10 123 4567";
}
77. And encode + compress from text
$ cat data.txt
group "Data" struct {
value "name" string: "Bob the blob";
value "age" int: 7;
value "address" string: "7 Blob ave.";
value "phone" string: "+82 10 123 4567";
}
$ eet -e data.eet data data.txt 1