This document provides instructions for building Chromium OS from source code. It includes sections on setting up the build environment, retrieving the Chromium OS source code, building packages and images, debugging, and common commands. The build process involves initializing a chroot environment, configuring packages and boards, and compiling the necessary components to create Chromium OS disk images that can be used to install the operating system.
Biscuit: an operating system written in goSeongJae Park
Biscuit is a monolithic operating system kernel that is written in Go. This talk introduces the kernel and demonstrate how to build, install, and analyze the code.
1) Google Chrome OS is an open source operating system designed by Google to run exclusively on web applications using specifically designed hardware based on Linux.
2) Key features include ultra-fast boot times of less than 7 seconds, relying on cloud storage rather than local storage, and a simplified interface focused on web applications.
3) The architecture has three main components - the Chromium-based browser and window manager, system level software and services, and firmware. It is designed for netbooks and tablets with an interface optimized for web use.
Momenti Seminar - 5 Years of RosettaStoneChris Ohk
Momenti Seminar에서 진행했던 "하스스톤 시뮬레이터 RosettaStone 개발 5년 간의 기록"의 발표 자료를 공유드립니다. 5년 동안 오픈 소스 프로젝트를 진행하면서 경험했던 일들을 정리하며 어떤 교훈을 얻었는지 생각해보는 시간이었습니다. 많은 분들에게 도움이 되었으면 합니다.
Google Chrome OS is a lightweight operating system built on the Linux kernel and designed primarily for web applications and web browsing. It is based on the Google Chrome browser and aims to provide a fast, simple, and secure computing experience. Key features include booting in seconds, requiring only a Google login, automatic updates, and storing all data in the cloud to avoid data loss. Applications are web-based and run in a sandbox for security. While hardware-dependent currently, Chrome OS is open source and Google is working with OEMs to make Chrome OS machines available later this year.
Biscuit: an operating system written in goSeongJae Park
Biscuit is a monolithic operating system kernel that is written in Go. This talk introduces the kernel and demonstrate how to build, install, and analyze the code.
1) Google Chrome OS is an open source operating system designed by Google to run exclusively on web applications using specifically designed hardware based on Linux.
2) Key features include ultra-fast boot times of less than 7 seconds, relying on cloud storage rather than local storage, and a simplified interface focused on web applications.
3) The architecture has three main components - the Chromium-based browser and window manager, system level software and services, and firmware. It is designed for netbooks and tablets with an interface optimized for web use.
Momenti Seminar - 5 Years of RosettaStoneChris Ohk
Momenti Seminar에서 진행했던 "하스스톤 시뮬레이터 RosettaStone 개발 5년 간의 기록"의 발표 자료를 공유드립니다. 5년 동안 오픈 소스 프로젝트를 진행하면서 경험했던 일들을 정리하며 어떤 교훈을 얻었는지 생각해보는 시간이었습니다. 많은 분들에게 도움이 되었으면 합니다.
Google Chrome OS is a lightweight operating system built on the Linux kernel and designed primarily for web applications and web browsing. It is based on the Google Chrome browser and aims to provide a fast, simple, and secure computing experience. Key features include booting in seconds, requiring only a Google login, automatic updates, and storing all data in the cloud to avoid data loss. Applications are web-based and run in a sandbox for security. While hardware-dependent currently, Chrome OS is open source and Google is working with OEMs to make Chrome OS machines available later this year.
Google Chrome OS is a lightweight, web-based operating system developed by Google. It is based on the Linux kernel and focuses on running web applications. The OS is designed for netbooks and other lightweight devices. It emphasizes speed, simplicity, and security. When booting, Chrome OS loads directly into the Chrome browser where users can access web apps tied to their Google account. All data and apps are cloud-based. The OS aims to challenge Microsoft's dominance with Windows.
Google Chrome OS is an open-source operating system designed by Google to work exclusively with web applications. It is based on the Linux kernel and can only run on specific hardware. The OS is focused on being fast, simple, and secure. It loads in only a few seconds and keeps users' data in the cloud rather than on a hard drive. Google hopes Chrome OS will make the browser and web the center of users' computing experience.
Chrome OS is an operating system developed by Google that is based on the Linux kernel. It is designed to be lightweight and run web applications from the cloud. Some key points:
- Chrome OS focuses on web-based applications and stores all data in the cloud rather than locally. This allows it to boot very quickly and be secure since losing the physical device does not mean losing data.
- The interface is web-based and integrates with Google services. Applications can be accessed through the Google Chrome Web Store.
- It is open source and designed to be low cost to run on low-powered hardware like netbooks given its lightweight and cloud-focused nature. Regular updates also keep it secure.
This document discusses experimenting with cgroups in Docker containers to isolate processes. It describes installing Docker, launching an Ubuntu container with capabilities enabled, and installing cgroup tools. It then mounts the cpuset and cpu cgroup hierarchies and creates low and high cgroups. Different CPU shares are assigned to each cgroup and processes are run in each to demonstrate the CPU isolation between cgroups.
The document provides an overview of embedded Android, including:
1. It discusses the history and evolution of Android from 2002 to the present, highlighting major versions.
2. It describes the Android ecosystem, which includes over 2 billion active devices worldwide, 2.7 million apps, and Android having 88% of the global smartphone market share.
3. It covers the legal framework for Android, including code access, licenses, branding use, Google's apps, alternative app stores, and the Oracle v. Google lawsuit.
세션 소개
저는 개발자로서 RoamResearch와 VSCode를 사용하던 중 불의의 사고를 겪었습니다. 사고를 겪은 직후, Neovim을 접하고 나서 저의 개발 도구와 글 작성 도구를 모두 이것으로 전환하게 되었습니다. 그만큼 매력적인 도구인 Neovim을 여러분께 소개하고, 100퍼센트 활용할 수 있는 팁까지 공유하고 싶습니다.
발표자 소개
Neovim 에 과몰입한 백엔드 개발자
INTP과 ENFP 사이를 오가는 하이브리드
사색을 좋아하면서 한편으로는 도파민 자극을 좋아합니다
HTML5 Apps on AGL Platform with the Web Application Manager (Automotive Grade...Igalia
By Julie Kim.
Julie will be presenting the work that has been done over the last months to develop for the AGL platform a modern Chromium based Web Application Manager (WAM) that enables running HTML5 IVI applications on the system.
These different applications can define specific levels of integration and security on the platform, and can be run seamlessly on different hardware architectures.
Automotive Grade Linux All Member Meeting Japan 2019
March 5 - 6, 2019
Tokyo, Japan
https://events.linuxfoundation.org/events/agl-all-member-meeting-japan/
The Android graphics architecture uses SurfaceFlinger to composite surfaces from apps into the final display. Apps draw to surfaces using a canvas, which can target OpenGL or a software renderer. Views define a display list of drawing commands. SurfaceFlinger receives surfaces from apps and window status from WindowManager to composite surfaces in z-order before each VSYNC signal.
NDC Python 게임서버 안녕하십니까? : 몬스터 슈퍼리그 게임 서버 편의 후속으로 기획된 발표입니다. 사내 준비 도중 "너굴" 님의 질문에서 시작되었습니다.
이 발표는 잘 알려진 RPC Framework 인 Thrift, gRPC를 살펴보고 예시로 오델로 게임을 만들어보면서 기존 RPC framework 들이 게임의 서버/클라 구조에 잘 어울리지는 살펴보고 왜 몬스터 슈퍼리그에서 그런 선택을 했는지 살펴봅니다.
그리고 게임에 맞게 RPC 를 설계하고 이를 이용하여 온라인 오델로 게임을 완성해봅니다.
XPDS13: Xen in OSS based In–Vehicle Infotainment Systems - Artem Mygaiev, Glo...The Linux Foundation
Xen role, details of implementation and problems in a sample solution based on OSS (Android, Linux and Xen) that addresses Automotive requirements such as ultra-fast RVC boot time, quick IVI system boot time, cloud connectivity and multimedia capabilities, reliability and security through hardware virtualization. Secure CAN/LIN/MOST bus integration handled by Linux on Dom0 while Android runs customizable QML-based HMI in a sandbox of DomU. These case studies will include but not be limited to: computing power requirements, memory requirements, virtualization, stability, boot-time sequence and optimization, video clips showing results of the work done. Case study is built on TexasInstruments OMAP5 SoC.
This document summarizes key aspects of the Android operating system. It discusses what Android is, its architecture, versions, advantages and disadvantages compared to iOS. The architecture section explains that Android is based on the Linux kernel and uses various open source libraries and frameworks. It also summarizes the main applications building blocks in Android like activities, intents, services and content providers. The document concludes by comparing some differences between Android and iOS like open source vs proprietary, supported features and customization options.
Android Studio is a new Android development environment based on IntelliJ IDEA that provides new features over Eclipse ADT and will become the official Android IDE. It features a flexible Gradle-based build system, build variants, code completion, layout editing, and support for Lint and ProGuard. Projects in Android Studio contain modules like JAR and AAR files that are organized in a flattened file structure.
This document summarizes a presentation about Tizen, Firefox OS, and the future of Android. It discusses Tizen's cross-platform capabilities and history. It also outlines the architectures of Tizen, Firefox OS, and Chrome OS and how they relate. The document notes comments by Mark Zuckerberg and Brendan Eich about HTML5 and the potential for the web to replace native apps. It concludes with statistics on the most downloaded apps on iOS and Android and questions about the future of HTML5 performance and Tizen.
Google Chrome OS is a lightweight, web-based operating system developed by Google. It is based on the Linux kernel and focuses on running web applications. The OS is designed for netbooks and other lightweight devices. It emphasizes speed, simplicity, and security. When booting, Chrome OS loads directly into the Chrome browser where users can access web apps tied to their Google account. All data and apps are cloud-based. The OS aims to challenge Microsoft's dominance with Windows.
Google Chrome OS is an open-source operating system designed by Google to work exclusively with web applications. It is based on the Linux kernel and can only run on specific hardware. The OS is focused on being fast, simple, and secure. It loads in only a few seconds and keeps users' data in the cloud rather than on a hard drive. Google hopes Chrome OS will make the browser and web the center of users' computing experience.
Chrome OS is an operating system developed by Google that is based on the Linux kernel. It is designed to be lightweight and run web applications from the cloud. Some key points:
- Chrome OS focuses on web-based applications and stores all data in the cloud rather than locally. This allows it to boot very quickly and be secure since losing the physical device does not mean losing data.
- The interface is web-based and integrates with Google services. Applications can be accessed through the Google Chrome Web Store.
- It is open source and designed to be low cost to run on low-powered hardware like netbooks given its lightweight and cloud-focused nature. Regular updates also keep it secure.
This document discusses experimenting with cgroups in Docker containers to isolate processes. It describes installing Docker, launching an Ubuntu container with capabilities enabled, and installing cgroup tools. It then mounts the cpuset and cpu cgroup hierarchies and creates low and high cgroups. Different CPU shares are assigned to each cgroup and processes are run in each to demonstrate the CPU isolation between cgroups.
The document provides an overview of embedded Android, including:
1. It discusses the history and evolution of Android from 2002 to the present, highlighting major versions.
2. It describes the Android ecosystem, which includes over 2 billion active devices worldwide, 2.7 million apps, and Android having 88% of the global smartphone market share.
3. It covers the legal framework for Android, including code access, licenses, branding use, Google's apps, alternative app stores, and the Oracle v. Google lawsuit.
세션 소개
저는 개발자로서 RoamResearch와 VSCode를 사용하던 중 불의의 사고를 겪었습니다. 사고를 겪은 직후, Neovim을 접하고 나서 저의 개발 도구와 글 작성 도구를 모두 이것으로 전환하게 되었습니다. 그만큼 매력적인 도구인 Neovim을 여러분께 소개하고, 100퍼센트 활용할 수 있는 팁까지 공유하고 싶습니다.
발표자 소개
Neovim 에 과몰입한 백엔드 개발자
INTP과 ENFP 사이를 오가는 하이브리드
사색을 좋아하면서 한편으로는 도파민 자극을 좋아합니다
HTML5 Apps on AGL Platform with the Web Application Manager (Automotive Grade...Igalia
By Julie Kim.
Julie will be presenting the work that has been done over the last months to develop for the AGL platform a modern Chromium based Web Application Manager (WAM) that enables running HTML5 IVI applications on the system.
These different applications can define specific levels of integration and security on the platform, and can be run seamlessly on different hardware architectures.
Automotive Grade Linux All Member Meeting Japan 2019
March 5 - 6, 2019
Tokyo, Japan
https://events.linuxfoundation.org/events/agl-all-member-meeting-japan/
The Android graphics architecture uses SurfaceFlinger to composite surfaces from apps into the final display. Apps draw to surfaces using a canvas, which can target OpenGL or a software renderer. Views define a display list of drawing commands. SurfaceFlinger receives surfaces from apps and window status from WindowManager to composite surfaces in z-order before each VSYNC signal.
NDC Python 게임서버 안녕하십니까? : 몬스터 슈퍼리그 게임 서버 편의 후속으로 기획된 발표입니다. 사내 준비 도중 "너굴" 님의 질문에서 시작되었습니다.
이 발표는 잘 알려진 RPC Framework 인 Thrift, gRPC를 살펴보고 예시로 오델로 게임을 만들어보면서 기존 RPC framework 들이 게임의 서버/클라 구조에 잘 어울리지는 살펴보고 왜 몬스터 슈퍼리그에서 그런 선택을 했는지 살펴봅니다.
그리고 게임에 맞게 RPC 를 설계하고 이를 이용하여 온라인 오델로 게임을 완성해봅니다.
XPDS13: Xen in OSS based In–Vehicle Infotainment Systems - Artem Mygaiev, Glo...The Linux Foundation
Xen role, details of implementation and problems in a sample solution based on OSS (Android, Linux and Xen) that addresses Automotive requirements such as ultra-fast RVC boot time, quick IVI system boot time, cloud connectivity and multimedia capabilities, reliability and security through hardware virtualization. Secure CAN/LIN/MOST bus integration handled by Linux on Dom0 while Android runs customizable QML-based HMI in a sandbox of DomU. These case studies will include but not be limited to: computing power requirements, memory requirements, virtualization, stability, boot-time sequence and optimization, video clips showing results of the work done. Case study is built on TexasInstruments OMAP5 SoC.
This document summarizes key aspects of the Android operating system. It discusses what Android is, its architecture, versions, advantages and disadvantages compared to iOS. The architecture section explains that Android is based on the Linux kernel and uses various open source libraries and frameworks. It also summarizes the main applications building blocks in Android like activities, intents, services and content providers. The document concludes by comparing some differences between Android and iOS like open source vs proprietary, supported features and customization options.
Android Studio is a new Android development environment based on IntelliJ IDEA that provides new features over Eclipse ADT and will become the official Android IDE. It features a flexible Gradle-based build system, build variants, code completion, layout editing, and support for Lint and ProGuard. Projects in Android Studio contain modules like JAR and AAR files that are organized in a flattened file structure.
This document summarizes a presentation about Tizen, Firefox OS, and the future of Android. It discusses Tizen's cross-platform capabilities and history. It also outlines the architectures of Tizen, Firefox OS, and Chrome OS and how they relate. The document notes comments by Mark Zuckerberg and Brendan Eich about HTML5 and the potential for the web to replace native apps. It concludes with statistics on the most downloaded apps on iOS and Android and questions about the future of HTML5 performance and Tizen.
The document discusses web crawling and provides an overview of the process. It defines web crawling as the process of gathering web pages to index them and support search. The objective is to quickly gather useful pages and link structures. The presentation covers the basic operation of crawlers including using a seed set of URLs and frontier of URLs to crawl. It describes common modules in crawler architecture like URL filtering tests. It also discusses topics like politeness, distributed crawling, DNS resolution, and types of crawlers.
This document provides information about different types of automated tests for iOS applications, including:
1. Logic tests and application tests which check code functionality independently and in the context of an app.
2. Xcode test cases that can assert values, perform equality checks, and test for nil values.
3. Performance tests that measure execution time and compare performance of different code implementations.
4. UI automation tests that interact with user interfaces using JavaScript in Instruments to simulate user actions like taps and swipes.
5. Using Jenkins to manage test projects and write custom test scripts.
Google Chrome OS is an open source operating system designed by Google to run exclusively on web applications. It is based on Linux and runs on custom hardware. Google Chrome OS focuses on speed and simplicity, with boot times as fast as 7 seconds and login times of 3 seconds. It has a three-tier architecture including firmware, a web browser, and system-level software and services. Features include printing via Google Cloud Print and handling of file links. Versions include Cherry, Flow, Zero and Vanilla. Google Chrome OS and Android are two open source operating systems from Google that are converging over time.
EyeOS is an open source web desktop platform that allows users to access applications and files from any internet-connected device using only a web browser. It provides office applications, multimedia apps, and development tools. EyeOS aims to eliminate compatibility issues between devices and operating systems by providing centralized access and storage of files through the web. Key goals include allowing work from any device and sharing resources between locations. Benefits include worldwide access via the internet, requiring only a browser, customizable interfaces, extensive application selection, and remote file storage and editing.
Web Crawling and Data Gathering with Apache NutchSteve Watt
Apache Nutch is an open source web crawler built on Hadoop. It crawls websites, indexes the downloaded content using Lucene, and supports querying the index via Solr. The crawl process involves seeding, filtering, fetching pages, indexing content, and merging results. Nutch can crawl websites in a single process or distributed mode using Hadoop. It provides tools to inject URLs, read crawl segments from HDFS, and demonstrate the crawl lifecycle.
Tutorial given at ICWE'13, Aalborg, Denmark on 08.07.2013
Abstract:
Web crawling, a process of collecting web pages in an automated manner, is the primary and ubiquitous operation used by a large number of web systems and agents starting from a simple program for website backup to a major web search engine. Due to an astronomical amount of data already published on the Web and ongoing exponential growth of web content, any party that want to take advantage of massive-scale web data faces a high barrier to entry. In this tutorial, we will introduce the audience to five topics: architecture and implementation of high-performance web crawler, collaborative web crawling, crawling the deep Web, crawling multimedia content and future directions in web crawling research.
To cite this tutorial:
Please refer to http://dx.doi.org/10.1007/978-3-642-39200-9_49
Web crawlers, also known as robots or bots, are programs that systematically browse the internet and index websites for search engines. Crawlers follow links from seed URLs and download pages to extract new URLs to crawl. They use techniques like breadth-first crawling to efficiently discover as much of the web as possible. Crawlers must have policies to select pages, revisit sites, be polite to not overload websites, and coordinate distributed crawling. Their high-performance architecture is crucial for search engines to comprehensively index the large and constantly changing web.
Google announced an open source operating system called Chrome OS in November 2009. Based on the Linux family and Ubuntu, Chrome OS is designed to be used primarily for web applications with an emphasis on being always connected, instantly booting up, having security built in, and automatically receiving updates. Chrome notebooks boot up in about 10 seconds and resume from sleep instantly while providing access to web apps, the cloud, and integrated Wi-Fi and 3G connectivity.
The document discusses different types of operating systems. It defines an operating system as software that allows computer hardware and software to communicate and function. It then describes GUI operating systems as using graphics and icons navigated by a mouse. It also covers multi-user systems that allow multiple users to access a computer simultaneously or at different times, as well as multiprocessing systems that support more than one processor, and multitasking and multithreading systems that run multiple processes concurrently. Finally, it mentions embedded systems designed for devices like PDAs with limited resources.
Crawling the Web (for fun and profit) discusses how web crawlers systematically browse the internet and how they allow search engines to index only a portion of the deep web. The document also outlines several potential uses for custom web crawlers, including backup archiving, social network analysis, trend tracking, and building one's own search engine. With a basic framework like Scrapy, even individuals can build crawlers to extract useful data and information from the internet.
Google Chrome OS is an open source operating system designed by Google to work exclusively with web applications. It is based on Linux and will run only on specifically designed hardware. Google Chrome OS aims to be very fast, simple, and secure. It focuses on web browsing and cloud computing. Some drawbacks are the absence of a traditional desktop interface and heavy reliance on Google services.
This document summarizes a seminar presentation on Google Chrome OS. It begins with an introduction on the speed of Chrome OS and defines its "waightlessness". It then defines Google Chrome as a free, open-source browser developed by Google in 2008. It discusses how Chrome OS uses the cloud, requiring an internet connection and storing minimal user data and preferences in the cloud. The advantages are discussed as being lightweight, open source, internet-focused, and fast. Limitations include reliance on the web and potential hardware compatibility issues. The methodology, experimental design, sample questionnaire, and rejected methods are summarized. It concludes that Chrome OS is becoming more usable with regular updates.
The document discusses Google Chrome OS, an open-source operating system designed by Google to run on specifically designed hardware and exclusively with web applications. It provides an overview of Chrome OS including its history, versions, targeted users, features, benefits, limitations, and future. The group's project is on Chrome OS and includes an introduction, brief history covering early Chromebooks and expansions, descriptions of the Chromebook Pixel and controversies, security features, and future plans which include making Chromebooks more integrated with Android and the future of computing.
Booting Android: bootloaders, fastboot and boot imagesChris Simmonds
This document discusses booting Android devices. It covers Android boot images, bootloaders, fastboot protocol, and file systems used for different types of flash memory in Android devices. The key topics covered include bootloaders loading the boot and recovery images, the fastboot protocol for flashing and debugging, and file systems like ext4, f2fs, yaffs2 used on different flash chips like eMMC, SD cards, and raw NAND flash.
This whitepaper discusses the current state of availability and readiness between the three Cloud OS's which have been evangelized into commercial readiness by Google.
ChromeOS, sometimes stylized as chromeOS and formerly styled as Chrome OS, is a Linux-based operating system designed by Google. It is derived from the open-source ChromiumOS and uses the Google Chrome web browser as its principal user interface.
Chrome OS is an operating system developed by Google based on the Linux kernel. It uses the Google Chrome browser as its primary interface and focuses on cloud storage and web applications. Chromebooks running Chrome OS boot very quickly, in 5-7 seconds, and rely on being constantly connected to the internet for apps and storage via a user's Google account. Chrome OS emphasizes security through sandboxing each web page and app and verifying the OS hasn't been tampered with each startup. However, it has limited offline storage and support for non-web programs.
Executing Parallel Test Sessions with TestNG and Selenium WebDriverpCloudy
In today’s fast-paced world, the primary goal of every business is to release their websites or mobile applications to the end users as early as possible. As a result, businesses constantly search for ways to test, measure, and improve their products. With the increase in competition, faster time to market has become an important aspect for any business to survive in today’s competitive market . However, one of the possible challenges many businesses face is the release cycle time, which usually gets extended for various reasons.
This paper attempts to look behind the wheels of android and keeping special focus on custom rom’s and basically check for security misconfiguration’s which could yield to device compromise, which may result in malware infection or data theft.
This document discusses security issues that can arise in custom Android ROMs. It identifies several practices that could compromise device security, such as having USB debugging or ADB shell enabled with root access, insecure permissions on the system partition, or installing apps from unknown sources. The document provides examples of how these issues could be exploited. It also discusses how ROM developers and users can help protect devices by disabling unnecessary settings and being cautious of untrusted connections or apps.
Puppeteer is a Node library that provides a high-level API to control headless Chrome or Chromium over the DevTools Protocol. It can generate screenshots, crawl SPAs, automate form submission and UI testing, and more. Puppeteer communicates with the browser using the DevTools Protocol and controls browser instances, browser contexts within instances, pages within contexts, and frames within pages. It is maintained by the Chrome DevTools team.
BISP is committed to provide BEST learning material to the beginners and advance learners.
In the same series, we have prepared a complete end-to end Hands-on Guide for WebLogic
Administration. The document focuses on how to install, configure and post configuration steps.
Join our professional training program and learn from experts.
Scaling mobile testing on AWS: Emulators all the way downKim Moir
This talk will explore the evolution of Mozilla's continuous integration infrastructure for Firefox for Android. From our early device lab, to running tests on reference cards in custom racks, to our current implementation running on emulators in AWS. In addition, I'll discuss how we reduced the cost of running our tests in AWS by the use of spot instances, and fine tuning the selection of instance types. Finally, I'll discuss how we analyzed regression data to prune the number of tests we run to extend the capacity of our test pools and reduce costs. To give you some scope, our continuous integration farm consists of 6700 machines, 150,000 combined daily build and test jobs that are triggered by an average 300 pushes. This talk was given at USENIX release engineering summit in Washington, DC on November 13, 2015.
Google Chrome OS is an open-source operating system that is optimized for web applications and utilizes cloud computing. It was announced in 2009 and targets netbook users who primarily use the web. Chrome OS incorporates the Google Chrome browser as its interface and stores all information in the cloud to maximize speed and security. It is designed to boot in seconds and always keep software up to date without user involvement.
This document provides an overview of Chrome OS, including what makes it different from other operating systems, its architecture, characteristics, security features, and future development. Chrome OS relies entirely on web-based applications and cloud-based storage rather than local software. It is designed to be fast booting and secure due to its minimal locally stored data and built-in security sandbox for web content. Going forward, Chrome OS and Android are expected to converge further as development continues.
Chrome OS is a Linux-based operating system developed by Google to work primarily with web applications. It is designed to be lightweight and boot and run quickly. The user interface consists almost entirely of the Google Chrome web browser. While Chrome OS emphasizes web apps and cloud storage of files, it still faces some limitations including heavy reliance on internet connectivity and lack of full-featured offline applications like photo editors. It also lacks local printing capability when offline.
This document provides guidelines for cross browser testing. It defines cross browser compatibility as making a website work across different browsers and versions. It lists several free and paid tools that can be used for cross browser testing. It also provides a checklist of items to test, including HTML/CSS validation, JavaScript, Ajax, formatting, and special characters across browsers.
Installing Cognos 10: Tips and Tricks from the Trenches – Questions & Answers Senturus
Senturus experts answer nearly 100 questions raised by participants during the Installing Cognos 10: Tips and Tricks from the Trenches webinar. View the video recording and download this deck: http://www.senturus.com/resources/installing-cognos-10-2-1-tips-tricks-trenches/.
Topics include:
• Commonly encountered installation issues and how-to advice on streamlining a Cognos 10 upgrade
• Cognos 10 BI server core components
• Cognos 10 search index required post-install
• Navigating the maze of 32-bit and 64-bit
Senturus, a business analytics consulting firm, has a resource library with hundreds of free recorded webinars, trainings, demos and unbiased product reviews. Take a look and share them with your colleagues and friends: http://www.senturus.com/resources/.
Usage Note of Apache Thrift for C++ Java PHP LanguagesWilliam Lee
Thrift is used to define interfaces and generate code to build RPC clients and servers. The document discusses installing tools and libraries needed for Thrift including GCC, Boost, Java, Ant, Autoconf and others. It then covers generating code for C++, Java and PHP from a Thrift IDL file and running a sample Thrift server and clients in C++ and Java.
Usage Note of Qt ODBC Database Access on LinuxWilliam Lee
This document provides instructions for setting up ODBC database access on Linux using Qt. It describes installing the unixODBC library, Microsoft SQL Server ODBC driver, and Qt ODBC SQL driver plugin. It also explains how to create a DSN, use the sqlcmd tool to connect to SQL Server, and write Qt applications that use the ODBC driver plugin to connect via ODBC.
SWIG is a tool that connects C/C++ code to scripting languages like PHP. It works by taking C/C++ declarations and generating wrapper code. To use SWIG with PHP: 1) Write a SWIG interface file; 2) Run SWIG to generate wrapper code; 3) Compile the wrapper code into a PHP extension. The extension can then be loaded in PHP to access functions defined in the C/C++ code.
Upgrade GCC & Install Qt 5.4 on CentOS 6.5 William Lee
This document provides instructions to upgrade GCC to version 4.9.0 and install Qt 5.4.1 on CentOS 6.5. It describes downloading and compiling GCC from source, setting it as the default compiler, and copying libraries. It also covers downloading and running the Qt 5.4.1 installer, adding Qt commands to the PATH, and copying pkg-config files. The goal is to support C++11 and have a newer compiler and Qt version on the older CentOS 6.5 operating system.
This document provides instructions and information for using the Bro network security monitor and its associated tools. It discusses installing Bro from source and describes Bro's architecture and event-based model. It also explains how to use Bro tools like BroControl and inspect Bro logs. The document outlines how to write Bro scripts and filter network traffic. It demonstrates reading pcap files with Bro and communicating with Bro using the Broccoli library.
Usage Note of Microsoft Dependency WalkerWilliam Lee
Dependency Walker is a free utility that scans 32-bit and 64-bit Windows modules to build a hierarchical tree showing module dependencies. It detects common application problems such as missing or invalid modules. It can be run as a graphical or console application, and handles various types of module dependencies. Dependency Walker runs on many versions of Windows, and can process modules for Windows CE. It is similar to the "ldd" and "nm" tools for Unix systems, and shows which functions a module exports and calls.
PlayCap is a packet replay tool that allows users to replay packet capture (PCAP) files by reading the files and sending the captured packets to a selected network interface. It has a graphical user interface and was created by Signal11. To use PlayCap, download the source code, build it using CMake, open a PCAP file, select a network interface, and click "Playback" to replay the packets. Other packet replay tools include those integrated with Wireshark, while sites like the Bro IDS wiki collect packet traces for analysis or replay.
This document describes how to implement kinetic scrolling in a Qt application. It discusses using mouse events to enable dragging and scrolling of a list. It also explains how to simulate inertia or kinetic scrolling by recording drag velocity and applying deceleration to continue scrolling the list even after dragging stops. Code examples and links are provided to help understand the implementation and see it in action. The document also covers setting up the Qt development environment and using tools like Qt Creator and Doxygen to build, run and document Qt applications.
The manual of the GTK+ 2.0 application - Desktop App Chooser which let the user to browse all installed X desktop applications and retrieve the Desktop Entry content of each application.
This document provides an overview of common gateway interface (CGI) and active server pages (ASP) for generating dynamic web pages. It explains that CGI involves running a separate process for each request, which can reduce performance. ASP was developed to address this by allowing tags to be inserted into web pages that are replaced with dynamic data when the page loads, without needing a separate process. The document also describes how form data is received in CGI and the basic workflow of CGI and ASP programs.
Moblin2 - Window Manager(Mutter) PluginWilliam Lee
The document summarizes key aspects of the Moblin2 window manager Mutter including:
- Mutter is based on Metacity and uses Clutter for rendering. It loads plugins from /usr/lib/metacity/plugins/clutter/ such as default.so and moblin-netbook.so.
- Plugins are loaded in mutter_display_open() and implement common interfaces like minimize() and map().
- The Clutter stage is initialized in clutter_cmp_manage_screen() and displayed in an overlay window layer.
- Custom content can be added in a plugin's constructed() function. Debug messages can be added using g_debug().
MGCP is a protocol used to control media gateways that convert between audio signals and data packets. It uses a master-slave architecture with a media gateway controlled by a call agent. MGCP commands include CRCX to create connections, MDCX to modify them, and DLCX to delete them. Basic call flows include the media gateway registering with the call agent, creating a call by requesting digits and notifying of events, and terminating a call by deleting connections on hook events.
This document discusses configuring Asterisk IP-PBX call detail record (CDR) log rotation using Linux cron jobs and the logrotate tool. It explains that Asterisk stores CDRs in CSV format files by default, and that logrotate can be used to automatically rotate and compress and delete old CDR log files on a daily basis. Instructions are provided on setting up a logrotate configuration file and cron job to implement automatic CDR log rotation.
L.A.M.P Installation Note --- CentOS 6.5William Lee
- The document provides installation and configuration instructions for LAMP (Linux, Apache, MySQL, PHP) on a CentOS 6.5 server.
- It details how to install and configure the core LAMP components like Apache 2.2, MySQL 5, and PHP 5 as well as additional components like phpMyAdmin.
- Troubleshooting tips are provided for common Apache and PHP issues along with explanations and solutions.
- Configuration files and their settings are described for optimal performance of the LAMP stack.
This document summarizes the Butterfat Internationalization (b28n) project, which implements internationalization in a JavaScript library (b28n.js) that reads XML files to translate text. It describes how to use the b28n library by creating language-specific XML files, including b28n.js, setting the text domain, and translating elements by id. It also explains how to set the user's language preference in a cookie and reload the page.
This document provides notes and code samples for using SQLite3 in C applications. It includes information on resolving link errors when building SQLite3 applications, the two forms of the LIMIT clause, using the sqlite3_get_table() function to retrieve and iterate through query results, and using the Firefox SQLite Manager add-on to view and edit SQLite databases. Code samples demonstrate getting the total record count of a table, iterating through retrieved records in different ways, and connecting and querying a SQLite database.
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
HCL Notes und Domino Lizenzkostenreduzierung in der Welt von DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-und-domino-lizenzkostenreduzierung-in-der-welt-von-dlau/
DLAU und die Lizenzen nach dem CCB- und CCX-Modell sind für viele in der HCL-Community seit letztem Jahr ein heißes Thema. Als Notes- oder Domino-Kunde haben Sie vielleicht mit unerwartet hohen Benutzerzahlen und Lizenzgebühren zu kämpfen. Sie fragen sich vielleicht, wie diese neue Art der Lizenzierung funktioniert und welchen Nutzen sie Ihnen bringt. Vor allem wollen Sie sicherlich Ihr Budget einhalten und Kosten sparen, wo immer möglich. Das verstehen wir und wir möchten Ihnen dabei helfen!
Wir erklären Ihnen, wie Sie häufige Konfigurationsprobleme lösen können, die dazu führen können, dass mehr Benutzer gezählt werden als nötig, und wie Sie überflüssige oder ungenutzte Konten identifizieren und entfernen können, um Geld zu sparen. Es gibt auch einige Ansätze, die zu unnötigen Ausgaben führen können, z. B. wenn ein Personendokument anstelle eines Mail-Ins für geteilte Mailboxen verwendet wird. Wir zeigen Ihnen solche Fälle und deren Lösungen. Und natürlich erklären wir Ihnen das neue Lizenzmodell.
Nehmen Sie an diesem Webinar teil, bei dem HCL-Ambassador Marc Thomas und Gastredner Franz Walder Ihnen diese neue Welt näherbringen. Es vermittelt Ihnen die Tools und das Know-how, um den Überblick zu bewahren. Sie werden in der Lage sein, Ihre Kosten durch eine optimierte Domino-Konfiguration zu reduzieren und auch in Zukunft gering zu halten.
Diese Themen werden behandelt
- Reduzierung der Lizenzkosten durch Auffinden und Beheben von Fehlkonfigurationen und überflüssigen Konten
- Wie funktionieren CCB- und CCX-Lizenzen wirklich?
- Verstehen des DLAU-Tools und wie man es am besten nutzt
- Tipps für häufige Problembereiche, wie z. B. Team-Postfächer, Funktions-/Testbenutzer usw.
- Praxisbeispiele und Best Practices zum sofortigen Umsetzen
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
Driving Business Innovation: Latest Generative AI Advancements & Success StorySafe Software
Are you ready to revolutionize how you handle data? Join us for a webinar where we’ll bring you up to speed with the latest advancements in Generative AI technology and discover how leveraging FME with tools from giants like Google Gemini, Amazon, and Microsoft OpenAI can supercharge your workflow efficiency.
During the hour, we’ll take you through:
Guest Speaker Segment with Hannah Barrington: Dive into the world of dynamic real estate marketing with Hannah, the Marketing Manager at Workspace Group. Hear firsthand how their team generates engaging descriptions for thousands of office units by integrating diverse data sources—from PDF floorplans to web pages—using FME transformers, like OpenAIVisionConnector and AnthropicVisionConnector. This use case will show you how GenAI can streamline content creation for marketing across the board.
Ollama Use Case: Learn how Scenario Specialist Dmitri Bagh has utilized Ollama within FME to input data, create custom models, and enhance security protocols. This segment will include demos to illustrate the full capabilities of FME in AI-driven processes.
Custom AI Models: Discover how to leverage FME to build personalized AI models using your data. Whether it’s populating a model with local data for added security or integrating public AI tools, find out how FME facilitates a versatile and secure approach to AI.
We’ll wrap up with a live Q&A session where you can engage with our experts on your specific use cases, and learn more about optimizing your data workflows with AI.
This webinar is ideal for professionals seeking to harness the power of AI within their data management systems while ensuring high levels of customization and security. Whether you're a novice or an expert, gain actionable insights and strategies to elevate your data processes. Join us to see how FME and AI can revolutionize how you work with data!
Programming Foundation Models with DSPy - Meetup SlidesZilliz
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
GraphRAG for Life Science to increase LLM accuracyTomaz Bratanic
GraphRAG for life science domain, where you retriever information from biomedical knowledge graphs using LLMs to increase the accuracy and performance of generated answers
“An Outlook of the Ongoing and Future Relationship between Blockchain Technologies and Process-aware Information Systems.” Invited talk at the joint workshop on Blockchain for Information Systems (BC4IS) and Blockchain for Trusted Data Sharing (B4TDS), co-located with with the 36th International Conference on Advanced Information Systems Engineering (CAiSE), 3 June 2024, Limassol, Cyprus.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
Let's Integrate MuleSoft RPA, COMPOSER, APM with AWS IDP along with Slackshyamraj55
Discover the seamless integration of RPA (Robotic Process Automation), COMPOSER, and APM with AWS IDP enhanced with Slack notifications. Explore how these technologies converge to streamline workflows, optimize performance, and ensure secure access, all while leveraging the power of AWS IDP and real-time communication via Slack notifications.
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
Building Production Ready Search Pipelines with Spark and MilvusZilliz
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
2. Index
Introduction........................................................................................................................................................ 4
FAQ ..................................................................................................................................................................... 5
Usage ................................................................................................................................................................... 7
SW Architecture................................................................................................................................................. 9
Build Process .....................................................................................................................................................11
Portage Build System................................................................................................................................11
Prerequisites ............................................................................................................................................. 12
Setup Build Envrionment........................................................................................................................ 12
Build Chromium Browser....................................................................................................................... 13
Init Setup........................................................................................................................................... 13
Get the Code..................................................................................................................................... 13
Install Prerequisite Liraries ............................................................................................................ 13
Add debugging Messages ................................................................................................................ 13
Build Chromium OS................................................................................................................................ 14
i> Initial Setup.................................................................................................................................. 14
ii> Get the Code................................................................................................................................ 14
iii> Create a chroot .......................................................................................................................... 15
iv> Enter the chroot......................................................................................................................... 17
v> Set up board ................................................................................................................................ 18
vi> Enable a local user(guest) account (optioal) ........................................................................... 20
viii> Set the shared user password (optioal).................................................................................. 21
ix> Build packages ........................................................................................................................... 21
x> Build image.................................................................................................................................. 22
Start working on a package............................................................................................................. 26
Stop working on a package ............................................................................................................. 27
Autotest............................................................................................................................................. 27
Chrome Web Apps ........................................................................................................................................... 29
Concepts.................................................................................................................................................... 29
Apps................................................................................................................................................... 29
Themes .............................................................................................................................................. 29
Extensions......................................................................................................................................... 29
Installable Web Apps ............................................................................................................................... 29
Host Apps.......................................................................................................................................... 30
Packaged Apps ................................................................................................................................. 30
New Features .................................................................................................................................................... 31
Remote Desktop Capabilities - Chromoting.......................................................................................... 31
GPU Accelerated Compositing – WebGL.............................................................................................. 31
Reference .......................................................................................................................................................... 33
Google Chromium OS Main Site – http://www.chromium.org/............................................................. 33
Introduction.............................................................................................................................................. 33
FAQ ........................................................................................................................................................... 33
3. Usage ......................................................................................................................................................... 33
SW Architecture....................................................................................................................................... 33
Build Process ............................................................................................................................................ 33
Debugging................................................................................................................................................. 34
New Features ............................................................................................................................................ 34
Chrome Web App..................................................................................................................................... 34
4. Introduction
Chromium OS is the open source development version of Google's Chrome OS. Chrome OS's source code
was released on November 19, 2009 under the BSD license as Chromium OS.
5. FAQ
Q1. The distinction between Google Chrome OS and Chromium OS.
Ans : Google Chrome OS is to Chromium OS what Google Chrome browser is to Chromium. Chromium OS
is the open source project, used primarily by developers, with code that is available for anyone to
checkout, modify and build their own version with.
Q2. Should I call my build Chromium OS or Google Chrome OS?
Ans : You should call it Chromium OS.
Q3. Will the autoupdate feature work on both Google Chrome OS and Chromium OS?
Ans : We don't plan to support autoupdate on Chromium OS, as we did not build the binaries, and we don't
know what modifications you've made to the system, so we don't want to blow away any changes you
may have made to the code. Therefore Google will not autoupdate Chromium OS systems, but you're
welcome to set up your own autoupdate server.
Google Chrome OS will autoupdate to keep consumer machines running the latest and greatest at all
times.
Q4. Will the verified boot feature work on both Google Chrome OS and Chromium OS?
Ans : The verified boot procedure relies on custom firmware and hardware modifications and hence will work
with only Google Chrome OS netbooks.
Q5. Where can I download Google Chrome OS?
Ans : Google Chrome OS is not a conventional operating system that you can download or buy on a disc and
install. As a consumer, the way you will get Google Chrome OS is by buying a netbook that has Google
Chrome OS installed by the OEM. Google Chrome OS is being developed to run on new machines that
are specially optimized for increased security and performance. We are working with manufacturers to
develop reference hardware for Google Chrome OS. These netbooks will be available in the fourth
quarter of 2010.
If you are the kind of developer who likes to build an open source operating system from scratch, you
can check out Chromium OS, build it and experiment with it. A number of sites have also posted
pre-built binaries of Chromium OS. However, these downloads are not verified by Google, therefore
please ensure you trust the site you are downloading these from.
Keep in mind that Chrome OS is not yet ready for general consumer use.
Q6. Is it true that you don't support hard disk drives (HDDs)?
Ans : Firstly, we should point out that the information in the open source release has been misinterpreted as
saying that we don't support local storage. We do, but we are asking our hardware partners for Google
Chrome OS to use solid state drives (SSDs) rather than hard disk drives (HDDs), for performance and
reliability reasons.
Secondly, this restriction doesn't apply to Chromium OS : It will work with conventional HDDs,
though the disk accesses are optimized for flash-based storage, like reduced read-ahead.
6. Clarification for Chromium OS (post on 2009/12/11)
1. This is not ready for consumers yet — everything you see can and probably will change by the time
Google Chrome OS-based devices are available late next year.
2. Please note that Google has not released an official binary for Chromium OS and therefore if you
download Chromium OS binaries please ensure that you trust the site you are downloading them from.
3. While we will try our best to help you through the Chromium discussion forums, we will not be officially
supporting any of these builds. Remember that you are downloading that specific site/developer's build of
Chromium OS.
7. Usage
1. I can't log in!!!
Ans : Login may fail under various circumstances. For example, if you do not have network connectivity
and you have never logged in before, then you will not be able to log in.
The login screen should display a message beneath the username/password input field. For example, if
you have network connectivity and provide the wrong credentials, you will be told that either your
username or password is incorrect.
To troubleshoot networking at this point, you have to jump to a virtual terminal (only enabled on dev
machines) by using Ctrl+Alt+F2 and entering the shared user password that you optionally set as part
of the build process. If you did not set this field, you will not be able to debug networking and
should plug into Ethernet at your earliest convenience.
If you are able to log in to the virtual terminal, reconfigure the networking service (sudo initctl restart
flimflam).
Note: If you are having trouble with wireless, just plug in an Ethernet cable. It is much easier to
troubleshoot a networking issue once you have logged in.
For more information about login errors, look at the log files:
* /var/log/libcros_log - logging related to chromium's interaction with system services
* /home/chronos/chrome_log - login manager (which is, actually, chrome) logs
2. I log in but the browser does not appear
Ans : If you do not have a black screen, try using the hotkey Ctrl+Alt+N to open a new window. If this
doesn't work, check slim.log to verify whether it's an error in slim, or in something else. The logs you
may be concerned about are:
* /var/log/messages
* /var/log/window_manager/chromoeos-wm.LATEST - for pre-login window manager logs
* /home/chronos/user/log/chromoeos-wm.LATEST - for post-login window manager logs
3. Wireless drops and does not reconnect
Ans : Drop into a terminal either through vt02 (Ctrl+Alt+F2) or Ctrl+Alt+T. Reconfiguring the connman
service may fix the problem.
4. What are the shortcut keys?
Ans : To get a visual overlay of shortcut keys available, hit F8 and then hold modifier keys like Ctrl, Alt, and
Shift to see the associated hotkeys.
Most browser shortcuts also apply :
http://www.google.com/support/chrome/bin/answer.py?hl=en&answer=95743
8. Are native applications supported?
Google Chrome OS is a web-centric system, so all applications are web applications; this provides powerful
and simple manageability and security. To write applications that will benefit from native code execution we
recommend using NativeClient, an open source project that allows web apps to run native code securely
within a browser. See http://code.google.com/p/nativeclient/ for more details.
Of course Chromium OS is open source, and it's Linux. This means that as a developer you can do pretty
much anything you want, including installing any Linux application.
Under Linux, web apps locate in "/opt/google/chrome/resources".
Action When Feature
F12 Running Toggle Window Overview mode.
It brings up a multi-window view, with the option to open additional browser
windows and switch between them.
F8 Running Toggle keyboard overlay showing all the shortcut keys and a command-line
interface that accepts common Linux commands.
Escape Window
Overview
Exit Window Overview mode.
F2 Boot Startup options - disable internal HDD to boot from USB stick
Ctrl + Alt + T Running Open a terminal window
Ctrl + Alt + L Running Lock the screen
Ctrl + Alt + M Running Enable external monitor
Ctrl + , Chrome Go to battery and network settings page
Ctrl + Tab Chrome Next Tab
Ctrl + Shift + Tab Chrome Prior Tab
Ctrl + 1 through
Ctrl + 8
Chrome Switches to the tab at the specified position number on the tab strip
Alt + Tab Running Next Window
Alt + Shift + Tab Running Prior Window
Close Lid Running Sleep mode
Power-Key Running Shutdown
Print Screen Running Take a screenshot and save it to
/home/chronos/user/Downloads/Screenshots/screenshot-YYYYMMDD-HH
MMSS.png
Ctrl-SPACE Running Select the previous input method
Shift-Alt Running Circle through the active input methods
9. SW Architecture
Chromium OS consists of three major components :
* The Chromium-based browser and the window manager handling user interaction
* System-level software and user-land services : the kernel, drivers, connection manager, and so on
* Firmware
Chromium and the window manager
The window manager is responsible for handling the user's interaction with multiple client windows. It does
this in a manner similar to that of other X window managers, by controlling window placement, assigning the
input focus, and exposing hotkeys that exist outside the scope of a single browser window. Parts of the
ICCCM (Inter-Client Communication Conventions Manual) and EWHM (Extended Window Manager Hints)
specifications are used for communication between clients and the window manager where possible.
The window manager also uses the XComposite extension to redirect client windows to offscreen pixmaps so
that it can draw a final, composited image incorporating their contents itself. This lets windows be
transformed and blended together. The Clutter library is currently used to animate these windows and to
render them via OpenGL or OpenGL|ES.
System-level and user-land software
From here we bring in the Linux kernel, drivers, and user-land daemons. Our kernel is mostly stock except for
a handful of patches that we pull in to improve boot performance. On the user-land side of things we have
streamlined the init process so that we're only running services that are critical. All of the user-land services
are managed by Upstart. By using Upstart we are able to start services in parallel, re-spawn jobs that crash,
10. and defer services to make boot faster.
Here's a quick list of things that we depend on :
D-Bus – The browser uses D-Bus to interact with the rest of the system. Examples of this include the battery
meter and network picker.
Connection Manager – Provides a common API for interacting with the network devices, provides a DNS
proxy, and manages network services for 3G, wireless, and ethernet.
WPA Supplicant – Used to connect to wireless networks.
Autoupdate – Our autoupdate daemon silently installs new system images.
Power Management – (ACPI on Intel) Handles power management events like closing the lid or pushing the
power button.
xscreensaver – Handles screen locking when the machine is idle.
Standard Linux services – NTP, syslog, and cron.
Firmware
The firmware plays a key part to make booting the OS faster and more secure. To achieve this goal we are
removing unnecessary components and adding support for verifying each step in the boot process. We are also
adding support for system recovery into the firmware itself. We can avoid the complexity that's in most PC
firmware because we don't have to be backwards compatible with a large amount of legacy hardware. For
example, we don't have to probe for floppy drives.
Our firmware will implement the following functionality :
* System recovery – The recovery firmware can re-install Chromium OS in the event that the system has
become corrupt or compromised.
* Verified boot – Each time the system boots, Chromium OS verifies that the firmware, kernel, and system
image have not been tampered with or become corrupt. This process starts in the firmware.
* Fast boot – We have improved boot performance by removing a lot of complexity that is normally found in
PC firmware.
11. Build Process
The computer to pratices steps in this document :
* Intel i7 CPU
* 3G RAM
* Ubuntu 10.04 Lucid 64-bit
Portage Build System
The Chromium project started to use Portage build system from Gentoo in Feb, 2010.
Portage is a package management system used by Gentoo, based on the concept of ports collections of
FreeBSD. Ports collections (or ports trees, or just ports) are the sets of makefiles and patches provided by
the BSD-based operating systems.
Each “port” listed here contains any patches necessary to make the original application source code compile.
Each port's Makefile automatically fetches the application source code, either from a local disk, CD-ROM or
via ftp, unpacks it on your system, applies the patches, and compiles. If all went well, a simple make install
will install the application and register it with the package system.
Precompiled (binary) ports are called packages. For most ports, a precompiled package also exists, saving
the user the work of having to compile anything at all. Each port contains a link to its corresponding package.
Gentoo Portage tree does not contain directories of Makefiles, but of so-called ebuilds, bash scripts that
describe separate functions to download, configure, make, install and remove a package and additional
functions that can be used to set up the operating environment for a package.
ebuilds are shell scripts with variables and functions which contain a description of the software, and
instructions on how to obtain, configure, compile, and install it, more closely akin to (but more powerful than)
the .spec files distributed in SRPMs.
Portage's main utility is emerge, which is written in Python and can be used by privileged users to easily
inspect and alter the set of installed packages on a Gentoo operating system.
emerge provides an interface to ebuild : managing an ebuild repository, resolving dependencies and similar
issues.
emerge calculates and manages dependencies, executes ebuilds and maintains the local Portage tree and
database of installed packages. The compilation settings used by ebuilds can be changed through the
CFLAGS environment variable, based on the specifications of the individual computer and on the user's
desire for optimization.
emerge and ebuild therefore have roughly the same relation as rpm has with yum, or dpkg has with APT.
The Portage system offers the use of "USE flags," which allows users to indicate which software features they
would like to include (and exclude) while building packages. The USE flags affect which dependencies are
required, generally affecting which optional features will be built into a given program when it is compiled.
12. For example, in packages which use a configure script, the USE flag feature would translate to :
./configure --with-feature
.
Prerequisites
You need to have Linux. We currently support the following :
* Ubuntu (Hardy 8.04 or newer, Lucid 10.04 recommended)
* A 64-bit system for performing the build
* An account with root access (needed to run chroot and modify the mount table)
* Chromium browser (binary or build it from source)
* Tools : repo, GIT (need git-core library)
Setup Build Envrionment
For those who use company’s network connecting to the internetwork, it should set the following environment
variable :
export GIT_PROXY_COMMAND=set-git-proxy.sh
export http_proxy=http://10.110.15.60:8080
, where “set-git-proxy.sh”’s contnet is as :
and the shell script file name, “set-git-proxy.sh”, could be changed as you wish.
#! /bin/bash
(echo "CONNECT $1:$2 HTTP/1.0"; echo; cat ) | socket 10.110.15.60 8080 | (read a; read a; cat )
13. Build Chromium Browser
Init Setup
Dowload and execute the script build/install-build-deps.sh (for Ubuntu) attempts to automate installing the
above software :
wget –r –l1 http://src.chromium.org/svn/trunk/src/build/install-build-deps.sh
On Lucid, it also need these fonts for layout tests :
sudo apt-get install ttf-indic-fonts
To build the Chromium OS version of Chromium with their build system, add “GYP_DEFINES” variable to
your environment :
export GYP_DEFINES="chromeos=1"
Get the Code
1. Download the source tarball :
http://chromium-browser-source.commondatastorage.googleapis.com/chromium_tarball.html
2. Untar the source tarball into the directory you've chosen.
For example : ~/chromium
3. Install the depot_tools :
3.1) Retrieve depot_tools; select one of these ways :
svn co http://src.chromium.org/svn/trunk/tools/depot_tools
3.2) Add depot_tools to your PATH :
For example, for the default bash shell, use:
export PATH=`pwd`/depot_tools:"$PATH"
4. Updating your checkout once by running
gclient sync --force
in the source code directory (~/chromium/src).
Install Prerequisite Liraries
Change to the “build” directory in Chromium browser source directory,
# cd chromium-browser/src/build
Execute “install-build-deps.sh” script.
Add debugging Messages
export GYP_DEFINES="chromeos=1 target_arch=ia32"
gclient runhooks --force
14. Build Chromium OS
cros_workon is a workflow tool for ChromiumOS development. It is currently in beta.
With cros_workon, developers subscribe to the packages they want to work on. The tools then only
checkout the packages a developer is subscribed to and only builds the packages a developer is
subscribed to.
When using cros_workon, gclient is no longer used, and two new commands are used instead:
repo
Usually run outside the chroot.
It's used to check out and sync your repositories and manage the tracking branches for git.
This is used instead of gclient.
If run inside the chroot, make sure you have "git config -l" configured with your correct email
address -- if not, you could lose local commits on repo sync.
src/scripts/cros_workon (will soon move be able to run cros_workon from anywhere in the
chroot)
Always run inside the chroot.
It's used to unmask a package ebuild so that
1) repo will be prepared to sync a local copy of the source, and
2) build_packages will use the local source instead of the stable version.
i> Initial Setup
Install “repo” through steps in : http://source.android.com/source/git-repo.html
For read-only access to the code :
export GITHOST:=http://src.chromium.org/git
ii> Get the Code
Execute commands :
$ mkdir mychromiumos
$ cd mychromiumos
$ repo init -u http://git.chromium.org/git/manifest -m minilayout.xml
#internal users use: repo init -u ssh://gitrw.chromium.org:9222/manifest-internal -m minilayout.xml
$ repo sync
“repo sync” done :
15. iii> Create a chroot
To simplify dependencies, development is done inside a chroot. The following command creates the chroot
for you.
$ cd src/scripts
$ ./make_chroot
or, faster :
$ cd src/scripts
$ ./make_chroot --fast
16.
17. iv> Enter the chroot
To enter the chroot in order to do development, run the following command :
$ ./enter_chroot.sh
18. , or if you want to build your Chromium browser by the way, run the command as :
$ ./enter_chroot.sh --chrome_root=$(PATH/TO/CHROMIUM-BROWSER/SRC)
v> Set up board
You need to run setup_board in order to install the toolchain (gcc/glibc) for the target you wish to work on.
setup_board also creates the initial SYSROOT the target.
(chroot) $ ./setup_board --board=x86-generic –default --job 4
19.
20. vi> Enable a local user(guest) account (optioal)
The local user account allows login with no password even if you can not connect to the Internet. If you are
customizing Chromium OS and having trouble logging in due to your customizations, it may be handy to be
able to bypass authentication and log yourself in as a test user. This is disabled by default for security reasons,
but if you want to enable it for a backdoor user USERNAME:
./enable_localaccount.sh USERNAME
Here, we use "guest" acctount :
./enable_localaccount.sh guest
21. viii> Set the shared user password (optioal)
The shared system level account ("chronos") password defaults to a long random string. If you want to be able
to sudo from the terminal in Chromium OS (this also includes actually installing the OS on your device), need
help debugging networking, or you have some other reason for needing to log on directly as the shared user,
you need to set up the password for the shared user:
./set_shared_user_password.sh
This will prompt you for a password. The encrypted password will be stored in ./shared_user_password.txt, so
you only need to do this once.
ix> Build packages
The ChromiumOS equivalent of "make".
(chroot) $ ./build_packages --board="x86-generic" --jobs=4
The number “8” means the number of cores of your CPU, you could change it to be available number.
By default, build_packages will build the stable version of a package (i.e. from committed git sources) unless
you are working on a package. If you are working on a package, build_packages will build using your local
sources.
22. In this phase, it spend around 9~10 hours…please be patient!!!
x> Build image
The ChromiumOS equivalent of "make install".
(chroot) $ ./build_image
If you want to use the developer server (./start_devserver in the chroot) and gmerge on the device to build and
merge changes that you make then you will need to disable the root filesystem signature checking. Give the
flag (which will auto complete) to build_image.
23. (chroot) $ ./build_image --noenable_rootfs_verification
The generated images are :
1> chromiumos_base_image.bin for Chromium OS.
2> chromiumos_image.bin for developer.
Start to build image :
Image built done :
24.
25.
26. Use Chromium OS Image through USB / VM
[VMware]
./image_to_vm.sh --from=../build/images/x86/Version.BuiltDate&Time –board=x86-generic
[USB]
./image_to_usb.sh --from=../build/images/x86/Version.BuiltDate&Time --to=/dev/USB-Node .
“USB-Node” should be like “/dev/sdc” other than “/dev/sdc1”
Start working on a package
In order to modify and build a local version of a package, you must first mark it active :
(chroot) $ ./cros_workon start <pkgname> # Use the name of the Portage package, e.g chromeos-wm
This marks the ebuild for the given package so that build_packages will use your local changes instead of the
stable, committed version.
If you don't know the package name, you can see all the available packages like this :
(chroot) $ ./cros_workon list --all
Special case : chromiumos-overlay is not in this list and cros_workon start/stop is not used. Follow the
instructions below under "Making and committing your changes".
27. Note :
cros_workon requires either a "--host" or "--board PLATFORM" option, to indicate the target that will be
affected by your local changes. Chances are that this argument is being silently provided by the contents of
src/scripts/.default_board.
If you need to work on package changes that should be built for multiple boards, you'll need to specify each
board with separate "start" commands. For that to work, you'll need to delete the .default_board file.
Stop working on a package
This tells the buildsystem to use stable pre-built version of the package. build_packages will now ignore your
local repository. Stopping doesn't delete your local copy, so don't be fooled into thinking it's still being used.
(chroot) $ ./cros_workon stop <pkgname>
Autotest
<Temporary Notice> Until the autotest is entirely converted, tested, and the new workflow is made default,
there are no stable ebuilds for anything autotest-related, in order to not mess with the original workflow. Until
that moment, the first thing that has to be done is to "workon" all autotest-related ebuilds. This also means that
there will be no prebuilt packages yet.
$ cros_workon start autotest autotest-tests
$ repo sync
[Running a test]
The operation of autotest is significantly different in cros-workon. Tests are organized in ebuilds, where each
ebuild implements certain number of tests. Tests consist of a build phase and run phase, where the first is
executed by the ebuild, and the second by the "run_remote_tests.sh" script, with exactly the same syntax as
before. Unlike before, tests have to be built with emerge-${board} before they can be ran using
run_remote_tests.sh.
Currently, tests are organized within these ebuilds :
chromeos-base/autotest-tests
To see which tests are implemented by an ebuild, run the usual pretended emerge:
$ emerge-${board} -pv autotest-tests
All tests have a default state, either enabled (+) or disabled (-). The TESTS= variable is a USE_EXPAND.
There are two ways to use these.
(1) Non-Incremental --- Simply override the list by a new list
TESTS="platform_MiniJailPidNamespace platform_MiniJailPtraceDisabled" emerge-${board} -pv
autotest-tests
(2) Incremental --- All USE_EXPAND flags are also accessible as USE flags, with the appropriate prefix,
and can be used incrementally with +, -
USE="tests_platform_MiniJailPidNamespace tests_platform_MiniJailPtraceDisabled" emerge-${board}
-pv autotest-tests
28. For operations across all tests, following incremental USE wildcard is supported by portage : "tests_*"
Both Incremental and Non-Incremental methods can be set/overriden by : the ebuild (default values),
make.conf, make.profile, /etc/portage, commandline.
29. Chrome Web Apps
Concepts
Apps
Contains installable web apps.
An installable web app can be a normal website with a bit of extra metadata; this type of app is called a
hosted app.
Alternatively, an installable web app can bundle all its content into an archive that users download when they
install the app; this is a packaged app.
Both hosted and packaged apps have icons in Google Chrome's New Tab page, and most users shouldn't be
able to tell the difference between them without looking at the address bar.
Before publishing a hosted app in the store, you must verify that you own the website that hosts the app's
content. Packaged apps might have some association with a website, but you have the option of designing
them so that they don't rely on the web at all.
Themes
Contains themes for Google Chrome, which change the way the browser looks.
Extensions
Contains Google Chrome Extensions, which change how the browser behaves and, in a limited way, how it
looks. Until the store is public, you can find extensions in the Extensions Gallery.
If your extension seems more like a website than a small browser add-on, consider making it a packaged app.
Packaged apps are implemented as extensions that have the additional ability to present an app-like interface.
[Terminology note : When this documentation talks about an app without giving any other details, it means
any of the above—an installable web app (either hosted or packaged), a theme, or an extension.]
Every app has a manifest, and most likely icons, that you put into a ZIP file and upload to the Chrome
Developer Dashboard. The Chrome Web Store takes the contents of this ZIP file and puts them in a
cryptographically signed .crx file. Users download this .crx file when they click the Install button for your
app.
To create installable web apps and extensions, you should be familiar with HTML, JavaScript, and CSS. If
you're targeting Google Chrome exclusively, you can depend on HTML5 and the other emerging APIs that
Google Chrome supports.
Installable Web Apps
An installable web app requires a .crx file that contains metadata describing the app. (The .crx file format is
just a variation of ZIP that's used by Google Chrome.) An app's .crx file can be hosted on your own server or,
more typically, by the Chrome Web Store.
The .crx file for an installable web app must contain a set of icons and a manifest that has details about how
30. the app should function. For a packaged app, the .crx file also contains any HTML, CSS, JavaScript, and
other files that the app needs.
Note : Unlike a packaged app, a hosted app has no access to the files inside its .crx file.
Host Apps
You just provide some icons and a manifest.
Packaged Apps
A packaged app is a web app that's bundled into a .crx file and can use Google Chrome Extension features.
You might want to use a packaged app if any of the following are true:
You don't want to run a service to host your app.
You want to build an app that works really well offline.
You want tighter integration with Google Chrome, using the extension APIs.
You build a packaged app just like you build an extension. All the resources that the app requires—HTML,
JavaScript, CSS, images, and any other files—go into the app's .crx file. The manifest is similar to a hosted
app's manifest, but it can include only local URLs, and you can add any field (such as "background_page")
that's available to extensions.
31. New Features
Remote Desktop Capabilities - Chromoting
One of the larger questions asked by novices to the Chrome OS experience is this: Can it run Windows apps?
Up until now, the answer has been a resolute, "no." Google’s Chrome operating system is entirely
Web-driven, in the sense that there’s nothing you can actually install into the operating system.
You access Web-driven applications via the browser and, though you can "install" or save these Web apps into
Chrome OS, you just can’t grab your average application CD, throw it in an optical drive, and expect
something magical to happen.
This feature would let users run "legacy PC applications" right in the browser, and that it would be
"something like" Microsoft's Remote Desktop Connection. This feature is probably closer to running an
application via Terminal Services or by first connecting to a host machine by using RDP or VNC.
For recent release of Chrome/Chromium(after 2010/06), uses can add “--enable-remoting” parameter after
Chromium/Chromium executable, “chrome --enable-remoting”,users can see there will show a option, “Set
Up Remoting…”, in Configuration.
Google wants everything run in browser!!!
GPU Accelerated Compositing – WebGL
WebGL is a cross-platform, royalty-free API used to create 3D graphics in a Web browser. Based on
OpenGL ES 2.0, WebGL uses the OpenGL shading language, GLSL, and offers the familiarity of the
standard OpenGLAPI. Because it runs in the HTML5 Canvas element, WebGL has full integration with all
Document Object Model (DOM) interfaces.
32. The canvas element is part of HTML5 and allows for dynamic, scriptable rendering of 2D shapes and
bitmap images. It is a low level, procedural model that updates a bit map and does not have a built in scene
graph.
Canvas consists of a drawable region defined in HTML code with height and width attributes. JavaScript
code may access the area through a full set of drawing functions similar to other common 2D APIs, thus
allowing for dynamically generated graphics.
Usage -
In HTML page :
In JavaScript code :
WebGL is a DOM API, which means that it can be used from any DOM-compatible language: JavaScript,
Java, or—if you embed WebKit into an application on a Mac—Objective C.
Major browser vendors Google (Chrome), Opera (Opera), Mozilla (Firefox), and Apple (Safari) are members
of the Khronos consortium's WebGL Working Group, along with many other 3D graphics developers.
WebGL Implementation
* Firefox
Supported in Firefox/4.0b1.
* Safari
Supported on Mac OS X 10.6 in the WebKit.
* Chrome/Chromium
Chromium must be launched from the command line in order to enable WebGL.
Linux : ./chrome --enable-webgl
Mac OS X : ./Chromium.app/Contents/MacOS/Chromium --enable-webgl
Windows : No command line options needed.
<canvas id="example" width="200" height="200">
This text is displayed if your browser does not support HTML5 Canvas.
</canvas>
var example = document.getElementById('example');
var context = example.getContext('2d');
context.fillStyle = "rgb(255,0,0)";
context.fillRect(30, 30, 50, 50);
33. Reference
Google Chromium OS Main Site – http://www.chromium.org/
Introduction
* Chromium OS wiki – http://en.wikipedia.org/wiki/Chromium_OS
FAQ
* The distinction between Google Chrome OS and Chromium OS –
http://blog.chromium.org/2009/12/whats-difference-between-chromium-os.html
* More detail answer – http://www.chromium.org/chromium-os/how-tos-and-troubleshooting/developer-faq
Usage
* Playing with Google Chromium OS –
http://garymlewis.com/instchg/2010/01/19/playing-with-google-chromium-os/
* Hexxen Linux instruction – http://chromeos.hexxeh.net/wiki/doku.php?id=linux_instructions
* More detail answer – http://www.chromium.org/chromium-os/how-tos-and-troubleshooting/developer-faq
* Chrome Apps – http://www.downloadsquad.com/2010/07/06/more-google-chrome-web-apps/
SW Architecture
* Chromium OS Design Document –
http://sites.google.com/a/chromium.org/dev/chromium-os/chromiumos-design-docs
Build Process
* HowTo & Troubleshooting – http://dev.chromium.org/chromium-os/how-tos-and-troubleshooting
* Build Chromium OS – http://sites.google.com/a/chromium.org/dev/chromium-os/building-chromium-os
* Linux Build Instructions Prerequisites –
http://code.google.com/p/chromium/wiki/LinuxBuildInstructionsPrerequisites
* Portage Build System –
http://en.wikipedia.org/wiki/Gentoo_Linux
http://en.wikipedia.org/wiki/Portage_(software)
* Portage Based Build – http://dev.chromium.org/chromium-os/building-chromium-os/portage-based-build
* Chromium changed to use Portage build system –
http://groups.google.com/a/chromium.org/group/chromium-os-dev/browse_frm/thread/337cca9a0da59ad6/
b91ccac986266a94?tvc=1#b91ccac986266a94
* FreeBSD Ports – http://www.freebsd.org/ports/
* Download Chrome – http://penkia.blogspot.com/2010/02/notes-on-chromium-os-for-arm.html
34. * Explanation in Traditional Chinese – http://wadefs.blogspot.com/2010/04/chromium-under-ubuntu-1.html
Debugging
* Debugging Tips – http://dev.chromium.org/chromium-os/how-tos-and-troubleshooting/debugging-tips
* Linux Debugging Tips – http://code.google.com/p/chromium/wiki/LinuxDebugging
New Features
Chromoting >
* Chromoting –
http://loda.hala01.com/2010/06/chrome-os-to-support-legacy-pc-apps-via-chromoting/
* How does Chromoting work? –
http://blog.kowalczyk.info/article/How-does-chromoting-works.html
*Chromoting Codes –
http://src.chromium.org/svn/trunk/src/remoting/
WebGL Support >
* WebGL Main Site –
http://www.khronos.org/webgl/
http://www.khronos.org/webgl/wiki/Main_Page
* WebGL Implementations –
http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation
* WebGL in Chrome –
http://www.khronos.org/developers/library/2010_siggraph_bof_webgl/WebGL-BOF-2-WebGL-in-Chrome_
SIGGRAPH-Jul29.pdf
* WebGL Testing Site –
http://www.chromium.org/developers/demos-gpu-acceleration-and-webgl
* WebGL (introduced in Chinese) –
http://heresy.spaces.live.com/blog/cns!E0070FB8ECF9015F!10277.entry?sa=769074931
* Canvas Tutorial –
https://developer.mozilla.org/en/Canvas_tutorial
* Canvas Usage –
http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html
Chrome Web App
1. http://code.google.com/intl/zh-TW/chrome/webstore/docs/index.html
2. http://code.google.com/intl/zh-TW/chrome/webstore/articles/apps_vs_extensions.html
3. http://code.google.com/intl/zh-TW/chrome/apps/docs/developers_guide.html
4. http://code.google.com/chrome/extensions/
http://code.google.com/chrome/extensions/overview.html
http://code.google.com/chrome/extensions/getstarted.html