This document provides an overview of JavaScript topics covered in Tutorial 5, including:
- JavaScript vs JScript
- Built-in data types and objects like String, Math, Number, Boolean, and Date
- Control structures like if/else statements and for/while loops
- Operators, global functions, events, and DOM hierarchy
- Communicating between JavaScript and Java applets
- Recommended sites for further JavaScript and dynamic HTML information
This document provides a cheat sheet for the DocParsers API in ModX Evolution version 1.0.2. It lists various objects, variables, functions, and events available through the API for interacting with documents, snippets, templates, and other system components. High-level areas covered include document parsing and manipulation, database interaction, template service events, and system events.
This document summarizes the Demoiselle Spatial framework. It includes archetypes, documentation, examples, and features. The key features are components for geocoding, KML, shapefiles, OGC web services, and GeoREST. It also includes the Hibernate Spatial JPA extension. The scope of the initiative currently includes archetypes, documentation, the Hibernate Spatial extension, and common features. It provides information on how to contribute to the project.
The document discusses reactive programming and frameworks. It introduces reactive programming as a way to think about asynchronous and event-based programming that is fundamental to cloud, web and mobile applications. It shows how asynchronous and event-based computations can be viewed as push-based collections by dualizing enumerable collections to observable collections. This allows applying LINQ-style queries to asynchronous programming. Examples are provided for moving a ball with keyboard input and dragging the mouse to draw, implemented imperatively and declaratively with observables.
Slides from my talk at the Junction (Jan 24, 2013)
Single-core performance has hit a ceiling, and building web-scale multi-core applications using imperative programming models is nightmarishly difficult. Parallel programming creates a new set of challenges, best practices and design patterns. Scala is designed to enable building scalable systems, elegantly blending functional and object oriented paradigms into an expressive and concise language, while retaining interoperability with Java. Scala is the fastest growing JVM programming language, being rapidly adopted by leading companies such as Twitter, LinkedIn and FourSquare.
This presentation provides a comprehensive overview of the language, which managed to increase type safety while feeling more dynamic, being more concise and improving readability at the same time. We will see how Scala simplifies real life problems by empowering the developer with powerful functional programming primitives, without giving up on the object oriented paradigm. The overview includes tools for multi-core programming in Scala, the type system, collection framework and domain-specific languages. We’ll explore the power of compile-time meta-programming, which is made possible by the newly released Scala 2.10, and get a glimpse into what to expect from 2.11 in 2014.
We will also see how Scala helps overcome the inherent limitations of Java, such as type erasure, array covariance and boxing overhead.
Multiple examples emphasize how Scala pushes the JVM harder than any other mainstream language through the infinite number of boilerplate busters, increased type safety and productivity boosters from a Java developer’s perspective.
This document summarizes Jeffrey Zhao's background and areas of expertise. It includes:
1. Jeffrey Zhao is a software engineer from China who blogs at http://blog.zhaojie.me/. His areas of expertise include JavaScript, F#, Scala, C#, Python, .NET and Mono.
2. The document provides code examples in different programming languages for common algorithms and data structures like sorting and grouping, demonstrating Jeffrey's proficiency in languages like C#, F#, Ruby, Java, and JavaScript.
3. It introduces Jscex, a JavaScript library created by Jeffrey that allows writing asynchronous code in a synchronous style using JavaScript computation expressions. Jscex compiles asynchronous code into
This document discusses Jscex, which allows writing asynchronous JavaScript code in a synchronous style using the $await operator. It provides examples of rewriting bubble sort to use asynchronous compare and swap functions. It also discusses using Jscex to handle parallelism, I/O, and concurrency in applications. Key benefits mentioned include just-in-time compilation for performance and ahead-of-time compilation for smaller file sizes.
Hadoop est devenu une référence dans l’univers du BigData, et MapReduce, un nouveau paradigme pour exploiter les données. Implémenter directement les traitements de données avec MapReduce donne certainement le plus de flexibilité, mais cela revient à utiliser de l’assembleur. Cascalog est sans doute l’alternative la plus concise. Basée sur Clojure, cette solution vous laisse dans un environnement familier (la JVM) tout en vous apportant une abstraction fort utile par le biais de la programmation logique.
This document provides a cheat sheet for the DocParsers API in ModX Evolution version 1.0.2. It lists various objects, variables, functions, and events available through the API for interacting with documents, snippets, templates, and other system components. High-level areas covered include document parsing and manipulation, database interaction, template service events, and system events.
This document summarizes the Demoiselle Spatial framework. It includes archetypes, documentation, examples, and features. The key features are components for geocoding, KML, shapefiles, OGC web services, and GeoREST. It also includes the Hibernate Spatial JPA extension. The scope of the initiative currently includes archetypes, documentation, the Hibernate Spatial extension, and common features. It provides information on how to contribute to the project.
The document discusses reactive programming and frameworks. It introduces reactive programming as a way to think about asynchronous and event-based programming that is fundamental to cloud, web and mobile applications. It shows how asynchronous and event-based computations can be viewed as push-based collections by dualizing enumerable collections to observable collections. This allows applying LINQ-style queries to asynchronous programming. Examples are provided for moving a ball with keyboard input and dragging the mouse to draw, implemented imperatively and declaratively with observables.
Slides from my talk at the Junction (Jan 24, 2013)
Single-core performance has hit a ceiling, and building web-scale multi-core applications using imperative programming models is nightmarishly difficult. Parallel programming creates a new set of challenges, best practices and design patterns. Scala is designed to enable building scalable systems, elegantly blending functional and object oriented paradigms into an expressive and concise language, while retaining interoperability with Java. Scala is the fastest growing JVM programming language, being rapidly adopted by leading companies such as Twitter, LinkedIn and FourSquare.
This presentation provides a comprehensive overview of the language, which managed to increase type safety while feeling more dynamic, being more concise and improving readability at the same time. We will see how Scala simplifies real life problems by empowering the developer with powerful functional programming primitives, without giving up on the object oriented paradigm. The overview includes tools for multi-core programming in Scala, the type system, collection framework and domain-specific languages. We’ll explore the power of compile-time meta-programming, which is made possible by the newly released Scala 2.10, and get a glimpse into what to expect from 2.11 in 2014.
We will also see how Scala helps overcome the inherent limitations of Java, such as type erasure, array covariance and boxing overhead.
Multiple examples emphasize how Scala pushes the JVM harder than any other mainstream language through the infinite number of boilerplate busters, increased type safety and productivity boosters from a Java developer’s perspective.
This document summarizes Jeffrey Zhao's background and areas of expertise. It includes:
1. Jeffrey Zhao is a software engineer from China who blogs at http://blog.zhaojie.me/. His areas of expertise include JavaScript, F#, Scala, C#, Python, .NET and Mono.
2. The document provides code examples in different programming languages for common algorithms and data structures like sorting and grouping, demonstrating Jeffrey's proficiency in languages like C#, F#, Ruby, Java, and JavaScript.
3. It introduces Jscex, a JavaScript library created by Jeffrey that allows writing asynchronous code in a synchronous style using JavaScript computation expressions. Jscex compiles asynchronous code into
This document discusses Jscex, which allows writing asynchronous JavaScript code in a synchronous style using the $await operator. It provides examples of rewriting bubble sort to use asynchronous compare and swap functions. It also discusses using Jscex to handle parallelism, I/O, and concurrency in applications. Key benefits mentioned include just-in-time compilation for performance and ahead-of-time compilation for smaller file sizes.
Hadoop est devenu une référence dans l’univers du BigData, et MapReduce, un nouveau paradigme pour exploiter les données. Implémenter directement les traitements de données avec MapReduce donne certainement le plus de flexibilité, mais cela revient à utiliser de l’assembleur. Cascalog est sans doute l’alternative la plus concise. Basée sur Clojure, cette solution vous laisse dans un environnement familier (la JVM) tout en vous apportant une abstraction fort utile par le biais de la programmation logique.
This document discusses JavaScript Computation Expressions (Jscex), which allows writing asynchronous JavaScript code in a synchronous-looking style using computation expressions. Key points:
- Jscex uses computation expressions to write asynchronous JavaScript code that looks synchronous using constructs like $await.
- Asynchronous functions can be defined and composed together asynchronously and parallel using $await without callbacks or promises.
- This allows asynchronous code to be written in a way that resembles synchronous code for readability while still maintaining asynchrony under the hood.
The document discusses functional programming concepts in Clojure including immutable data structures like lists, vectors, and maps. It compares the functional style of Clojure to the object-oriented style of Java, showing how Clojure allows data to flow through transformations without side effects. Key points covered include Clojure's homoiconic nature, pure functions, and use of transformations and composition over iterative steps.
The document introduces Jscex, a JavaScript library that provides computation expressions to help with common programming scenarios in JavaScript. It allows writing asynchronous code in a synchronous-looking way. Key points:
- Jscex is a library, not a language, framework or runtime. It works with any JavaScript engine.
- It keeps the JavaScript language semantics and allows programming asynchronously without breaking code locality.
- Examples show how it can be used to animate bubble sort and handle asynchronous operations like HTTP requests in an easier way compared to promises or callbacks.
DevFest Istanbul - a free guided tour of Neo4JFlorent Biville
2013-11-02 : DevFest Türkiye, Istanbul.
Slightly modified version of my previous Neo4J introduction talk about Neo4J in Soft-Shake Event, Geneva, Switzerland.
This document summarizes a talk given about Nokia's migration to Scala for its Places API. The key points are:
1) Nokia migrated its Places API codebase to Scala to take advantage of Scala's features like its powerful type system, immutable data structures, and functional programming capabilities.
2) The migration was done gradually over time while continuing to develop new features. They discovered many benefits of Scala along the way like improved test readability and JSON parsing capabilities.
3) Nokia uses Scala features like case classes, options, and functions to model data and add type safety to its codebase. This uncovered bugs that would have been hard to find in Java.
This document provides an overview of coding in style with Scala. It discusses embracing expressions over statements, operator notation, using language features to simplify code, favoring higher-order functions, manipulating data with collections, working with asynchronous code and futures, macro programming to transform ASTs, and new features coming in Scala 2.11 like potential modularization and performance improvements. The document encourages idiomatic Scala techniques like favoring expressions, embracing operators, letting the language do work, aiming higher with higher-order functions, and embracing new language features.
Clojure and Swing – a new productivity sweet spot? discusses how Clojure, a Lisp dialect that runs on the JVM, can be used to develop graphical user interfaces (GUIs) using Java Swing in a more productive way than plain Java. It presents several advantages of Clojure for Swing development, such as reducing boilerplate code, easier definition of actions and event bindings, and increased flexibility and reusability through functional programming techniques. Examples are provided of common Swing programming tasks implemented more concisely and readably in Clojure compared to Java. The document concludes that Clojure is a powerful and flexible language that offers opportunities to apply Lisp concepts to Swing GUI development
The document provides tips on Java concurrency. It discusses using synchronized, volatile and java.util.concurrent classes like AtomicInteger for thread-safe operations on shared resources like account balances. Synchronized uses locks for mutual exclusion but volatile only ensures visibility, so atomic classes use Compare-And-Swap (CAS) operations for thread-safe updates without blocking.
This document discusses two approaches for connecting Node.js applications to MySQL databases: 1) Using a JavaScript MySQL client library like mysql (node-mysql) and 2) Using a common relational database framework for Node.js connections called node-db (db-mysql). It provides instructions for installing db-mysql and an example of connecting to a database and running queries.
Soft Shake Event / A soft introduction to Neo4JFlorent Biville
The document discusses graph databases and the Neo4j graph database. It begins with an introduction to graphs and property graphs. It then covers topics like the Neo4j data model, core API, querying with Cypher, object graph mapping with Spring Data, and example use cases for graph databases like recommendations, fraud detection, and network analysis.
Dart is an open-source programming language developed by Google to build structured web applications. It aims to replace JavaScript for web development. Dart is class-based, object-oriented language with optional static typing. It has advantages over JavaScript like native support for concurrency using isolates, strong typing of variables, and required main entry point. While the syntax is similar, Dart introduces features like libraries, constructors, inheritance, operator overloading, and exceptions handling that are not available natively in JavaScript.
The document discusses different approaches tried to switch device certificates programmatically on iOS, including using NSURLConnection, GTMHTTPFetcher, and ASIHTTPRequest. It also describes some hacks that worked like using the IP address instead of the hostname and adding a period to the hostname. The document appears to be technical notes on trying to authenticate and switch certificates during an HTTPS connection on iOS.
This document summarizes a MongoDB live coding session presented by Tobias Trelle. It introduces MongoDB concepts like documents, collections, CRUD operations, queries including geospatial queries, replication, sharding, and the Java and Spring Data APIs. It also advertises MongoDB user groups in Dusseldorf and Frankfurt organized by codecentric AG.
This document provides a summary of Taro Matsuzawa's career and activities from 1981 to 2011. It notes that he was involved with various computer-related clubs and organizations in Japan, including English language societies and Linux communities. It also discusses his work on open source projects like Mozilla and Pantomime, an open source email library for iOS.
This document provides an introduction to the Scala programming language for Java programmers. It discusses Scala's motivation as a scalable and more productive alternative to Java. Key features covered include static typing, object-oriented and functional programming, traits, pattern matching, and actors. Examples are provided to illustrate concepts like functions as first-class values, partially applied functions, and collection operations. The document concludes by mentioning additional Scala concepts and providing references for further reading.
The document provides an introduction to Groovy, including:
- The presenter's background in programming languages including Java since 1996 and using Groovy since 2009.
- The presentation objectives are to recognize Groovy code, get interested in Groovy coding, and introduce some key Groovy concepts without focusing on Grails, Geb, or Spock yet.
- Groovy is a dynamic language that extends Java with features like closures, GStrings, and optional semicolons to enable less code and more clarity while compiling to Java classes for seamless integration.
This document provides an overview of Scala and compares it to Java in 3 sentences:
Scala is a multi-paradigm programming language that runs on the Java Virtual Machine and interoperates seamlessly with Java, combining object-oriented and functional programming in one concise, high-level language. Scala improves on Java with features like closures, pattern matching, traits, and immutable data while maintaining a familiar syntax; it compiles to Java bytecode and allows Java and Scala code to interoperate. Scala aims to be a better language for writing concurrent, parallel and distributed applications than Java with its support for actors, futures and software transactional memory.
This document provides an overview of new features in Java 8, including lambda expressions, default methods on interfaces, bulk data operations on collections, and other library enhancements. It discusses how lambda expressions allow for closures in Java and interface evolution with default methods. It also provides code examples of using lambda expressions for event handling and animation in a JavaFX application that makes circles vanish when clicked.
V8 is the JavaScript engine used in Google Chrome and Node.js. It aims to make large JavaScript programs run faster through techniques like JIT compiling, hidden classes, inline caching, and precise garbage collection. Hidden classes optimize property access by generating custom classes for objects with similar properties, similar to static typing. Inline caching caches property lookups to avoid hidden class traversal. Precise garbage collection handles memory management. Overall, V8 uses modern techniques to address problems like JavaScript's dynamic nature and improve performance of JavaScript programs.
Scala can be used for both object-oriented programming and functional programming. It supports features like functions as first-class objects, closures, patterns, and immutable data structures. Scala can be used to build domain specific languages through its support for features like functions, pattern matching, and implicit conversions. Some examples of Scala DSLs include SimpleModeler for modeling and g3/g4 for Android development. Scala also supports concepts from functional programming like functors, monads, and other type classes to build abstractions.
Spark schema for free with David SzakallasDatabricks
DataFrames are essential for high-performance code, but sadly lag behind in development experience in Scala. When we started migrating our existing Spark application from RDDs to DataFrames at Whitepages, we had to scratch our heads real hard to come up with a good solution. DataFrames come at a loss of compile-time type safety and there is limited support for encoding JVM types.
We wanted more descriptive types without the overhead of Dataset operations. The data binding API should be extendable. Schema for input files should be generated from classes when we don’t want inference. UDFs should be more type-safe. Spark does not provide these natively, but with the help of shapeless and type-level programming we found a solution to nearly all of our wishes. We migrated the RDD code without any of the following: changing our domain entities, writing schema description or breaking binary compatibility with our existing formats. Instead we derived schema, data binding and UDFs, and tried to sacrifice the least amount of type safety while still enjoying the performance of DataFrames.
This document discusses JavaScript Computation Expressions (Jscex), which allows writing asynchronous JavaScript code in a synchronous-looking style using computation expressions. Key points:
- Jscex uses computation expressions to write asynchronous JavaScript code that looks synchronous using constructs like $await.
- Asynchronous functions can be defined and composed together asynchronously and parallel using $await without callbacks or promises.
- This allows asynchronous code to be written in a way that resembles synchronous code for readability while still maintaining asynchrony under the hood.
The document discusses functional programming concepts in Clojure including immutable data structures like lists, vectors, and maps. It compares the functional style of Clojure to the object-oriented style of Java, showing how Clojure allows data to flow through transformations without side effects. Key points covered include Clojure's homoiconic nature, pure functions, and use of transformations and composition over iterative steps.
The document introduces Jscex, a JavaScript library that provides computation expressions to help with common programming scenarios in JavaScript. It allows writing asynchronous code in a synchronous-looking way. Key points:
- Jscex is a library, not a language, framework or runtime. It works with any JavaScript engine.
- It keeps the JavaScript language semantics and allows programming asynchronously without breaking code locality.
- Examples show how it can be used to animate bubble sort and handle asynchronous operations like HTTP requests in an easier way compared to promises or callbacks.
DevFest Istanbul - a free guided tour of Neo4JFlorent Biville
2013-11-02 : DevFest Türkiye, Istanbul.
Slightly modified version of my previous Neo4J introduction talk about Neo4J in Soft-Shake Event, Geneva, Switzerland.
This document summarizes a talk given about Nokia's migration to Scala for its Places API. The key points are:
1) Nokia migrated its Places API codebase to Scala to take advantage of Scala's features like its powerful type system, immutable data structures, and functional programming capabilities.
2) The migration was done gradually over time while continuing to develop new features. They discovered many benefits of Scala along the way like improved test readability and JSON parsing capabilities.
3) Nokia uses Scala features like case classes, options, and functions to model data and add type safety to its codebase. This uncovered bugs that would have been hard to find in Java.
This document provides an overview of coding in style with Scala. It discusses embracing expressions over statements, operator notation, using language features to simplify code, favoring higher-order functions, manipulating data with collections, working with asynchronous code and futures, macro programming to transform ASTs, and new features coming in Scala 2.11 like potential modularization and performance improvements. The document encourages idiomatic Scala techniques like favoring expressions, embracing operators, letting the language do work, aiming higher with higher-order functions, and embracing new language features.
Clojure and Swing – a new productivity sweet spot? discusses how Clojure, a Lisp dialect that runs on the JVM, can be used to develop graphical user interfaces (GUIs) using Java Swing in a more productive way than plain Java. It presents several advantages of Clojure for Swing development, such as reducing boilerplate code, easier definition of actions and event bindings, and increased flexibility and reusability through functional programming techniques. Examples are provided of common Swing programming tasks implemented more concisely and readably in Clojure compared to Java. The document concludes that Clojure is a powerful and flexible language that offers opportunities to apply Lisp concepts to Swing GUI development
The document provides tips on Java concurrency. It discusses using synchronized, volatile and java.util.concurrent classes like AtomicInteger for thread-safe operations on shared resources like account balances. Synchronized uses locks for mutual exclusion but volatile only ensures visibility, so atomic classes use Compare-And-Swap (CAS) operations for thread-safe updates without blocking.
This document discusses two approaches for connecting Node.js applications to MySQL databases: 1) Using a JavaScript MySQL client library like mysql (node-mysql) and 2) Using a common relational database framework for Node.js connections called node-db (db-mysql). It provides instructions for installing db-mysql and an example of connecting to a database and running queries.
Soft Shake Event / A soft introduction to Neo4JFlorent Biville
The document discusses graph databases and the Neo4j graph database. It begins with an introduction to graphs and property graphs. It then covers topics like the Neo4j data model, core API, querying with Cypher, object graph mapping with Spring Data, and example use cases for graph databases like recommendations, fraud detection, and network analysis.
Dart is an open-source programming language developed by Google to build structured web applications. It aims to replace JavaScript for web development. Dart is class-based, object-oriented language with optional static typing. It has advantages over JavaScript like native support for concurrency using isolates, strong typing of variables, and required main entry point. While the syntax is similar, Dart introduces features like libraries, constructors, inheritance, operator overloading, and exceptions handling that are not available natively in JavaScript.
The document discusses different approaches tried to switch device certificates programmatically on iOS, including using NSURLConnection, GTMHTTPFetcher, and ASIHTTPRequest. It also describes some hacks that worked like using the IP address instead of the hostname and adding a period to the hostname. The document appears to be technical notes on trying to authenticate and switch certificates during an HTTPS connection on iOS.
This document summarizes a MongoDB live coding session presented by Tobias Trelle. It introduces MongoDB concepts like documents, collections, CRUD operations, queries including geospatial queries, replication, sharding, and the Java and Spring Data APIs. It also advertises MongoDB user groups in Dusseldorf and Frankfurt organized by codecentric AG.
This document provides a summary of Taro Matsuzawa's career and activities from 1981 to 2011. It notes that he was involved with various computer-related clubs and organizations in Japan, including English language societies and Linux communities. It also discusses his work on open source projects like Mozilla and Pantomime, an open source email library for iOS.
This document provides an introduction to the Scala programming language for Java programmers. It discusses Scala's motivation as a scalable and more productive alternative to Java. Key features covered include static typing, object-oriented and functional programming, traits, pattern matching, and actors. Examples are provided to illustrate concepts like functions as first-class values, partially applied functions, and collection operations. The document concludes by mentioning additional Scala concepts and providing references for further reading.
The document provides an introduction to Groovy, including:
- The presenter's background in programming languages including Java since 1996 and using Groovy since 2009.
- The presentation objectives are to recognize Groovy code, get interested in Groovy coding, and introduce some key Groovy concepts without focusing on Grails, Geb, or Spock yet.
- Groovy is a dynamic language that extends Java with features like closures, GStrings, and optional semicolons to enable less code and more clarity while compiling to Java classes for seamless integration.
This document provides an overview of Scala and compares it to Java in 3 sentences:
Scala is a multi-paradigm programming language that runs on the Java Virtual Machine and interoperates seamlessly with Java, combining object-oriented and functional programming in one concise, high-level language. Scala improves on Java with features like closures, pattern matching, traits, and immutable data while maintaining a familiar syntax; it compiles to Java bytecode and allows Java and Scala code to interoperate. Scala aims to be a better language for writing concurrent, parallel and distributed applications than Java with its support for actors, futures and software transactional memory.
This document provides an overview of new features in Java 8, including lambda expressions, default methods on interfaces, bulk data operations on collections, and other library enhancements. It discusses how lambda expressions allow for closures in Java and interface evolution with default methods. It also provides code examples of using lambda expressions for event handling and animation in a JavaFX application that makes circles vanish when clicked.
V8 is the JavaScript engine used in Google Chrome and Node.js. It aims to make large JavaScript programs run faster through techniques like JIT compiling, hidden classes, inline caching, and precise garbage collection. Hidden classes optimize property access by generating custom classes for objects with similar properties, similar to static typing. Inline caching caches property lookups to avoid hidden class traversal. Precise garbage collection handles memory management. Overall, V8 uses modern techniques to address problems like JavaScript's dynamic nature and improve performance of JavaScript programs.
Scala can be used for both object-oriented programming and functional programming. It supports features like functions as first-class objects, closures, patterns, and immutable data structures. Scala can be used to build domain specific languages through its support for features like functions, pattern matching, and implicit conversions. Some examples of Scala DSLs include SimpleModeler for modeling and g3/g4 for Android development. Scala also supports concepts from functional programming like functors, monads, and other type classes to build abstractions.
Spark schema for free with David SzakallasDatabricks
DataFrames are essential for high-performance code, but sadly lag behind in development experience in Scala. When we started migrating our existing Spark application from RDDs to DataFrames at Whitepages, we had to scratch our heads real hard to come up with a good solution. DataFrames come at a loss of compile-time type safety and there is limited support for encoding JVM types.
We wanted more descriptive types without the overhead of Dataset operations. The data binding API should be extendable. Schema for input files should be generated from classes when we don’t want inference. UDFs should be more type-safe. Spark does not provide these natively, but with the help of shapeless and type-level programming we found a solution to nearly all of our wishes. We migrated the RDD code without any of the following: changing our domain entities, writing schema description or breaking binary compatibility with our existing formats. Instead we derived schema, data binding and UDFs, and tried to sacrifice the least amount of type safety while still enjoying the performance of DataFrames.
The document discusses using the Coq proof assistant to implement and verify algorithms in Ruby. It mentions encoding a Base64 algorithm in Coq and extracting it to OCaml, Haskell, Scheme and potentially Ruby. It provides examples of defining and proving properties of a factorial function in Coq and extracting implementations to other languages. It also discusses using Coq to model and verify other algorithms like sorting before generating Ruby implementations.
(Bill Bejeck, Confluent) Kafka Summit SF 2018
Apache Kafka added a powerful stream processing library in mid-2016, Kafka Streams, which runs on top of Apache Kafka. The community has embraced Kafka Streams with many early adopters, and the adoption rate continues to grow. Large to mid-size organizations have come to rely on Kafka Streams in their production environments. Kafka Streams has many advanced features to make applications more robust.
The point of this presentation is to show users of Kafka Streams some of the latest and greatest features, as well as some that may be advanced, that can make streams applications more resilient. The target audience for this talk are those users already comfortable writing Kafka Streams applications and want to go from writing their first proof-of-concept applications to writing robust applications that can withstand the rigor that running in a production environment demands.
The talk will be a technical deep dive covering topics like:
-Best practices on configuring a Kafka Streams application
-How to meet production SLAs by minimizing failover and recovery times: configuring standby tasks and the pros and cons of having standby replicas for local state
-How to improve resiliency and 24×7 operability: the use of different configurable error handlers, callbacks and how they can be used to see what’s going on inside the application
-How to achieve efficient scalability: a thorough review of the relationship between the number of instances, threads and state stores and how they relate to each other
While this is a technical deep dive, the talk will also present sample code so that attendees can view the concepts discussed in practice. Attendees of this talk will walk away with a deeper understanding of how Kafka Streams works, and how to make their Kafka Streams applications more robust and efficient. There will be a mix of discussion.
1. JavaScript is a scripting language used in web browsers. It was originally created to make web pages more interactive and dynamic.
2. The document discusses the history and evolution of JavaScript, including its origins from Scheme and Java, standardization by ECMA, and adoption by major browsers.
3. Key concepts covered include JavaScript objects, functions, and closures. Objects are fundamental data types in JavaScript along with primitives like strings and numbers. Functions are objects that can be assigned to variables or passed as arguments. Closures allow functions to access variables from outer scopes.
1. JavaScript is a scripting language that originated from LiveScript and was developed by Netscape in 1995 to make web pages more interactive. It was later standardized by Ecma International as ECMAScript.
2. Objects in JavaScript can be created using object literals or the Object constructor. All objects in JavaScript inherit properties and methods from the Object prototype.
3. Functions in JavaScript are objects that allow for abstraction and code reuse. Functions can be defined using function declarations or expressions. All functions have a prototype property that is used to implement prototype-based inheritance.
This document provides an introduction to Scala. It discusses:
- Who the author is and their background with Scala and Spark
- Why Scala is a scalable language that runs on the JVM and supports object oriented and functional programming
- How to install Scala and use the Scala interpreter
- Basic Scala syntax like defining values and variables, type inference, strings, tuples, objects, importing classes
- Common functions and operations like map, reduce, anonymous functions, pattern matching
- Code samples for RDD relations and SparkPi
- Tips for using Scala in practice including SBT and good IDEs like IntelliJ
This document discusses Common Lisp Object System (CLOS) and the Metaobject Protocol (MOP). It provides examples of using CLOS to define classes and generic functions. It also shows how MOP can be used for metaprogramming techniques like singleton classes, object-relational mapping, and specializing on object equality. The document suggests CLOS and MOP are useful for implementing domain-specific languages and techniques like interceptors, validation, and lazy initialization.
The document introduces SVGo, a Go library for generating SVG drawings programmatically. It demonstrates how to use SVGo to create basic shapes like rectangles and lines, add attributes, apply transformations, and script interactions. The goal of SVGo is to allow generating consistent SVG views from standardized data.
JavaScript objects must implement certain standard properties and methods. Objects have a prototype property that is either an object or null, and prototype chains must have finite length. The typeof operator returns a string indicating the type of a variable or value. JavaScript supports basic types like undefined, null, boolean, number, string, and object. Functions are objects that can be called, and have properties like length and arguments. Variables declared with var have function scope, while variables assigned without var have global scope. Arrays, objects, and functions can be declared using various syntaxes. JavaScript uses prototypal inheritance rather than classes.
The document discusses serializing EMF models with Xtext. It covers:
- The new Xtext serializer is better than the old one in terms of errors, performance and deprecation.
- Serialization is used for quickfixes, refactoring, persistence, generators and more. It guarantees syntactical correctness and handles comments/whitespace.
- The serializer must parse a serialized model back to the original, and serialize modifications with minimal textual diffs. Ambiguities can cause parsing/serialization mismatches.
- The architecture uses state machines and observer pattern. Hooks allow customizing cross-references, keywords, values and more during serialization.
Lisp Macros in 20 Minutes (Featuring Clojure)Phil Calçado
"We just started holding 20 minutes presentations during lunch time in the ThoughtWorks Sydney office. For the first session I gave a not-that-short talk on Lisp macros using Clojure. The slides are below.
It turns out that 20 minutes is too little time to actually acquire content but I think at least we now have some people interested in how metaprogramming can be more than monkey patching."
http://fragmental.tw/2009/01/20/presentation-slides-macros-in-20-minutes/
This document provides an introduction to programming concepts useful for designing with code, including object oriented programming, frameworks, syntax, classes, objects, functions, variables, and arrays. It explains that arrays allow the creation of multiple variables without defining a new name for each, making the code shorter and easier to read and update. Arrays can store different data types like images or numbers.
The document discusses using node.js with MongoDB. It includes examples of basic CRUD operations using the node.js driver and MongoDB native driver. It also discusses ORM libraries like Mongoose that provide an abstraction layer. The document contains code samples for performing inserts, updates, finds and counting documents using the native node.js driver and Mongoose.
Continuation Passing Style and Macros in Clojure - Jan 2012Leonardo Borges
The document discusses continuation-passing style (CPS) in Clojure, where control is passed explicitly as a continuation argument to each function, and provides examples of implementing the Pythagorean theorem and Fibonacci sequence in CPS; it also explains how macros can be used to avoid deep nesting when accessing nested values and demonstrates a macro for this use case.
Scala is a functional programming language that runs on the Java Virtual Machine. The document discusses using Scala to define functions for zero and successor, and provides an example of calling those functions. It also mentions using Scala with Android and recipes, and using Scala with the Zsh shell by defining a scall function to run Scala code on files or standard input.
The document provides documentation for an SVG generation library in Go. It describes functions for reading Flickr photo data, parsing it into structures, and drawing an image grid. Key functions include flickrAPI to call the Flickr API, makeURI to convert photo details to URLs, and imageGrid to read the response, create an SVG group, and add linked image elements in a grid layout.
This document summarizes a presentation about unit testing Spark applications. The presentation discusses why it is important to run Spark locally and as unit tests instead of just on a cluster for faster feedback and easier debugging. It provides examples of how to run Spark locally in an IDE and as ScalaTest unit tests, including how to create test RDDs and DataFrames and supply test data. It also discusses testing concepts for streaming applications, MLlib, GraphX, and integration testing with technologies like HBase and Kafka.
This is an quick introduction to Scalding and Monoids. Scalding is a Scala library that makes writing MapReduce jobs very easy. Monoids on the other hand promise parallelism and quality and they make some more challenging algorithms look very easy.
The talk was held at the Helsinki Data Science meetup on January 9th 2014.
This document provides a help and tutorial for TopStyle Pro version 3.11. It covers getting started with TopStyle, editing style sheets and HTML/XHTML, working with colors, previews, validation, site management, reports, mappings, customization, and third-party integration. It also includes appendices on CSS basics and tips, TopStyle tips and tricks, style sheet resources, keyboard shortcuts, and regular expressions.
TopStyle Help & <b>Tutorial</b>tutorialsruby
This document provides a table of contents for the TopStyle Pro Help & Tutorial, which teaches how to use the TopStyle software for editing style sheets and HTML/XHTML documents. It lists over 50 sections that provide explanations and instructions for features like creating and opening files, editing styles, working with colors, previews, validation, site management, reports and customizing the software. The document was created by Giampaolo Bellavite from the online help provided with TopStyle version 3.11.
The Art Institute of Atlanta IMD 210 Fundamentals of Scripting <b>...</b>tutorialsruby
This document provides the course outline for IMD 210 Fundamentals of Scripting Languages at The Art Institute of Atlanta during the Spring 2005 quarter. The course focuses on integrating programming concepts with interface design using scripting languages like JavaScript and CSS. It will cover topics like DOM, CSS layout, JavaScript variables, conditionals, and events. Students will complete 4 assignments including redesigning existing websites, and there will be weekly quizzes, a midterm, and final exam. The course is worth 4 credits and meets once a week for class and lab.
This document provides the course outline for IMD 210 Fundamentals of Scripting Languages at The Art Institute of Atlanta during the Spring 2005 quarter. The course focuses on integrating programming concepts with interface design using scripting languages like JavaScript and CSS. It will cover topics like DOM, CSS layout, JavaScript variables, conditionals, and events. Students will complete 4 assignments including redesigning existing websites, and there will be weekly quizzes, a midterm, and final exam. The course is worth 4 credits and meets once a week for class and lab.
The group aims to bridge gaps between peer-to-peer database architectures and scaling multimedia information retrieval. They develop a probabilistic multimedia database system with abstraction layers for applications and researchers. They also research challenges of peer-to-peer networks for distributed data management. Both lines are supported by the MonetDB platform to exploit custom hardware and adaptive query optimization. The goal is a modular solution linking theoretical optimal solutions to application demands under resource limitations.
Standardization and Knowledge Transfer – INS0tutorialsruby
The group aims to bridge gaps between peer-to-peer database architectures and scaling multimedia information retrieval. They develop a probabilistic multimedia database system with abstraction layers and a flexible model. They also research challenges of peer-to-peer networks for distributed data management. Both lines are supported by the MonetDB platform to exploit custom hardware and adaptive query optimization. The goal is a modular solution linking theoretical optimal solutions to application demands under resource limitations.
This document provides an introduction to converting HTML documents to XHTML, including the basic syntax changes needed like making all tags lowercase and closing all tags. It provides examples of correct XHTML markup for different tags. It also explains the new DOCTYPE declaration and shows a sample well-formed XHTML document incorporating all the discussed changes. Resources for learning more about XHTML are listed at the end.
This document provides an introduction to converting HTML documents to XHTML, including the basic syntax changes needed like making all tags lowercase and closing all tags. It provides examples of correct XHTML markup for different tags. It also explains the new DOCTYPE declaration and shows a sample well-formed XHTML document incorporating all the discussed changes. Resources for learning more about XHTML are listed at the end.
XHTML is a markup language that provides structure and semantics to web pages. It is based on XML and is more strict than HTML. XHTML pages must have a document type definition, html and head tags, and a body where the visible content goes. Common XHTML tags include paragraphs, lists, links, images, and divisions to logically separate content. While XHTML provides structure, CSS is used to style pages and control visual presentation by defining rules for tags. CSS rules are defined in external style sheets to keep presentation separate from structure and content.
XHTML is a markup language that provides structure and semantics to web pages. It is based on XML and is more strict than HTML. XHTML pages must have a document type definition, html and head tags, and a body where the visible content goes. Common XHTML tags include paragraphs, lists, links, images, and divisions to logically separate content. While XHTML provides structure, CSS is used to style pages and control visual presentation through rules that target specific XHTML elements.
This document discusses how to create and use external cascading style sheets (CSS) in Dreamweaver. It provides steps to:
1. Open the CSS Styles tab in Dreamweaver and create a new external CSS stylesheet using a sample text style.
2. Save the stylesheet and link it to a new HTML page to style elements like headings, text sizes, and boxes.
3. Edit existing styles by selecting a tag in the CSS Styles panel and modifying properties directly, or by clicking the tag and using the pencil icon to edit in a window. This allows customizing styles globally across all linked pages.
This document provides an overview of how to create and use cascading style sheets (CSS) in Dreamweaver. It describes the different types of style sheets, including external and internal style sheets. It outlines the steps to create an external style sheet in Dreamweaver using the CSS Styles panel and provides instructions for linking the external style sheet to an HTML page. The document demonstrates how to experiment with predefined styles and how to edit, add, and delete styles in the CSS stylesheet.
This document appears to be a weekly update from an intro to computer science course. It includes summaries of classmates' demographics, comfort levels, and prior experience. It also discusses time spent on problem sets and recommends upcoming courses in CS51 and CS61. Finally, it recommends reading on TCP/IP, HTTP, XHTML, CSS, PHP, SQL and using the bulletin board for questions.
This document appears to be a weekly update from an intro to computer science course. It includes summaries of classmates' demographics, comfort levels, and prior experience. It also discusses time spent on problem sets and recommends upcoming courses in CS51 and CS61. Finally, it recommends reading on topics like TCP/IP, HTTP, XHTML, CSS, PHP, SQL and using bulletin boards, and includes images related to these topics.
The document discusses how to use Cascading Style Sheets (CSS) with Corvid Servlet Runtime templates to control formatting and layout. CSS allows separating design from content, making templates simpler and easier to maintain. It also enables adapting appearance for different devices. The document provides examples of using CSS classes to style template elements and explains how to set up a demo system using the included CSS and templates.
The document discusses how to use Cascading Style Sheets (CSS) with Corvid Servlet Runtime templates to control formatting and layout. CSS allows separating design from content, making templates simpler and easier to maintain. It also enables customization of appearance for different devices. The document provides examples of how to apply CSS classes and rules to Corvid template elements to control fonts, colors, positioning and more.
The document provides an introduction to CSS and how it works with HTML to control the presentation and styling of web page content. It explains basic CSS concepts like selectors, properties and values, and how CSS rules are used to target specific HTML elements and style them. Examples are given of common CSS properties and selectors and how they can be used to style elements and format the layout of web pages.
The document introduces CSS and how it works with HTML to separate content from presentation, allowing the styling of web pages through rules that target HTML elements. It explains CSS syntax and various selectors like type, class, ID, and descendant selectors. Examples are provided of how CSS can be used to style properties like color, font, padding, and layout of elements on a page.
Cascading Style Sheets (CSS) allow users to define how HTML elements are presented on a page. CSS enables changing the appearance and layout of an entire website by editing just one CSS file. CSS uses selectors to apply styles to HTML elements via properties and values. Styles can be defined internally in HTML or externally in CSS files. CSS can control text formatting, colors, spacing, positioning and more to achieve visual consistency across web pages.
Cascading Style Sheets (CSS) allow users to define how HTML elements are presented on a page. CSS enables changing the appearance and layout of an entire website by editing just one CSS file. CSS uses selectors to apply styles to HTML elements via properties and values. Styles can be defined internally in HTML or externally in CSS files. CSS can control text formatting, colors, spacing, positioning and more to achieve visual consistency across web pages.
Monitoring and Managing Anomaly Detection on OpenShift.pdfTosin Akinosho
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...Jason Yip
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/how-axelera-ai-uses-digital-compute-in-memory-to-deliver-fast-and-energy-efficient-computer-vision-a-presentation-from-axelera-ai/
Bram Verhoef, Head of Machine Learning at Axelera AI, presents the “How Axelera AI Uses Digital Compute-in-memory to Deliver Fast and Energy-efficient Computer Vision” tutorial at the May 2024 Embedded Vision Summit.
As artificial intelligence inference transitions from cloud environments to edge locations, computer vision applications achieve heightened responsiveness, reliability and privacy. This migration, however, introduces the challenge of operating within the stringent confines of resource constraints typical at the edge, including small form factors, low energy budgets and diminished memory and computational capacities. Axelera AI addresses these challenges through an innovative approach of performing digital computations within memory itself. This technique facilitates the realization of high-performance, energy-efficient and cost-effective computer vision capabilities at the thin and thick edge, extending the frontier of what is achievable with current technologies.
In this presentation, Verhoef unveils his company’s pioneering chip technology and demonstrates its capacity to deliver exceptional frames-per-second performance across a range of standard computer vision networks typical of applications in security, surveillance and the industrial sector. This shows that advanced computer vision can be accessible and efficient, even at the very edge of our technological ecosystem.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
Dandelion Hashtable: beyond billion requests per second on a commodity serverAntonios Katsarakis
This slide deck presents DLHT, a concurrent in-memory hashtable. Despite efforts to optimize hashtables, that go as far as sacrificing core functionality, state-of-the-art designs still incur multiple memory accesses per request and block request processing in three cases. First, most hashtables block while waiting for data to be retrieved from memory. Second, open-addressing designs, which represent the current state-of-the-art, either cannot free index slots on deletes or must block all requests to do so. Third, index resizes block every request until all objects are copied to the new index. Defying folklore wisdom, DLHT forgoes open-addressing and adopts a fully-featured and memory-aware closed-addressing design based on bounded cache-line-chaining. This design offers lock-free index operations and deletes that free slots instantly, (2) completes most requests with a single memory access, (3) utilizes software prefetching to hide memory latencies, and (4) employs a novel non-blocking and parallel resizing. In a commodity server and a memory-resident workload, DLHT surpasses 1.6B requests per second and provides 3.5x (12x) the throughput of the state-of-the-art closed-addressing (open-addressing) resizable hashtable on Gets (Deletes).
The Microsoft 365 Migration Tutorial For Beginner.pptxoperationspcvita
This presentation will help you understand the power of Microsoft 365. However, we have mentioned every productivity app included in Office 365. Additionally, we have suggested the migration situation related to Office 365 and how we can help you.
You can also read: https://www.systoolsgroup.com/updates/office-365-tenant-to-tenant-migration-step-by-step-complete-guide/
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
What is an RPA CoE? Session 1 – CoE VisionDianaGray10
In the first session, we will review the organization's vision and how this has an impact on the COE Structure.
Topics covered:
• The role of a steering committee
• How do the organization’s priorities determine CoE Structure?
Speaker:
Chris Bolin, Senior Intelligent Automation Architect Anika Systems
Introduction of Cybersecurity with OSS at Code Europe 2024Hiroshi SHIBATA
I develop the Ruby programming language, RubyGems, and Bundler, which are package managers for Ruby. Today, I will introduce how to enhance the security of your application using open-source software (OSS) examples from Ruby and RubyGems.
The first topic is CVE (Common Vulnerabilities and Exposures). I have published CVEs many times. But what exactly is a CVE? I'll provide a basic understanding of CVEs and explain how to detect and handle vulnerabilities in OSS.
Next, let's discuss package managers. Package managers play a critical role in the OSS ecosystem. I'll explain how to manage library dependencies in your application.
I'll share insights into how the Ruby and RubyGems core team works to keep our ecosystem safe. By the end of this talk, you'll have a better understanding of how to safeguard your code.
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.
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
zkStudyClub - LatticeFold: A Lattice-based Folding Scheme and its Application...Alex Pruden
Folding is a recent technique for building efficient recursive SNARKs. Several elegant folding protocols have been proposed, such as Nova, Supernova, Hypernova, Protostar, and others. However, all of them rely on an additively homomorphic commitment scheme based on discrete log, and are therefore not post-quantum secure. In this work we present LatticeFold, the first lattice-based folding protocol based on the Module SIS problem. This folding protocol naturally leads to an efficient recursive lattice-based SNARK and an efficient PCD scheme. LatticeFold supports folding low-degree relations, such as R1CS, as well as high-degree relations, such as CCS. The key challenge is to construct a secure folding protocol that works with the Ajtai commitment scheme. The difficulty, is ensuring that extracted witnesses are low norm through many rounds of folding. We present a novel technique using the sumcheck protocol to ensure that extracted witnesses are always low norm no matter how many rounds of folding are used. Our evaluation of the final proof system suggests that it is as performant as Hypernova, while providing post-quantum security.
Paper Link: https://eprint.iacr.org/2024/257
4. JavaScript Built-in Objects
Ø Math Object:
§ Properties:
• E( Euler’s constant) LN2(Natural log of 2) LN10(natural log of 10)
LOG2E(log base-2 of E) LOG10E(log base-10 of E) PI
SQRT1_2( square root of 0.5) SQRT2(square root of 2)
§ Methods:
• abs( value ) acos( value ) asin( value )
atan( value ) atan2( value1, value2 ) ceil( value )
cos( value ) exp( value ) floor( value )
log( value ) max( value1, value2 ) min( value1, value2 )
pow( value1, value2 ) random( ) round( value )
sin( value ) sqrt( value ) tan( value )
Ø Number Object:
• Properties:
• constructor MAX_VALUE MIN_VALUE
NaN NEGATIVE_INFINITY POSITIVE_INIFINITY
prototype
§ Methods:
• toExponential( value ) toFixed( value ) toLocaleString( value )
toString( value ) toPrecision( ) valueOf( )
4
5. JavaScript Built-in Objects (cont’d)
Ø Boolean Object:
• Properties:
• constructor prototype
§ Methods:
• toString( BooleanValue ) valueOf( )
Ø Date Object:
§ Methods:
• getFullYear( ) getYear( ) getMonth( )
getDate( ) getDay( ) getHours( )
getMinutes( ) getSeconds( value ) getTime( value )
getMilliseconds( ) getUTCFullYear( value1, value2 ) getUTCMonth( value1, value2 )
getUTCDate( value1, value2 ) getUTCDay( ) getUTCHours( value )
getUTCMinutes( ) getUTCSeconds( ) tgetUTCMilliseconds( )
setYear( value ) setFullYear( value ) setMonth( value )
setDate ( value ) setHours( value ) setMinutes( value )
setSeconds( value ) setMilliseconds( value ) setTime( value )
setUTCFullYear( value ) setUTCMonth( value ) setUTCDate ( value )
setUTCHours( value ) setUTCMinutes( value ) setUTCSeconds( value )
setUTCMilliseconds( value ) getTimezoneOffset( ) toDateString( )
toGMTString( ) toLocaleString( ) toLocateTimeString( )
toString( ) toTimeString( ) toUTCString( )
parse( “a date string”) UTC( date values )
5
9. JavaScript Global Functions and Statements
Ø Global Functions:
§ decodeURI( “encodedURI” )
§ decodeURIComponent(“encodedURIComponent” )
§ encodeURI( “URIString” )
§ encodeURIComponent( “URIComponentString” )
§ escape( “URIString” )
§ unescape( “escapedURIString” )
§ eval( “string” ) // evaluate any JavaScript statement or expression stored as string
§ isFinite( number ) // checks if number is beyond JavaScript ability to handle
§ isNan( expression ) // tests whether a value is a number or not
§ Number( “string” ) // converts a string to a numeric value
§ parseFloat( “string” ) // converts a string to a float
§ parseInt( “string” , radix ) // converts a string to an integer
§ toString( ) // returns a string representation
§ unwatch( ) // for debugging purposes
§ watch( ) // for debugging purposes
Ø Statements:
§ const // e.g. const FREEZING_F = 32;
§ var // e.g.: var temperature = 32;
§ // comments
9
11. JavaScript – Applet Communication
Ø test.html
<html>
<head><title>test</title></head>
<body>
<h1>This is a test of applets</h1>
<hr></hr>
<applet name="testapplet" code="TestApplet.class" height="300" width="300">
<param name="text" value="Grizzly Dave!"></param>
Text displayed by non-java enabled browsers
</applet>
<hr></hr>
<form>
<input type="button“ onclick="alert(document.testapplet.getText())“ value="Get Data From Applet">
</form>
</body>
</html>
Ø TestApplet.java
import java.applet.*;
import java.awt.*;
public class TestApplet extends Applet {
String text = "error";
public void init() {
text = getParameter("text");
}
public void paint(Graphics g) {
g.drawString(text,50,50);
}
public String getText() {
return text;
}
} 11
12. DOM Hierarchy
Window
(frame,self,top,parent)
navigator screen history document location event
link stylesheets applets form images plugins embeds
anchor all
textarea text radio button reset select
selection
[elements]
option
password checkbox submit
style
12