Electron in Action.Pdf

Total Page:16

File Type:pdf, Size:1020Kb

Electron in Action.Pdf Steve Kinney MANNING Electron in Action Electron in Action STEVEN KINNEY MANNING SHELTER ISLAND For online information and ordering of this and other Manning books, please visit www.manning.com. The publisher offers discounts on this book when ordered in quantity. For more information, please contact Special Sales Department Manning Publications Co. 20 Baldwin Road PO Box 761 Shelter Island, NY 11964 Email: [email protected] ©2019 by Manning Publications Co. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, mechanical, photocopying, or otherwise, without prior written permission of the publisher. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in the book, and Manning Publications was aware of a trademark claim, the designations have been printed in initial caps or all caps. Recognizing the importance of preserving what has been written, it is Manning’s policy to have the books we publish printed on acid-free paper, and we exert our best efforts to that end. Recognizing also our responsibility to conserve the resources of our planet, Manning books are printed on paper that is at least 15 percent recycled and processed without the use of elemental chlorine. Manning Publications Co. Development editor: Helen Stergius 20 Baldwin Road Technical development editor: Nickie Buckner PO Box 761 Review editor: Aleksandar Dragosavljevic´ Shelter Island, NY 11964 Project editor: Lori Weidert Copy editor: Pamela Hunt Proofreader: Elizabeth Martin Technical proofreader: Doug Warren Typesetter: Dennis Dalinnik Cover designer: Marija Tudor ISBN: 9781617294143 Printed in the United States of America 12345678910–DP–232221201918 This book is dedicated to my wife, Logan, and my sons, Wes and Jack. You are the loves of my life. brief contents PART 1GETTING STARTED WITH ELECTRON ..............................1 1 ■ Introducing Electron 3 2 ■ Your first Electron application 17 PART 2BUILDING CROSS-PLATFORM APPLICATIONS WITH ELECTRON .........................................................45 3 ■ Building a notes application 47 4 ■ Using native file dialog boxes and facilitating interprocess communication 65 5 ■ Working with multiple windows 87 6 ■ Working with files 98 7 ■ Building application and context menus 123 8 ■ Further operating system integration and dynamically enabling menu items 143 9 ■ Introducing the tray module 159 10 ■ Building applications with the menubar library 181 11 ■ Using transpilers and frameworks 199 vii viii BRIEF CONTENTS 12 ■ Persisting use data and using native Node.js modules 222 13 ■ Testing applications with Spectron 243 PART 3DEPLOYING ELECTRON APPLICATIONS .......................257 14 ■ Building applications for deployment 259 15 ■ Releasing and updating applications 272 16 ■ Distributing your application through the Mac App Store 293 contents preface xvii acknowledgments xix about this book xxi about the cover illustration xxv PART 1GETTING STARTED WITH ELECTRON ....................1 Introducing Electron 3 1 1.1 What is Electron? 4 What is the Chromium Content Module? 5 ■ What is Node.js? 6 1.2 Who’s using Electron? 6 1.3 What do I need to know? 8 1.4 Why should I use Electron? 8 Building on your existing skill set 9 ■ Access to native operating system APIs 10 ■ Enhanced privileges and looser restrictions 10 Accessing Node from the browser context 13 ■ Offline first 13 1.5 How does Electron work? 13 The main process 14 ■ Renderer processes 14 1.6 Electron vs. NW.js 15 ix x CONTENTS Your first Electron application 17 2 2.1 Building a bookmark list application 18 Structuring the Electron application 19 ■ package.json 20 Downloading and installing Electron in our project 21 2.2 Working with the main process 23 2.3 Creating a renderer process 24 Loading code from the renderer process 26 ■ Requiring files in the renderer process 29 ■ Adding styles in the renderer process 29 2.4 Implementing the UI 30 Making cross-origin requests in Electron 32 ■ Parsing responses 33 ■ Storing responses with web storage APIs 34 Displaying request results 35 ■ The unhappy path 38 An unexpected bug 40 PART 2BUILDING CROSS-PLATFORM APPLICATIONS WITH ELECTRON ...............................................45 Building a notes application 47 3 3.1 Defining our application 48 3.2 Laying the foundation 49 3.3 Bootstrapping the application 51 Implementing the UI 51 ■ Gracefully displaying the browser window 56 3.4 Implementing the base functionality 57 3.5 Debugging an Electron application 59 Debugging renderer processes 59 ■ Debugging the main process 61 ■ Debugging the main process with Visual Studio Code 61 Using native file dialog boxes and facilitating interprocess 4 communication 65 4.1 Triggering native file dialog boxes 66 4.2 Reading files using Node 69 Scoping the Open File dialog 70 ■ Implementing dialog sheets in macOS 71 4.3 Facilitating interprocess communication 74 Introducing the remote module 77 CONTENTS xi 4.4 Triggering the Open File function using interprocess communication 79 Understanding the CommonJS require system 79 ■ Requiring functionality from another process 79 4.5 Sending content from the main process to the renderer process 81 Sending the file contents to the renderer contents 82 Working with multiple windows 87 5 5.1 Creating and managing multiple windows 88 Communicating between the main process and multiple windows 90 ■ Passing a reference to the current window to the main process 91 5.2 Improving the user experience of creating new windows 93 5.3 Integrating with macOS 95 Working with files 98 6 6.1 Keeping track of the current file 99 Updating the window title based on the current file 101 Determining whether the current file has changed 103 Enabling the Save and Revert buttons in the UI 105 Updating the represented file on macOS 105 6.2 Tracking recently opened files 106 6.3 Saving files 108 Exporting the rendered HTML output 109 ■ Common paths 110 ■ Saving files from the renderer process 110 Saving the current file 111 ■ Reverting files 112 6.4 Opening files using drag and drop 112 Ignoring dropped files everywhere else 113 ■ Providing visual feedback 113 ■ Opening dropped files 116 6.5 Watching files for changes 117 6.6 Prompting the user before discarding changes 119 Building application and context menus 123 7 7.1 Replacing and replicating the default menu 125 macOS and the case of the missing Edit menu 126 The hidden cost of replacing Electron’s default menu 128 xii CONTENTS Implementing the Edit and Window menus 129 ■ Defining menu item roles and keyboard shortcuts 130 ■ Restoring the application menu on macOS 131 ■ Adding a Help menu 134 7.2 Adding application-specific menu functionality 136 Handling the case of having no focused window 138 7.3 Building context menus 140 Further operating system integration and dynamically 8 enabling menu items 143 8.1 Using the shell module from the UI in the renderer process 145 8.2 Using the shell module in the application menu 146 Additional features of the Electron shell module 148 8.3 Accessing the shell module from a context menu 148 Deciding between putting functionality in a menu or in the browser 149 ■ Deciding between putting functionality in the application or context menu 150 8.4 Disabling menu items when appropriate 150 Dynamically enabling and disabling menu items in the context menu 150 ■ Dynamically enabling and disabling menu items in the application menu 153 Introducing the tray module 159 9 9.1 Getting started with Clipmaster 161 9.2 Creating an application with the tray module 161 Using the correct icon for macOS and Windows 163 Supporting dark mode in macOS 164 ■ Reading from the clipboard and storing clippings 164 9.3 Reading from and writing to the clipboard 167 Writing to the clipboard 168 ■ Handling edge cases 170 9.4 Registering global shortcuts 172 Checking registrations and unregistering global shortcuts 174 9.5 Displaying notifications 174 9.6 Switching menu bar icons when pressed in macOS 177 9.7 Completed code 178 CONTENTS xiii Building applications with the menubar library 181 10 10.1 Starting an application with menubar 182 10.2 Adding clippings to the UI 186 10.3 Working with clippings in the application 188 Preventing memory leaks using event delegation 188 Removing a clipping 189 ■ Writing to the clipboard 190 10.4 Publishing clippings 191 Setting up request 192 10.5 Displaying notifications and registering global shortcuts 193 Registering global shortcuts 194 ■ Solving for the edge case that occurs if the window has never been shown 196 10.6 Adding a secondary menu 197 Using transpilers and frameworks 199 11 11.1 Introducing electron-compile 201 11.2 Laying the application’s foundation 202 11.3 Building the UI in React 207 The Application component 208 ■ Displaying the lists of items 210 11.4 Adding new items 214 11.5 Live reload and hot module reloading 217 Enabling live reload 217 ■ Setting up hot module reloading 218 Persisting user data and using native Node.js modules 222 12 12.1 Storing data in an SQLite database 223 Using the right versions with electron-rebuild 224 ■ Setting up SQLite and Knex.js 224 ■ Hooking the database into React 226 Fetching all of the items from the database 227 ■ Adding items to the database 228 ■ Updating items in the database 230 Deleting items 232 ■ Storing the database in the right place 235 12.2 IndexedDB 236 Creating a store with IndexedDB 236 ■ Getting data from IndexedDB 237 ■ Writing data
Recommended publications
  • Emscripten: an LLVM to Javascript Compiler
    Emscripten: An LLVM to JavaScript Compiler Alon Zakai Mozilla What? Why? Compiling to JavaScript ● The web is everywhere – PCs to iPads – No plugins, no installation required – Built on standards ● The web runs JavaScript Existing Compilers to JavaScript ● Google Web Toolkit: Java (Gmail, etc.) ● CoffeeScript ● Pyjamas: Python ● SCM2JS: Scheme ● JSIL: .NET bytecode ● (and many more) ● But C and C++ are missing! Emscripten ● Enables compiling C and C++ into JavaScript ● Written in JavaScript ● Open source http://emscripten.org https://github.com/kripken/emscripten Demos! ● Bullet ● SQLite ● Python, Ruby, Lua ● Real-world code – Large, complex codebases ● Manual ports exist – Typically partial and not up to date The Big Picture C or C++ LLVM Bitcode JavaScript Low Level Virtual Machine (LLVM) ● A compiler project (cf. GCC) ● Intermediate Representation: LLVM bitcode – Very well documented – Great tools ● Much easier to compile LLVM bitcode than compile C or C++ directly! How? Code Comparison #include <stdio.h> int main() { printf(“hello, world!\n”); return 0; } Code Comparison @.str = private unnamed_addr constant [15 x i8] c"hello, world!\0A\00", align 1 define i32 @main() { entry: %retval = alloca i32, align 4 call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([15 x i8]* @.str, i32 0, i32 0)) store i32 0, i32* %retval ret i32 %retval } Code Comparison define i32 @main() { function _main() { entry: %retval = alloca i32, var _retval; align 4 call i32 (i8*, ...)* _printf (..); @printf (..) store i32 0, i32* _retval = 0; %retval ret
    [Show full text]
  • Webassembly a New World of Native Exploits on the Web Agenda
    WebAssembly A New World Of Native Exploits On The Web Agenda • Introduction • The WebAssembly Platform • Emscripten • Possible Exploit Scenarios • Conclusion Wasm: What is it good for? ● Archive.org web emulators ● Image/processing ● Video Games ● 3D Modeling ● Cryptography Libraries ● Desktop Application Ports Wasm: Crazy Incoming ● Browsix, jslinux ● Runtime.js (Node), Nebulet ● Cervus ● eWASM Java Applet Joke Slide ● Sandboxed ● Virtual Machine, runs its own instruction set ● Runs in your browser ● Write once, run anywhere ● In the future, will be embedded in other targets What Is WebAssembly? ● A relatively small set of low-level instructions ○ Instructions are executed by browsers ● Native code can be compiled into WebAssembly ○ Allows web developers to take their native C/C++ code to the browser ■ Or Rust, or Go, or anything else that can compile to Wasm ○ Improved Performance Over JavaScript ● Already widely supported in the latest versions of all major browsers ○ Not limited to running in browsers, Wasm could be anywhere Wasm: A Stack Machine Text Format Example Linear Memory Model Subtitle Function Pointers Wasm in the Browser ● Wasm doesn’t have access to memory, DOM, etc. ● Wasm functions can be exported to be callable from JS ● JS functions can be imported into Wasm ● Wasm’s linear memory is a JS resizable ArrayBuffer ● Memory can be shared across instances of Wasm ● Tables are accessible via JS, or can be shared to other instances of Wasm Demo: Wasm in a nutshell Emscripten ● Emscripten is an SDK that compiles C/C++ into .wasm binaries ● LLVM/Clang derivative ● Includes built-in C libraries, etc. ● Also produces JS and HTML code to allow easy integration into a site.
    [Show full text]
  • Javascript to Webassembly Cross Compiler Studienarbeit
    JavaScript to WebAssembly Cross Compiler Studienarbeit Abteilung Informatik Hochschule für Technik Rapperswil Herbstsemester 2018 Autoren: Matteo Kamm, Mike Marti Betreuer: Prof. Dr. Luc Bläser Projektpartner: Institute for Networked Solutions Inhaltsverzeichnis 1 Abstract 3 2 Einführung 4 2.1 Ausgangslage . .4 2.2 Übersicht . .5 2.2.1 Beispiel . .6 2.3 Struktur des Berichts . .7 3 Language Set 8 3.1 Grundsatz des Subsets . .8 3.2 Typen . .9 3.3 Unterstützte Sprachkonstrukte . .9 4 Cross Compilation 11 4.1 Typinferenz . 11 4.2 Template-Based Code Generation . 11 4.2.1 Unäre Operatoren . 12 4.2.2 Binäre Operationen . 12 4.2.3 Expression Statements . 13 4.2.4 Arrayzugriffe . 13 4.3 Control Flow . 15 4.3.1 Block Statement . 15 4.3.2 Branching . 15 4.3.3 While-Loop . 17 4.3.4 For-Loop . 19 4.4 Variablen-Allokation . 19 4.5 Funktionsaufrufe . 20 5 Laufzeitunterstützung 21 5.1 Prüfen der Funktionssignatur . 21 5.2 Kopieren der Array Parameter . 21 5.3 Konvertieren des zurückgegebenen Resultats . 21 5.4 Out Parameter . 21 5.5 Speicher . 22 5.5.1 Import . 22 5.5.2 Export . 22 6 Auswertung 23 6.1 Testfälle . 23 6.2 Setup . 23 6.3 Resultate . 24 6.3.1 Speedup . 24 6.3.2 Varianz . 26 6.3.3 Vergleich zu C++ . 27 6.3.4 Webpack Development Modus . 28 6.4 Fazit . 28 7 Schlussfolgerung 29 7.1 Ausblick . 29 1 Anhang 30 A Erläuterung Language Set 30 A.1 Typen . 30 A.2 Numerische Erweiterung . 30 A.3 Abweichungen der binären Operatoren zu JavaScript .
    [Show full text]
  • Hi, My Name Is Chad Ausen, Technical Director at IMVU, and Today We're Go
    Hi, my name is Chad Aus0n, technical director at IMVU, and today we’re going to talk about a library we’ve developed for connec0ng C++ and JavaScript with Emscripten. 1 2 IMVU is an online social plaorm where you can sign up, dress up an avatar, and meet people from all around the world. We offer other ac0vi0es such as games as well. 3 The content in our world is created by our customers, and to our knowledge, we have the largest catalog of 3D virtual goods on the Internet. 4 We currently offer a downloadable applicaon for Windows and Mac. Windows and Mac are great plaorms, but in recent years, other plaorms have grown to prominence. We’d like our content available everywhere: mobile plaorms, desktop, server-side renderers, and even the web browser! For almost all plaorms, it’s obvious that C++ is a great choice for the core engine. However, our big ques0on was, what about the web browser? In 2011, I benchmarked an upcoming tool called Emscripten and was quite impressed. 5 Emscripten works very well in prac0ce, so the implicaon is that C++ is the portable, high-performance language EVERYWHERE. 6 Here is our Emscripten applicaon running in Firefox. UI is HTML and CSS. Chat over WebSockets, graphics in WebGL. 7 asm.js is the subset of JavaScript that can be stacally compiled into machine code. More informaon at h`p://asmjs.org/ 8 The C heap is stored in an ArrayBuffer in JavaScript. One con0guous blob of memory. This memory is indexed by eight different typed array views that alias each other.
    [Show full text]
  • Static Typescript
    1 Static TypeScript 56 2 57 3 An Implementation of a Static Compiler for the TypeScript Language 58 4 59 5 60 6 Thomas Ball Peli de Halleux Michał Moskal 61 7 Microsoft Research Microsoft Research Microsoft Research 62 8 Redmond, WA, United States Redmond, WA, United States Redmond, WA, United States 63 9 [email protected] [email protected] [email protected] 64 10 Abstract 65 11 66 12 While the programming of microcontroller-based embed- 67 13 dable devices typically is the realm of the C language, such 68 14 devices are now finding their way into the classroom forCS 69 15 education, even at the level of middle school. As a result, the 70 16 use of scripting languages (such as JavaScript and Python) 71 17 for microcontrollers is on the rise. 72 18 We present Static TypeScript (STS), a subset of TypeScript (a) (b) 73 19 (itself, a gradually typed superset of JavaScript), and its com- 74 20 piler/linker toolchain, which is implemented fully in Type- Figure 1. Two Cortex-M0 microcontroller-based educational 75 21 Script and runs in the web browser. STS is designed to be use- devices: (a) the BBC micro:bit has a Nordic nRF51822 MCU 76 22 ful in practice (especially in education), while being amenable with 16 kB RAM and 256 kB flash; (b) Adafruit’s Circuit Play- 77 23 to static compilation targeting small devices. A user’s STS ground Express (https://adafruit.com/products/3333) has an 78 24 program is compiled to machine code in the browser and Atmel SAMD21 MCU with 32 kB RAM and 256 kB flash.
    [Show full text]
  • BROWSIX: Bridging the Gap Between Unix and the Browser Bobby Powers, John Vilk, Emery D
    BROWSIX: Bridging the Gap Between Unix and the Browser Bobby Powers, John Vilk, Emery D. Berger University of Massachusetts Amherst Abstract As a representative example, websites like ShareLaTeX1 2 A Applications written to run on conventional operating sys- and Overleaf let users write and edit LTEX documents in the tems typically depend on OS abstractions like processes, pipes, browser without the need to install a TEX distribution locally. signals, sockets, and a shared file system. Porting these ap- This workflow lowers the barrier for students and first-time A plications to the web currently requires extensive rewriting LTEX authors and enables real-time collaboration, eliminating or hosting significant portions of code server-side because some of the complexity of creating multi-author documents. browsers present a nontraditional runtime environment that These applications achieve this functionality by providing a lacks OS functionality. browser-based frontend for editing; user input is sent to the server for persistence and collaboration purposes. When the This paper presents BROWSIX, a framework that bridges pdflatex the considerable gap between conventional operating systems user requests a generated PDF, the website runs bibtex and the browser, enabling unmodified programs expecting a and server-side on the user’s behalf, with the resulting PDF sent to the browser when complete. Unix-like environment to run directly in the browser. BROWSIX comprises two core parts: (1) a JavaScript-only system that These web applications generate PDFs server-side out of makes core Unix features (including pipes, concurrent pro- necessity because browsers lack the operating system services cesses, signals, sockets, and a shared file system) available to and execution environment that Unix programs expect.
    [Show full text]
  • Porting C/C++ Applications to the Web PROJECT P1 Fundamental Research Group
    Porting C/C++ applications to the web PROJECT P1 Fundamental Research Group Mentors Nagesh Karmali Rajesh Kushalkar Interns Ajit Kumar Akash Soni Sarthak Mishra Shikhar Suman Yasasvi V Peruvemba List of Contents Project Description Simavr Understanding the Problem Overall Problems Emscripten References Vim.wasm Tetris PNGCrush.js Project Description Lots of educational tools like electronic simulators, emulators, IDEs, etc. are written mostly as a native C/C++ applications. This project is focussed on making these applications run on the web as a service in the cloud. It is focused on porting these desktop applications into their JavaScript counterparts. Understanding the problem 1. Converting the underlying logic written in C/C++ into it’s analogous Javascript file 2. Making sure minimum performance loss occurs during porting. Emscripten 1. Emscripten is an Open Source LLVM to JavaScript compiler. 2. Compile any other code that can be translated into LLVM bitcode into JavaScript. https://emscripten.org/docs/introducing_emscrip ten/about_emscripten.html Installing Emscripten # Get the emsdk repo git clone https://github.com/emscripten-core/emsdk.git # Enter that directory cd emsdk # Fetch the latest version of the emsdk (not needed the first time you clone) git pull # Download and install the latest SDK tools. ./emsdk install latest # Make the "latest" SDK "active" for the current user. (writes ~/.emscripten file) ./emsdk activate latest # Activate PATH and other environment variables in the current terminal source ./emsdk_env.sh Porting of Vim Github Repository https://github.com/rhysd/vim.wasm Source files of Vim that are slightly modified can be found here - https://github.com/rhysd/vim.wasm/compare/a9604e61451707b38fdcb088fbfaeea 2b922fef6...f375d042138c824e3e149e0994b791248f2ecf41#files The Vim Editor is completely written in C.
    [Show full text]
  • Prioritizing Pull Requests
    Prioritizing pull requests Version of June 17, 2015 Erik van der Veen Prioritizing pull requests THESIS submitted in partial fulfillment of the requirements for the degree of MASTER OF SCIENCE in COMPUTER SCIENCE by Erik van der Veen born in Voorburg, the Netherlands Software Engineering Research Group Q42 Department of Software Technology Waldorpstraat 17F Faculty EEMCS, Delft University of Technology 2521 CA Delft, the Netherlands The Hague, the Netherlands www.ewi.tudelft.nl www.q42.com c 2014 Erik van der Veen. Cover picture: Finding the pull request that needs the most attention. Prioritizing pull requests Author: Erik van der Veen Student id: 1509381 Email: [email protected] Abstract Previous work showed that in the pull-based development model integrators face challenges with regard to prioritizing work in the face of multiple concurrent pull requests. We identified the manual prioritization heuristics applied by integrators and ex- tracted features from these heuristics. The features are used to train a machine learning model, which is capable of predicting a pull request’s importance. The importance is then used to create a prioritized order of the pull requests. Our main contribution is the design and initial implementation of a prototype service, called PRioritizer, which automatically prioritizes pull requests. The service works like a priority inbox for pull requests, recommending the top pull requests the project owner should focus on. It keeps the pull request list up-to-date when pull requests are merged or closed. In addition, the service provides functionality that GitHub is currently lacking. We implemented pairwise pull request conflict detection and several new filter and sorting options e.g.
    [Show full text]
  • WASM Deep Dive by Geoff Darst
    WASM Deep Dive By Geoff Darst Introduction The purpose of this document is to take a deep dive into WASM. We will explore the complete end-to- end scenario of compiling C/C++ code to WASM and then loading and executing WASM in Microsoft Flight Simulator. We will perform our investigation from the system level with the goal being to have as complete of an understanding as possible of how WASM works (down to the hardware level) in Microsoft Flight Simulator. This document assumes understanding of how to build WASM in Microsoft Visual Studio for Microsoft Flight Simulator as well as create and deploy the package. For anyone who has not yet built their first WASM, I would recommend doing so prior to continuing with this document. The Platform Toolset instructions can be found here: SDK Documentation (flightsimulator.com). Background What is WASM? WASM stands for Web ASseMbly. It is a specification for an abstract LLVM (Low Level Virtual Machine). The complete specification can be found here: WebAssembly Specification — WebAssembly 1.1 (Draft 2021-05-17). Unlike architectures such as x86-64, which represent physical chips, LLVMs are an abstraction that allows imagining computation without tying it to a specific hardware implementation. The WASM LLVM architecture is that of a stack machine. There are no defined registers in the instruction set. Instead, operations generally involve pushing and popping values from the stack. For example, a binary operation such as Add would pop two values from the stack (the left and right operands) and then push the result of the operation back onto the stack.
    [Show full text]
  • Research.Js: Sharing Your Research on the Web
    Research.js: Sharing Your Research on the Web Joel Galenson, Cuong Nguyen, Cindy Rubio-Gonzalez,´ Christos Stergiou, Nishant Totla University of California, Berkeley fjoel,rubio,chster,[email protected] Abstract We propose helping researchers compile their tools to Most research tools are publicly available but rarely used JavaScript, which would allow anyone with a web browser to due to the difficulty of building them, which hinders the use them. This would allow researchers to make their tools sharing of ideas. Web browsers have recently become an usable online without running their own secure servers. It excellent platform for giving portable demos. Researchers would also allow readers to browse through tool demos as could enable their tools to run in a web browser by compiling easily as they browse through web pages, thereby helping them into JavaScript, making the tools more accessible by them discover ideas that interest them and explore interest- removing the need to configure and build them. In this paper, ing tools. we explore ideas to make sharing research easier. 2. Approach We propose building an infrastructure that makes it easy both 1. Motivation to take an existing project and compile it to JavaScript and When computer scientists create tools in the course of their to put the JavaScript onto a webpage for users to visit. research, they sometimes publicly release them. This is a 2.1 Translation to JavaScript useful practice, as it allows other researchers to evaluate and build on their ideas and potentially enables users to We plan to leverage existing tools that translate programs use a practical tool.
    [Show full text]
  • Is the Web Good Enough for My App?
    Is the Web good enough for my app ? François Daoust (@tidoust), W3C Workshop HTML5 vs Native by software.brussels 4 December 2014 A short history of the Web App platform Tim Berners Lee Olympic games opening ceremony July 2012, London “The Web is an information space in which the items of interest, referred to as resources, are identified by global identifiers called Uniform Resource Identifiers” Architecture of the World Wide Web HTML HTTP URL • Web Standards HTML, CSS, XML, SVG, PNG, XSLT, WCAG, RDF, JavaScript APIs… • Consortium ~400 members, from industry and research • World-wide Offices in many countries • One Web! Founded and directed by Tim Berners-Lee • Global participation 55,000 people subscribed to mailing lists, 1,500+ participants in 60+ Groups User interaction <form action="post.cgi"> <input type="text" name="firstname" /> <input type="submit" title="Submit" /> </form> User interaction <form action="post.cgi"> <input type="text" name="firstname" /> <input type="submit" title="Submit" /> </form> DHTML • Document Object Model (DOM) • JavaScript • Events AJAX XMLHttpRequest Properties of the Web app platform Top-down approach and Extensible Web Manifesto Security • Hard to expose low-level APIs • Beware of fingerprinting Global platform Ex: access to local storage IndexedDB API Human platform Philae vs. CSS Complete platform Communications API Usage HTML5 Web Messaging Inter-app (same browser) WebRTC P2P, real time data/audio/video Network Service Discovery Local network Presentation API Second screen Cross-device communication Presentation API navigator.presentation .startSession('http://example.org/pres.html') .then(function (newSession) { session.onstatechange = function () { switch (session.state) { case 'connected': session.postMessage(/*...*/); session.onmessage = function() { /*...*/ }; break; case 'disconnected': console.log('Disconnected.'); break; } }; }, function () { /*...*/ }); Packaging • Offline execution ApplicationCache Service Workers • Packaging in itself Manifest file Archive (Zip) Native shim (ex.
    [Show full text]
  • Using SD Everywhere to Bring SD Models to Mac, Windows, and the Web
    Using SD Everywhere to Bring SD Models to Mac, Windows, and the Web By Travis Franck and Todd Fincannon Abstract A good user interface makes System Dynamics models come alive for policymakers and stakeholders. This workshop will show how Climate Interactive translates large Vensim models into C and JavaScript code which can be embedded in custom applications. The open source SDEverywhere toolkit developed by Climate Interactive and Todd Fincannon gives you full control over user interface development. We will show how to get SDEverywhere, translate your model, and run it everywhere: on Mac, Windows, and the web. SDEverywhere is one of several new community tools (e.g., SDXchange project, PySD) that are providing open source solutions to make SD models more useful. Visit sdeverywhere.org for the latest updates, tutorials, release information, and news. Required software SDEverywhere currently runs on macOS. You will need a Mac and a text editor such as Atom. We will be working from the command line. You can use the Terminal app that is built into macOS, or try the iTerm2 terminal emulator. The instructions below will guide you through installing the other tools required by SDEverywhere. Xcode Node.js Emscripten SDK Set up SDEverywhere Follow this procedure to set up SDEverywhere on your macOS computer. 1. If you have installed Apple’s Xcode development kit on your Mac, skip this step. Otherwise, open the App Store app on your Mac, search for Xcode , download it, and install it. 2. If you have installed Node.js version 6.11.1 LTS or later, skip this step.
    [Show full text]