This document proposes an implementation of LINQ-style querying for ActionScript 3 collections. It provides examples of filtering, sorting, grouping and selecting data from collections using query syntax. The implementation would include interfaces like IQuery and ICondition to define query and filter objects. CollectionQuery would be the main class, allowing queries to be built and executed on a target collection. Predicates would represent individual filter conditions, and Conditions groups of predicates. The proposal outlines methods, properties and classes required to support queries on nested and complex objects.
The document discusses functions and objects in JavaScript. It defines a function as a reusable block of code that performs operations to fulfill a specific task. Functions can be invoked to execute their code. Objects are collections of properties and methods that represent real-world entities. The document describes how to create user-defined functions and objects in JavaScript, including defining properties and methods. It also provides examples of the built-in String and Math objects and their properties and methods.
Lodash is a JavaScript library that provides utility functions for common programming tasks like array, object and string manipulation, as well as functions for chaining, currying and binding. It includes methods for filtering, sorting, mapping, reducing, currying, binding and templating JavaScript objects and arrays. Lodash wraps values to enable method chaining and provides both chainable and non-chainable wrapper methods.
JavaScript Fundamentals with Angular and LodashBret Little
The purpose of this presentation is also largely to explain some of the fun parts of JavaScript (dynamic function invocation with reflection, dynamic arguments, etc). I don't necessarily encourage putting complex logic throughout your templates with lodash, though there may be times it is appropriate.
Lets talk about lodash and how it can easily be married to Angular. Using a six line filter, I will expose the power of lodash directly within angular templates. This will be an introduction to lodash, angular templates, and we'll talk about scope and reflection within JavaScript.
jQuery Data Manipulate API - A source code dissecting journeyHuiyi Yan
Represent major data manipulate API in jQuery 1.6; such as .data(), removeData(), index(), globalEval() and so no. Also, HTML5 data-* attributes. I will walk you through with diving into jQuery source code and find out the killing techniques used in jQuery.
This document discusses various utility methods provided by Prototype to simplify common scripting tasks. The $ method is described as the cornerstone method, as it allows passing either element IDs or DOM elements to functions. The $$ method selects elements using CSS selectors. The $A, $F, $H, $R, and $w methods provide shortcuts for common tasks like casting to an array, getting a form value, creating hashes and ranges, and splitting a string. The Try.these method returns the result of the first function passed to it that does not throw an error.
This document introduces valid_model, a Python library for declarative data modeling. It allows defining data models using descriptors to specify data types and validation rules. This provides strict typing while remaining unopinionated about persistence. Custom descriptors can extend the library's functionality. The library aims to enable use cases like database modeling, form validation, and API request/response objects.
This document provides an overview of Scala and compares it to Java. It discusses Scala's object-oriented and functional capabilities, how it compiles to JVM bytecode, and benefits like less boilerplate code and support for functional programming. Examples are given of implementing a simple Property class in both Java and Scala to illustrate concepts like case classes, immutable fields, and less lines of code in Scala. The document also touches on Java interoperability, learning Scala gradually, XML processing capabilities, testing frameworks, and tool/library support.
The document discusses functions and objects in JavaScript. It defines a function as a reusable block of code that performs operations to fulfill a specific task. Functions can be invoked to execute their code. Objects are collections of properties and methods that represent real-world entities. The document describes how to create user-defined functions and objects in JavaScript, including defining properties and methods. It also provides examples of the built-in String and Math objects and their properties and methods.
Lodash is a JavaScript library that provides utility functions for common programming tasks like array, object and string manipulation, as well as functions for chaining, currying and binding. It includes methods for filtering, sorting, mapping, reducing, currying, binding and templating JavaScript objects and arrays. Lodash wraps values to enable method chaining and provides both chainable and non-chainable wrapper methods.
JavaScript Fundamentals with Angular and LodashBret Little
The purpose of this presentation is also largely to explain some of the fun parts of JavaScript (dynamic function invocation with reflection, dynamic arguments, etc). I don't necessarily encourage putting complex logic throughout your templates with lodash, though there may be times it is appropriate.
Lets talk about lodash and how it can easily be married to Angular. Using a six line filter, I will expose the power of lodash directly within angular templates. This will be an introduction to lodash, angular templates, and we'll talk about scope and reflection within JavaScript.
jQuery Data Manipulate API - A source code dissecting journeyHuiyi Yan
Represent major data manipulate API in jQuery 1.6; such as .data(), removeData(), index(), globalEval() and so no. Also, HTML5 data-* attributes. I will walk you through with diving into jQuery source code and find out the killing techniques used in jQuery.
This document discusses various utility methods provided by Prototype to simplify common scripting tasks. The $ method is described as the cornerstone method, as it allows passing either element IDs or DOM elements to functions. The $$ method selects elements using CSS selectors. The $A, $F, $H, $R, and $w methods provide shortcuts for common tasks like casting to an array, getting a form value, creating hashes and ranges, and splitting a string. The Try.these method returns the result of the first function passed to it that does not throw an error.
This document introduces valid_model, a Python library for declarative data modeling. It allows defining data models using descriptors to specify data types and validation rules. This provides strict typing while remaining unopinionated about persistence. Custom descriptors can extend the library's functionality. The library aims to enable use cases like database modeling, form validation, and API request/response objects.
This document provides an overview of Scala and compares it to Java. It discusses Scala's object-oriented and functional capabilities, how it compiles to JVM bytecode, and benefits like less boilerplate code and support for functional programming. Examples are given of implementing a simple Property class in both Java and Scala to illustrate concepts like case classes, immutable fields, and less lines of code in Scala. The document also touches on Java interoperability, learning Scala gradually, XML processing capabilities, testing frameworks, and tool/library support.
Pluggable plugins allow developers to build reusable plugin components in a more secure and maintainable way compared to traditional monolithic plugins. They are constructed by teams using object-oriented programming principles like inheritance, which allows components to be extended while reusing common functionality. This makes the code more modular and customizable. Real-world examples show how pluggable components can be built and integrated into projects like photo galleries and ecommerce systems to solve problems like adding custom image sizes or integrating external inventory systems.
This document outlines topics covered in a lecture on object oriented JavaScript using the Prototype framework, including:
- Revision of object oriented JavaScript concepts like objects, prototypes, and classes
- Prototype framework utilities like $, $$ and Enumerable
- Extending DOM elements using Prototype methods
- Templates, form management, and getting element dimensions
- Event handling and classes/inheritance in Prototype
- JSON encoding/parsing
- Ajax utilities like Ajax.Request and Ajax.Updater
Descriptive programming allows testers to directly enter object information into test scripts without using an object repository. There are two main types: static programming, where object information is directly provided in the script using properties and values, and dynamic programming, where description objects are created and used in the script. Descriptive programming is useful when objects are dynamic, the object repository is large, the application is not ready for recording, or modifications are needed but the repository is read-only. It offers benefits like faster execution, portability, easier maintenance, and the ability to start testing without the full application.
Singletons in PHP - Why they are bad and how you can eliminate them from your...go_oh
While Singletons have become a Pattern-Non-Grata over the years, you still find it surprisingly often in PHP applications and frameworks. This talk will explain what the Singleton pattern is, how it works in PHP and why you should avoid it in your application.
Programación funcional con swift. Se ven conceptos como funciones de primera clase, funciones de orden superior, métodos como filter, map y el patrón Result para la gestión de errores.
The document discusses the MVC pattern and its components - Model, View, Controller. It then provides more details on concepts related to the model component, including entities, data access objects (DAOs), mappers, services, and interfaces. It shows examples of how these concepts can be implemented, such as defining interfaces, entity and DAO classes, and using mappers and services to work with data from different sources.
The document discusses basic inheritance in Python. It explains that all classes inherit from the base Object class. Inheritance allows creating subclasses that inherit attributes and methods from a parent superclass. This allows code reuse and adding specialized behavior. An example creates a Contact class to store names and emails, with a Supplier subclass that adds an "order" method. A SupplierCheck subclass then overrides the order method to check the customer balance before processing orders.
The document discusses improving code quality through object calisthenics and readability tips. Object calisthenics are a set of simple exercises to help internalize principles of object-oriented design, like having only one level of indentation per method. Readability tips include writing code that minimizes the time for others to understand it, using single line if statements for simple operations, and returning early from functions. Native PHP functions are also preferable for performance over pure PHP implementations.
Objects in JavaScript can be created using object literals, the new keyword, or Object.create(). Objects are collections of properties and methods that are mutable and manipulated by reference. Arrays are objects that represent ordered collections of values of any type and are created using array literals or the Array constructor. Common array methods include concat, join, pop, push, reverse, and sort. The Math object provides common mathematical functions like pow, round, ceil, floor, random, and trigonometric functions.
Implementation details and performance traits of generics in .NET, Java and C++. Presentation for the Jerusalem .NET/C++ User Group by Sasha Goldshtein.
JavaScript: The Good Parts Or: How A C# Developer Learned To Stop Worrying An...Doug Jones
We rarely dive into current programming languages, touting the next new framework or the new features that will be out next year. This is about JavaScript the language as it exists today, what I picked up in going from C# to JS, and what C# picked up from JS along the way as well. It is based on Douglas Crockford's seminal book "JavaScript: The Good Parts".
The document provides an overview of various Objective-C concepts including classes, objects, methods, properties, protocols, categories, dictionaries, property lists, user defaults, errors, delegates, callbacks, and table views. It discusses core classes like NSString, NSArray, NSDictionary, and NSMutableDictionary. It covers concepts like inheritance, polymorphism, and memory management using retain, release, and autorelease. The document also provides examples of declaring and defining classes, creating class instances, and implementing table views with custom cells.
This document provides an introduction to JavaScript including:
- JavaScript is an object-oriented scripting language that is a dialect of ECMAScript.
- It was originally designed to add interactivity to HTML pages through dynamic HTML, reacting to events, and data validation.
- JavaScript is now heavily used in AJAX-based sites to asynchronously retrieve and display data without reloading pages.
- The document discusses JavaScript compatibility issues and provides examples of basic JavaScript concepts like variables, comparisons, repetition, and popup boxes.
A dictionary in Python is a mutable container that stores key-value pairs, with keys that must be immutable like strings or numbers. Dictionaries allow fast lookup of values based on keys. Keys must be unique within a dictionary, while values can be of any type including other containers. Dictionaries can be accessed, updated, and modified using square bracket notation or dictionary methods.
The document discusses generics in C#, explaining that generics allow defining type-safe data structures without committing to actual data types, improving performance and code quality. It covers why generics are required by discussing issues with non-generic stacks, and describes generic type parameters, constraints, methods, delegates and event handling using generics.
Este documento proporciona información sobre diferentes tipos de memoria RAM y ROM. Explica brevemente Dynamic RAM (DRAM), Static RAM (SRAM), Video RAM (VRAM), Single In-line Memory Module (SIMM), Dual In-line Memory Module (DIMM), y RAM Disk. También cubre memoria caché, Synchronous DRAM (SDRAM), Fast Page Mode (FPM), Extended Data Output (EDO), y Pipeline Burst SRAM. Por último, resume Programmable ROM (PROM), Erasable Programmable ROM (EPROM), EEPROM, y memoria FLASH.
Pluggable plugins allow developers to build reusable plugin components in a more secure and maintainable way compared to traditional monolithic plugins. They are constructed by teams using object-oriented programming principles like inheritance, which allows components to be extended while reusing common functionality. This makes the code more modular and customizable. Real-world examples show how pluggable components can be built and integrated into projects like photo galleries and ecommerce systems to solve problems like adding custom image sizes or integrating external inventory systems.
This document outlines topics covered in a lecture on object oriented JavaScript using the Prototype framework, including:
- Revision of object oriented JavaScript concepts like objects, prototypes, and classes
- Prototype framework utilities like $, $$ and Enumerable
- Extending DOM elements using Prototype methods
- Templates, form management, and getting element dimensions
- Event handling and classes/inheritance in Prototype
- JSON encoding/parsing
- Ajax utilities like Ajax.Request and Ajax.Updater
Descriptive programming allows testers to directly enter object information into test scripts without using an object repository. There are two main types: static programming, where object information is directly provided in the script using properties and values, and dynamic programming, where description objects are created and used in the script. Descriptive programming is useful when objects are dynamic, the object repository is large, the application is not ready for recording, or modifications are needed but the repository is read-only. It offers benefits like faster execution, portability, easier maintenance, and the ability to start testing without the full application.
Singletons in PHP - Why they are bad and how you can eliminate them from your...go_oh
While Singletons have become a Pattern-Non-Grata over the years, you still find it surprisingly often in PHP applications and frameworks. This talk will explain what the Singleton pattern is, how it works in PHP and why you should avoid it in your application.
Programación funcional con swift. Se ven conceptos como funciones de primera clase, funciones de orden superior, métodos como filter, map y el patrón Result para la gestión de errores.
The document discusses the MVC pattern and its components - Model, View, Controller. It then provides more details on concepts related to the model component, including entities, data access objects (DAOs), mappers, services, and interfaces. It shows examples of how these concepts can be implemented, such as defining interfaces, entity and DAO classes, and using mappers and services to work with data from different sources.
The document discusses basic inheritance in Python. It explains that all classes inherit from the base Object class. Inheritance allows creating subclasses that inherit attributes and methods from a parent superclass. This allows code reuse and adding specialized behavior. An example creates a Contact class to store names and emails, with a Supplier subclass that adds an "order" method. A SupplierCheck subclass then overrides the order method to check the customer balance before processing orders.
The document discusses improving code quality through object calisthenics and readability tips. Object calisthenics are a set of simple exercises to help internalize principles of object-oriented design, like having only one level of indentation per method. Readability tips include writing code that minimizes the time for others to understand it, using single line if statements for simple operations, and returning early from functions. Native PHP functions are also preferable for performance over pure PHP implementations.
Objects in JavaScript can be created using object literals, the new keyword, or Object.create(). Objects are collections of properties and methods that are mutable and manipulated by reference. Arrays are objects that represent ordered collections of values of any type and are created using array literals or the Array constructor. Common array methods include concat, join, pop, push, reverse, and sort. The Math object provides common mathematical functions like pow, round, ceil, floor, random, and trigonometric functions.
Implementation details and performance traits of generics in .NET, Java and C++. Presentation for the Jerusalem .NET/C++ User Group by Sasha Goldshtein.
JavaScript: The Good Parts Or: How A C# Developer Learned To Stop Worrying An...Doug Jones
We rarely dive into current programming languages, touting the next new framework or the new features that will be out next year. This is about JavaScript the language as it exists today, what I picked up in going from C# to JS, and what C# picked up from JS along the way as well. It is based on Douglas Crockford's seminal book "JavaScript: The Good Parts".
The document provides an overview of various Objective-C concepts including classes, objects, methods, properties, protocols, categories, dictionaries, property lists, user defaults, errors, delegates, callbacks, and table views. It discusses core classes like NSString, NSArray, NSDictionary, and NSMutableDictionary. It covers concepts like inheritance, polymorphism, and memory management using retain, release, and autorelease. The document also provides examples of declaring and defining classes, creating class instances, and implementing table views with custom cells.
This document provides an introduction to JavaScript including:
- JavaScript is an object-oriented scripting language that is a dialect of ECMAScript.
- It was originally designed to add interactivity to HTML pages through dynamic HTML, reacting to events, and data validation.
- JavaScript is now heavily used in AJAX-based sites to asynchronously retrieve and display data without reloading pages.
- The document discusses JavaScript compatibility issues and provides examples of basic JavaScript concepts like variables, comparisons, repetition, and popup boxes.
A dictionary in Python is a mutable container that stores key-value pairs, with keys that must be immutable like strings or numbers. Dictionaries allow fast lookup of values based on keys. Keys must be unique within a dictionary, while values can be of any type including other containers. Dictionaries can be accessed, updated, and modified using square bracket notation or dictionary methods.
The document discusses generics in C#, explaining that generics allow defining type-safe data structures without committing to actual data types, improving performance and code quality. It covers why generics are required by discussing issues with non-generic stacks, and describes generic type parameters, constraints, methods, delegates and event handling using generics.
Este documento proporciona información sobre diferentes tipos de memoria RAM y ROM. Explica brevemente Dynamic RAM (DRAM), Static RAM (SRAM), Video RAM (VRAM), Single In-line Memory Module (SIMM), Dual In-line Memory Module (DIMM), y RAM Disk. También cubre memoria caché, Synchronous DRAM (SDRAM), Fast Page Mode (FPM), Extended Data Output (EDO), y Pipeline Burst SRAM. Por último, resume Programmable ROM (PROM), Erasable Programmable ROM (EPROM), EEPROM, y memoria FLASH.
This document proposes a narrative display to summarize sports tournaments using a tree layout to show tournament structure, small multiples to detail individual matches, and tweets to capture fan reactions, using data from the 2012-2013 UEFA Champions League as an example. The display would be hosted at uclfinal.twitter.com and divided into three main sections for tournament overview, match details, and fans' reactions.
Krist Wongsuphasawat's Dissertation Proposal Slides: Interactive Exploration ...Krist Wongsuphasawat
This dissertation by Krist Wongsuphasawat from the University of Maryland describes research on interactive exploration of event sequences in temporal categorical data. The document discusses how this type of data arises in domains like electronic health records and student records. It proposes designing effective visualization and interaction techniques to support users in exploring event sequences when they are uncertain about what they are looking for. The research aims to provide an overview of event sequences in temporal categorical data as well as a flexible temporal search approach.
The document summarizes research on visualizing temporal categorical data from electronic health records. It describes tools like LifeLines for visualizing a single patient record, LifeLines2 for searching and comparing multiple records, and Similan for similarity-based search. A new tool called LifeFlow is introduced for aggregating and visualizing patterns across large numbers of records. The research was conducted over 10+ years at the University of Maryland by researchers including Krist Wongsuphasawat, Taowei David Wang, Catherine Plaisant, and Ben Shneiderman.
d3Kit is a set of tools to speed D3 related project development. It is a lightweight library to help you do the basic groundwork tasks you need when building visualization with d3.
The document discusses object-oriented programming concepts in JavaScript. It explains that JavaScript uses prototype-based programming rather than classes. Behavior reuse is accomplished by decorating existing objects that serve as prototypes. It then covers key OO concepts like inheritance, encapsulation, polymorphism, and abstraction and how they are supported in JavaScript through mechanisms like prototypes, functions, and object literals. The document provides examples of defining classes with functions, creating objects, adding methods, and implementing inheritance through the prototype chain. It also discusses namespaces, closures, and other JavaScript programming patterns.
1. The document discusses JavaScript concepts like scope, closures, context, and object-oriented programming techniques like constructors, methods, and inheritance.
2. It provides examples of how to create public and private methods, and "privileged" methods that have access to private values and methods.
3. The document shows how to dynamically generate classes at runtime based on properties passed to a constructor using these JavaScript concepts.
This document provides an overview of using the Backbone.js framework for client-side MVC applications. It discusses why Backbone is useful for structuring JavaScript applications, its core architecture including models, collections, views and routers. It also provides examples of how to convert jQuery code to use a Backbone-based approach and lists some real-world applications that use Backbone.
The document appears to be notes on Backbone.js. It includes summaries of Backbone models, events, views and how to bind events. It demonstrates creating a model with defaults, getting/setting attributes, and binding event handlers. It also shows creating a view with tagName, className and attributes, and logging the generated HTML element.
Hello Swift Final 5/5 - Structures and ClassesCody Yun
The document provides an overview of classes and structures in Swift. It defines a Counter class with a count property and increment method. It then creates an instance of the Counter class and calls the increment method multiple times to increment the count property.
This lab report discusses object-oriented programming concepts like classes, objects, inheritance, and constructors in Java. It includes:
1) A class defines common properties and behaviors for a group of objects, while an object is an instance of a class. A house is an object with state like address and behavior like opening doors.
2) A constructor initializes an object when it is created and can be overloaded with different parameters. Getter and setter methods are used to access private variables.
3) Inheritance allows a subclass to inherit properties and behaviors from a parent class in a hierarchical relationship. This lab report provides examples of single, multilevel, and hierarchical inheritance in Java code.
The document introduces several uncommon design patterns:
1) Null Object pattern avoids using null values by implementing a "null" object that respects the expected interface.
2) Encapsulated Context pattern encapsulates common services/data needed by different components in a single context object rather than using global objects.
3) Role Object pattern handles modeling problems where an element can have different roles by using role objects that are added to and removed from a core object.
4) ISP & Object Adaptation pattern allows objects to adapt to different protocols by checking for direct implementation, using registered adapters, or throwing exceptions.
5) Essence pattern uses an "essence" class to encapsulate an object's configuration and
This document provides an overview of Backbone.js and how it can be used to build dynamic web applications. It discusses the main Backbone components:
- Models represent single data objects and can be validated.
- Collections hold ordered sets of models and can fetch data from the server.
- Views handle the display and interaction of data from models and collections.
- Routers map URLs to functions that control the application flow.
The document then gives an example of using Backbone to build a simple shopping cart application with Products and Cart views, demonstrating how the components work together.
The document discusses JavaScript objects and functions. It explains that JavaScript objects are collections of name-value pairs similar to dictionaries. Functions in JavaScript are objects that support function call operations. The document also covers constructor functions, prototypes, closures, and namespaces in JavaScript.
The document provides an outline of a lecture on object-oriented JavaScript and inheritance. It covers key concepts like objects, properties, methods, object literals, constructor functions, and prototype inheritance. It discusses creating and accessing objects, adding and removing properties, passing objects by reference, comparing objects, and the prototype chain. Private and privileged methods and properties are explained. Different approaches to implementing inheritance like prototype chaining are also summarized.
The document discusses how Symfony 1.2 supports RESTful routes out of the box. It provides examples of how to configure routes to support different HTTP methods like GET, POST, PUT, DELETE. It also describes how to create custom route classes to support additional route matching and generation behaviors, like domain routing based on subdomains. Overall, the document shows how Symfony 1.2 allows developers to easily create RESTful applications by mapping URLs to controller actions and resources in a RESTful way.
The document discusses Scala concepts including higher-order functions, anonymous functions, currying, tail recursion, classes and objects, properties with getters and setters, object-private fields, auxiliary constructors, primary constructors, nested classes, and singleton objects. It provides code examples to illustrate these Scala features and explains how they work and how they compare to similar concepts in other languages like Java. The document is intended as a lesson on these Scala programming concepts.
사내 기술 세미나를 다시 시작한다. 나는 그 첫번째 주제로 `Object-oriented Javascript`를 택했다.
예전에 학습했던 [Tuts+ 강의](https://code.tutsplus.com/courses/object-oriented-javascript)를 다시 정리하는 계기가 되었다.
Dpilot is a cloud based file transfer application that allows its user to upload data on cloud server and the receiver on the other hand can downlaod the data from the server. The Downlaod information is send to the receiver via mail service.
Other Features include:-
Secure Login system
Easy data Access
Lightening Fast Uploads and Downloads
Connect with your Facebook Or Gmail Account for easy access
This document contains code for a file sharing application that allows users to upload files to Amazon S3 storage and send download links to recipients via email. It includes code for connecting to MongoDB and S3 databases, handling file uploads with Multer, generating signed URLs with AWS, sending emails with Nodemailer, and building APIs with Express. The React code handles form inputs, file previews, and confirming upload status.
This document provides an overview of intermediate JavaScript language features including object literal notation, functions within objects, JSON syntax, arguments, arrays, logical operators, functions as objects, function pointers, callbacks, and higher order functions. It explains how object literals can be used to define objects and functions, the relationship between arrays and objects, and common patterns involving functions like callbacks and higher order functions.
This document discusses best practices for writing JavaScript code, including using object-oriented patterns, object hierarchies, and the prototype property to organize code and prevent naming collisions. It also recommends writing reusable code by parameterizing functions, using object literals as flexible parameters, and loading JavaScript on demand. Additionally, it suggests separating content, CSS and JavaScript into different files and reducing file sizes for production.
The Java Naming and Directory Interface (JNDI) allows Java applications to look up and discover named objects in a directory service. JNDI provides a standard interface for naming and accessing resources such as databases. Distributed application components can use JNDI to locate other components and resources by name. The JNDI lookup method passes a name and returns the associated object, enabling access to resources without prior knowledge of implementation details or location.
Similar to ActionScript3 collection query API proposal (20)
Walmart Business+ and Spark Good for Nonprofits.pdfTechSoup
"Learn about all the ways Walmart supports nonprofit organizations.
You will hear from Liz Willett, the Head of Nonprofits, and hear about what Walmart is doing to help nonprofits, including Walmart Business and Spark Good. Walmart Business+ is a new offer for nonprofits that offers discounts and also streamlines nonprofits order and expense tracking, saving time and money.
The webinar may also give some examples on how nonprofits can best leverage Walmart Business+.
The event will cover the following::
Walmart Business + (https://business.walmart.com/plus) is a new shopping experience for nonprofits, schools, and local business customers that connects an exclusive online shopping experience to stores. Benefits include free delivery and shipping, a 'Spend Analytics” feature, special discounts, deals and tax-exempt shopping.
Special TechSoup offer for a free 180 days membership, and up to $150 in discounts on eligible orders.
Spark Good (walmart.com/sparkgood) is a charitable platform that enables nonprofits to receive donations directly from customers and associates.
Answers about how you can do more with Walmart!"
Communicating effectively and consistently with students can help them feel at ease during their learning experience and provide the instructor with a communication trail to track the course's progress. This workshop will take you through constructing an engaging course container to facilitate effective communication.
Chapter wise All Notes of First year Basic Civil Engineering.pptxDenish Jangid
Chapter wise All Notes of First year Basic Civil Engineering
Syllabus
Chapter-1
Introduction to objective, scope and outcome the subject
Chapter 2
Introduction: Scope and Specialization of Civil Engineering, Role of civil Engineer in Society, Impact of infrastructural development on economy of country.
Chapter 3
Surveying: Object Principles & Types of Surveying; Site Plans, Plans & Maps; Scales & Unit of different Measurements.
Linear Measurements: Instruments used. Linear Measurement by Tape, Ranging out Survey Lines and overcoming Obstructions; Measurements on sloping ground; Tape corrections, conventional symbols. Angular Measurements: Instruments used; Introduction to Compass Surveying, Bearings and Longitude & Latitude of a Line, Introduction to total station.
Levelling: Instrument used Object of levelling, Methods of levelling in brief, and Contour maps.
Chapter 4
Buildings: Selection of site for Buildings, Layout of Building Plan, Types of buildings, Plinth area, carpet area, floor space index, Introduction to building byelaws, concept of sun light & ventilation. Components of Buildings & their functions, Basic concept of R.C.C., Introduction to types of foundation
Chapter 5
Transportation: Introduction to Transportation Engineering; Traffic and Road Safety: Types and Characteristics of Various Modes of Transportation; Various Road Traffic Signs, Causes of Accidents and Road Safety Measures.
Chapter 6
Environmental Engineering: Environmental Pollution, Environmental Acts and Regulations, Functional Concepts of Ecology, Basics of Species, Biodiversity, Ecosystem, Hydrological Cycle; Chemical Cycles: Carbon, Nitrogen & Phosphorus; Energy Flow in Ecosystems.
Water Pollution: Water Quality standards, Introduction to Treatment & Disposal of Waste Water. Reuse and Saving of Water, Rain Water Harvesting. Solid Waste Management: Classification of Solid Waste, Collection, Transportation and Disposal of Solid. Recycling of Solid Waste: Energy Recovery, Sanitary Landfill, On-Site Sanitation. Air & Noise Pollution: Primary and Secondary air pollutants, Harmful effects of Air Pollution, Control of Air Pollution. . Noise Pollution Harmful Effects of noise pollution, control of noise pollution, Global warming & Climate Change, Ozone depletion, Greenhouse effect
Text Books:
1. Palancharmy, Basic Civil Engineering, McGraw Hill publishers.
2. Satheesh Gopi, Basic Civil Engineering, Pearson Publishers.
3. Ketki Rangwala Dalal, Essentials of Civil Engineering, Charotar Publishing House.
4. BCP, Surveying volume 1
This document provides an overview of wound healing, its functions, stages, mechanisms, factors affecting it, and complications.
A wound is a break in the integrity of the skin or tissues, which may be associated with disruption of the structure and function.
Healing is the body’s response to injury in an attempt to restore normal structure and functions.
Healing can occur in two ways: Regeneration and Repair
There are 4 phases of wound healing: hemostasis, inflammation, proliferation, and remodeling. This document also describes the mechanism of wound healing. Factors that affect healing include infection, uncontrolled diabetes, poor nutrition, age, anemia, the presence of foreign bodies, etc.
Complications of wound healing like infection, hyperpigmentation of scar, contractures, and keloid formation.
Beyond Degrees - Empowering the Workforce in the Context of Skills-First.pptxEduSkills OECD
Iván Bornacelly, Policy Analyst at the OECD Centre for Skills, OECD, presents at the webinar 'Tackling job market gaps with a skills-first approach' on 12 June 2024
Gender and Mental Health - Counselling and Family Therapy Applications and In...PsychoTech Services
A proprietary approach developed by bringing together the best of learning theories from Psychology, design principles from the world of visualization, and pedagogical methods from over a decade of training experience, that enables you to: Learn better, faster!
2. Introduction
Draft implementation, just an idea, would be great if
we have something like this in ActionScript (but
more robust, complex, optimized of course)
Purpose – collection sorting, filtering, grouping
wrapper
OO-Style LINQ to Objects lib for flex
3. Usage examples – first, last, any, itemAt
//get first with title containing case insensitive string “Voislav Seselj”
var query:IQuery = new CollectionQuery(_news);
var firstItem:NewsFeed = query.where(new
Conditions().contains("title", “Voislav Seselj", false)).first() as NewsFeed;
//last item published in 2013 or 2014
var lastItem:NewsFeed = query.where(new
Conditions().eq("year", 2014).OR.eq("year", 2013)).last() as NewsFeed;
var usersQuery:IQuery = new CollectionQuery();
if(usersQuery.from(users).where(new Conditions().eq("name", "Peter Pan")).any())
{
//excellent, there is a user (or users) with name "Peter Pan“
}
//get third adault from the end of the collection ordered by name ascending and lastname
//descending.
var user:User = new CollectionQuery(users)
.where(new Conditions().gte("years", 18))
.orderBy("name").orderBy("lastname", false)
.itemAt(2) as User;
4. Usage examples – where, select, limit
//get users for given conditions ordered by company and then by years property
var users:IList = usersQuery.where(new Conditions().lt("years", 18).gt("years", 5).OR
.eq("company", "Company 1"))
.orderBy("company“).orderBy("years")
.execute() as IList;
//select collection containing anonymous objects with properties given in select clause
//extracted from user objects, for given conditions, ordered by salary with ascending order
//and compare as numerics.
//Limit to maximum 10 results
var users:IList = new CollectionQuery()
.select("name, lastname, company, salary")
.from(users)
.where(new Conditions().gte("salary", 40000).lte("salary", 45000)) //AND by default
.orderBy("salary", true, true)
.limit(10).execute() as IList;
5. Usage examples – nested complex objects
//select streets from complex member “address” for each user in users collection
var streets:IList = usersQuery.select("address.street").from(users).execute() as IList;
//select anonymous objects containing user’s name, lastname, address->number, address//>street, address->uniqueId->value, for users having address number greater then 400 in
//Kragujevac city, or having address number lower then 400 and live in Belgrade city.
//Order list by city ascending and by address number descending comparing address.number
//property as numbers.
var users:IList = usersQuery
.select("name, lastname, address.number, address.street, address.uniqueId.value")
.from(users)
.where(new Conditions()
.gt("address.number", 400).eq("address.city", "Kragujevac").OR.
lt("address.number", 400).eq("address.city", "Belgrade"))
.orderBy("address.city")
.orderBy("address.number", false, true)
.execute() as IList;
6. Usage examples – groupBy
//group users named Marija or Slavisa by city, ordere by name and then by lastname
var query:IQuery = new CollectionQuery();
var groupResults:IQueryGroupResult = query
.select("id, name, lastname, address.street") //get anonimous objects
.from(users)
.where(new Conditions()
.eq("name", "Slaviša").OR
.eq("name“,"Marija").AND.contains("lastname", "ić"))
.orderBy("name").orderBy("lastname", false) //order by name , lastname descending
.groupBy("address.city")
//group by city
.execute() as IQueryGroupResult;
//get grouped results
for each(var city:Object in groupResults.keys) //iterate through key collection
{
printUsersFromCity(key, groupResults[key] as IList); //and print collection for each key
}
if(groupResults.keys.contains("Kragujevac")) //test if there is a key
{
var kragujevcani:IList = groupResults["Kragujevac"] as IList; //print the collection
}
8. IQuery
/**
* Query interface
* @author Slavisa
*/
public interface IQuery
{
function select(value:String = null):IQuery;
//select columns
function from(coll:IList):IQuery;
//sets collection to be queried
function where(conditions:ICondition):IQuery;
//sets condition chain
function groupBy(property:String):IQuery;
//sets group keys
function orderBy(property:String, ascending:Boolean = true, numeric:Boolean = false):IQuery; //order
by given property
function limit(count:int = 100):IQuery;
//limits result’s item count
function first():Object;
//returns first or null
function last():Object;
//returns last or null
function itemAt(index:int):Object;
//returns item by the given index, or null
function execute():Object;
//actual execution, returns IList or IQueryGroupResult object
function any():Boolean;
//determines if at least one result exists
}
9. ICondition
/**
* Condition interface
* @author Slavisa
*/
public interface ICondition
{
function eq(prop:String, value:Object):ICondition;
//equal
function diff(prop:String, value:Object):ICondition;
//not equal
function contains(prop:String, value:String, caseSensitive:Boolean = true):ICondition; //contains
function lt(prop:String, value:Object):ICondition;
//lower than
function lte(prop:String, value:Object):ICondition;
//lower than or equal
function gt(prop:String, value:Object):ICondition;
//greater than
function gte(prop:String, value:Object):ICondition;
//greater than or equal
function get OR():ICondition;
function get AND():ICondition;
function get root():ICondition;
}
//OR – new condition group
//AND – new condition group
//get root condition
10. IQueryItemResult, QueryResultItem, IQueryGroupResult
/**
* Query Item result interface
* @author Slavisa
*/
public interface IQueryItemResult
{
}
/**
* Query Item result dynamic class
* Stores custom selection (anonimous object)
* @author Slavisa
*/
public dynamic class QueryResultItem
implements IQueryItemResult
{
}
/**
* Query Grouped results
* @author pokimsla
*/
public interface IQueryGroupResult
{
function get keys():ArrayCollection;
function get length():int;
}
//gets keys collection
//gets number of groups
11. QueryGroupResult
public dynamic class QueryGroupResult extends Dictionary implements IQueryGroupResult
{
//Gets array collection of group keys
public function get keys():ArrayCollection
{
var keys:ArrayCollection = new ArrayCollection();
for(var key:Object in this)
{
keys.addItem(key);
}
return keys;
}
//number of keys
public function get length():int
{
return keys.length;
}
}
12. Predicate
/**
* Predicate class
* @author Slavisa
* Used for combining multiple conditions joined with AND operator
*/
[Bindable]
public class Predicate implements ICondition
{
/* Predicate types */
public static const EQ:String = "equal";
public static const DIFF:String = "different";
public static const CONTAINS:String = "contains";
public static const LT:String = "less";
public static const GT:String = "greater";
public static const GTE:String = "greater or equal";
public static const LTE:String = "lower or equal";
/* operators */
public static const OPERATOR_OR:String = "or";
public static const OPERATOR_AND:String = "and";
public var property:String;
//property for comparison
public var value:Object;
//value to compare with
public var type:String;
//predicate type
public var conditions:Conditions; //joining conditions (group of predicates to which this predicate belongs)
public var attributes:Object;
//additional attributes
private var _root:ICondition;
//root condition
13. Predicate
public function Predicate(cond:ICondition, prop:String, val:Object, type:String, attributes:Object = null)
{
this._root = cond.root; //set the root condition
this.property = prop;
this.value = val;
this.type = type;
this.conditions = cond as Conditions;
this.conditions.addPredicate(this); //authomaticly add me to the predicate list
this.attributes = attributes;
}
//creates next predicate (not equal)
public function diff(prop:String, value:Object):ICondition
{
return createNextPredicate(prop, value, DIFF);
}
//creates next predicate (equal)
public function eq(prop:String, value:Object):ICondition
{
return createNextPredicate(prop, value, EQ);
}
…
//create next predicate for given values
private function createNextPredicate(prop:String, value:Object, type:String, attributes:Object = null):ICondition
{
var pred:Predicate = new Predicate(conditions, prop, value, type, attributes);
return pred;
}
14. Predicate
// Creates new condition with OR relation
public function get OR():ICondition
{
var condition:Conditions = new Conditions();
condition.type = OPERATOR_OR;
condition.root = root;
this.conditions.next = condition;
return condition;
}
//creates new condition with AND relation
public function get AND():ICondition
{
var condition:Conditions = new Conditions();
condition.type = OPERATOR_AND;
condition.root = root;
this.conditions.next = condition;
return condition;
}
//gets root condition
public function get root():ICondition
{
return _root;
}
}
15. Conditions
/**
* Condition contains group of predicates, used for joining multiple condition groups (predicates)
* @author Slavisa
* <br/>
* Condition chain boolean result is calculated from last to root condition group
*/
public class Conditions implements ICondition
{
private var _predicates:ArrayCollection=new ArrayCollection();
//predicate collection
private var _next:ICondition;
//next condition in a row
private var _root:Conditions;
//starting condition
public var type:String;
//starting condition shouldn't have a type property populated. EQ, OR, AND, LT...
//Condition contains group of predicates, used for joining multiple condition groups (predicates)
public function Conditions()
{
_root = this;
}
/**
* add predicates to a collection
* @param predicate
* predicates are validated in groups with ANR logical operator
*/
public function addPredicate(predicate:ICondition):void
{
_predicates.addItem(predicate);
}
16. Conditions
//creates and appends diff predicate
public function diff(prop:String, value:Object):ICondition
{
return new Predicate(this, prop, value, Predicate.DIFF);
}
//creates and appends eq predicate
public function eq(prop:String, value:Object):ICondition
{
return new Predicate(this, prop, value, Predicate.EQ);
}
//… other predicates, getters and setters
//OR condition does nothing on Conditions instance
public function get OR():ICondition
{
return this;
}
//AND condition does nothing on Conditions instance
public function get AND():ICondition
{
return this;
}
}
17. CollectionQuery
/**
* Actual collection query implementation
* @author Slavisa
*/
public class CollectionQuery implements IQuery
{
private var _coll:IList; //collection
private var _conditions:ICondition; //conditions
private var _comparatorGroups:ArrayCollection; //comparator groups built before collection iteration
private const _comparatorMap:Object = createComparatorMap(); //comparator delegates
private var _selectColumns:String = null; //select columns. If null, row items are selected
private var _limitCount:int = 0; //limited item count
private var _groupBy:String = null; //group by this property
private var _orderBy:ArrayCollection = new ArrayCollection(); //order by these properties
private var _hasGroupBy:Boolean = false;
private var _hasOrderBy:Boolean = false;
//ctor
public function CollectionQuery(coll:IList = null, selectColumns:String = null)
{
_coll = coll;
this._selectColumns = selectColumns;
}
19. CollectionQuery
//sets select properties
public function select(value:String = null):IQuery
{
_selectColumns = value;
return this;
}
//sets target collection
public function from(coll:IList):IQuery
{
_coll = coll;
return this;
}
//sets conditions root
public function where(conditions:ICondition):IQuery
{
this._conditions = conditions.root;
return this;
}
/*
Similar for :
groupBy
orderBy
limit
*/
20. CollectionQuery
public function first():Object
{
if(_hasGroupBy)
throw new Error("First() is allowed only for non-grouped results");
var result:IList = runExecution(1) as IList;
return result.length > 0 ? result[0] : null;
}
public function last():Object
{
if(_hasGroupBy)
throw new Error("Last() is allowed only for non-grouped results");
var result:IList = runExecution(1, true) as IList;
return result.length > 0 ? result[0] : null;
}
public function itemAt(index:int):Object
{
if(_hasGroupBy)
throw new Error("ItemAt() is allowed only for non-grouped results");
if(index < 0)
throw new ArgumentError("Invalid argument for itemAt method");
var result:IList = runExecution(index + 1) as IList;
return result.length > (index + 1) ? null : result[index];
}
21. CollectionQuery
public function execute():Object //interface impl
{
return runExecution(_limitCount);
}
//actual query execution
private function runExecution(limit:int = 0, reverse:Boolean = false):Object
{
implementation details excluded for insufficient space, if anyone cares send me an email to slavisapokimica@yahoo.com, I’ll
be happy to provide all you need
}
private function orderCollection(collection:ArrayCollection):void
{
if(_orderBy.length == 0)
return;
var sort:Sort = new Sort();
sort.fields = new Array();
for each(var fieldDef:Object in _orderBy)
{
var sortField:SortField = new SortField(fieldDef.field, false, !fieldDef.ascending, fieldDef.numeric);
sort.fields.push(sortField);
}
collection.sort = sort;
collection.refresh();
}
22. CollectionQuery
/**
* Creates result item
* @param item
* @return Row Item or anonymous object with properties generated from selectColumns variable
*/
private function createResultItem(item:Object):Object
{
if(_selectColumns == null) //return row item
return item;
var columns:Array = _selectColumns.split(",");
//split columns
if(columns.length == 1)
return extractPropertyValue(item, columns[0]);
//if only one property, than return it
var res:QueryResultItem = new QueryResultItem();
//anonymous dynamic object
for each(var column:String in columns)
//populate anonymous object
{
var col:String = StringUtil.trim(column);
var newPropname:String = col.replace(/[.]/g, '_');
res[newPropname] = extractPropertyValue(item, col); //set property value
}
return res;
}
23. CollectionQuery
/**
* extracts property from given item
*/
private function extractPropertyValue(item:Object, property:String):Object
{
var single:String = StringUtil.trim(property);
if(single.indexOf(".") == -1)
{
if( !item.hasOwnProperty(single) )
throw new ArgumentError("Property with name "" + single + "" does not exist!");
return item[single];
}
//recursive call when extracting complex member’s properties
return
extractPropertyValue(item[property.substring(0, property.indexOf("."))], property.substring(property.indexOf(".") + 1));
}
24. CollectionQuery
/**
* Actual filtering logic
* @param item collection item currently being validated
* @param validationGroups condition groups to be validated with
* @return Boolean
* <ul>
* <li>validation groups empty - return true</li>
* <li>single item in validation group - return predicate validation result</li>
* <li>iterate through all condition groups and its predicates and validate them all</li>
* </ul>
*/
private function filterFunction(item:Object, validationGroups:ArrayCollection):Boolean
{
if(validationGroups.length == 0)
return true;
if(validationGroups.length == 1)
return validatePredicates(item, _comparatorGroups[0].predicates);
var result:Boolean = validatePredicates(item, _comparatorGroups[0].predicates);
for (var i:int = 0; i < _comparatorGroups.length - 1; i++)
{
result = _comparatorGroups[i].operation == Predicate.OPERATOR_AND ?
result && validatePredicates(item, _comparatorGroups[i + 1].predicates) :
result || validatePredicates(item, _comparatorGroups[i + 1].predicates);
}
return result;
}
25. What’s next
Optimization
Validation
Interface expansion
“In” and “Between” conditions
Joins
Comparison between two properties
Query reset
Nested conditions
And much more…
26. Also kewl to have - code snippets I
<template autoinsert="true"
context="com.adobe.flexide.as.core.codetemplates.action_script"
deleted="false" description="Query first item by the given conditions"
enabled="true" name="query_first">
var query:IQuery = new CollectionQuery(${_collection});
var firstItem:${type} = query.where(new
Conditions().${operation:values(eq, lt, lte, gt, gte, diff,
contains)}("${prop}", ${value})).first() as ${type};
</template>
<template autoinsert="true"
context="com.adobe.flexide.as.core.codetemplates.action_script"
deleted="false" description="Order queried collection"
enabled="true" name="query_order">
var query:IQuery = new CollectionQuery(${_collection});
var orderedResults:IList = query.where(new Conditions()
.${operation:values(eq, lt, lte, gt, gte, diff, contains)}("${prop}", ${value}))
.orderBy("${orderProp}", ${ascending:values(true, false)}, ${numeric:values(false, true)})
.execute() as IList;
</template>
27. Code snippets II
<template autoinsert="true"
context="com.adobe.flexide.as.core.codetemplates.action_script"
deleted="false" description="Grouping query results"
enabled="true" name="query_group">
var query:IQuery = new
CollectionQuery(${_collection});
var groups:IQueryGroupResult = query
.where(new Conditions()
.${operation:values(eq, lt, lte, gt, gte, diff, contains)}("${prop}", ${value}))
.groupBy("${groupProperty}")
.execute() as IQueryGroupResult;
for each(var key:Object in groups.keys)
{
var groupedItems:ArrayCollection = groups[key] as ArrayCollection;
}
</template>