Dust

Download as pptx, pdf

0 likes133 views

Dust is a JavaScript templating engine that allows templates to be compiled to JavaScript for fast rendering on both the server and client side. It supports hierarchical data structures through context and path notation. Templates can reference data within the current context or higher contexts. Explicit context and parameters can also be passed to templates. Dust works anywhere JavaScript works and has no other dependencies.

▪ Dust is a Javascript templating
engine
▪ Designed to run asynchronously
on both the server and the browser
▪ Not truly Logic Less
▪ Dust works where Javascript
works

Advantages
–Template is compiled to Javascript
–Available on client side, so faster rendering and less network
load
–Dust can precompile your templates , or dynamically load
them
–Dust works where Javascript works, No other dependencies

Example
// Template
Hello {name}! You have {count} new messages.
// Data
{
"name": "Mick",
"count": 30
}
// Result
Hello Mick! You Have 30 new messages.

Section and context
–A simple key reference will look first in the current context
and, if not found, search all higher levels up to the root looking
for the name
–It will not search downward
–{#A}{anotherName}{/A} outputs "rootName"

Paths
–If we want to work only with the data within a specific context,
we can use dotted notation (called paths) to define the context
–{A.B.name} will output "Bob"
–Path notation allows you to reference a path outside a current
context

Paths
// Template
{#A.B}
Name in B = {name}, Name in A =
{A.name}
{/A.B}
// Data
{
"name": "root",
"anotherName": "root2",
"A":{
"name":"Albert",
"B":{
"name":"Bob"
}
}
}
//Result
Name in B = Bob, name in A = Albert

Explicit Context Setting
// Template
{#A:A2}
{#names}
{.} - {type}
{/names}
{/A}
// Data
{
"A":
{ names :
["Albert", "Alan"]
},
"A2":{
"type":"Student"
}
}

Passing Parameters
{#A.B foo=A.name bar=anotherName
myName="shashi"}
{foo} {name} {bar} {me}
{/A.B}

References
http://www.dustjs.com/
https://github.com/linkedin/dustjs

The document discusses using CouchDB and Rails for cloud computing. Some key points: - CouchDB is a document-oriented database that can be queried using JavaScript and offers incremental replication. It stores data as JSON documents and uses HTTP as its protocol. - The speaker demonstrates parsing a Bible database into CouchDB and creating views to query verses. - A Rails app is built on top with CouchDB as the backend to provide a frontend for querying the Bible data. - Heroku and Slicehost are discussed as options for hosting the application in the cloud. Scaling is addressed through replication and proxying.

Артем Сильчук - Respond in 60ms. Extremal optimization with reinventing a wheelLEDC 2016

��

This document discusses various techniques for optimizing page load times in Drupal, including disabling unused modules, enabling caching, using a CDN, and investigating slow queries. It describes how the Authcache module works by caching rendered HTML for logged-in users. Various stages of Drupal's bootstrap process are outlined and their timings shown. Custom "thin applications" are discussed as an alternative approach, but they have disadvantages around maintainability, security and development speed compared to Drupal. Finally, opportunities for optimizing Drupal's rendering and bootstrap processes are suggested.

MongoDb - Details on the POCAmardeep Vishwakarma

��

MongoDB is a document-oriented, schema-free, scalable, high-performance, open-source database that bridges the gap between key-value stores and traditional relational databases. MongoDB uses a document-oriented data model where data is stored in documents that map to programming language data types, which reduces the need for joins. It provides high performance through an absence of joins and support for indexing of embedded documents and arrays.

Starting with MongoDBCesar Martinez

��

This document provides an overview and introduction to MongoDB, including: - MongoDB is a non-relational, document-oriented database with dynamic schemas and stores data in JSON-like documents rather than tables. - It is well suited for prototyping, quick development refactoring, non-relational data, log data and metadata. Related data and needing joins may not be the best use case. - Installation and configuration process varies by operating system but involves downloading packages and creating a data directory with correct permissions. - The MongoDB command line interface provides commands to view and manage databases, collections, documents and perform basic operations like create, read, update and delete.

vOfficeware Brown Bag - NOSQLapexdodge

��

The document discusses schema-less databases and how they differ from traditional databases. Schema-less databases like MongoDB, CouchDB, and Cassandra use documents rather than tables and fields. Documents can vary in structure and there are no enforced relationships between data like with schemas. This flexibility allows for easier development of certain types of applications, like a campaign management system, though it comes with some disadvantages compared to SQL databases.

MongoDB NYC PythonMike Dirolf

��

The document describes MongoDB, an open-source, high-performance, schema-free, document-oriented database that addresses some shortcomings of relational databases like scalability and flexibility. It discusses some key MongoDB concepts like documents, collections, indexing, embedding data, and querying capabilities. An example blog application is provided to illustrate common operations like creating, retrieving, and counting documents in a MongoDB deployment using PyMongo.

U C2007 My S Q L Performance Cookbookguestae36d0

��

The document summarizes techniques for optimizing MySQL performance presented by Peter Zaitsev. Some key points include: - Ways to kill runaway queries including timeouts and monitoring process lists. - Methods for limiting query concurrency like using locks to control the number of concurrent queries. - Designing schemas and queries with performance in mind, such as avoiding expensive operations like DISTINCT, GROUP BY, and COUNT(*). - Techniques for backups like using table locks and storage snapshots to get fast cross-storage engine backups.

Data presentation with dust js technologies backing linkedinRuhaim Izmeth

��

The document discusses the use of Dust.js, a JavaScript templating engine, for separating presentation from logic in web development, highlighting its adoption by LinkedIn. It outlines the advantages, such as speed, caching, and localization support, as well as disadvantages like compatibility issues and SEO limitations. Additionally, it mentions future enhancements like deferred rendering with a tool named Fizzy introduced in 2013.

Skillwise Dust JS TemplateSkillwise Group

��

Dust JS is a JavaScript templating engine that separates presentation from logic. It allows for cleaner coding through logic-less templates and features like blocks, partials, and helpers. Dust runs on both client-side and server-side. Popular companies like LinkedIn and PayPal use Dust due to its active development, battle testing, and community support. Dust's data referencing allows accessing data outside of loops through features like {@eq} and {@size}. Templates are populated with JSON data through a three step process: 1) Dust templates for markup, 2) JSON data, 3) JavaScript rendering engine.

Velocity dustVeena Basavaraj

��

This document discusses LinkedIn's use of the Dust templating library to improve web performance and developer velocity. It describes how LinkedIn transitioned to serving JSON and using Dust templates to render pages, which unified their applications and platforms. This approach improved performance by enabling client-side rendering, reduced payload sizes, and increased developer productivity through rapid prototyping. The document also details how LinkedIn measures web performance using real user monitoring and describes optimizations made to Dust templates and payloads to improve page load times for slow browsers and regions.

Leaving jsps in the dustVeena Basavaraj

��

Leaving jsps in the dust discusses moving a front-end infrastructure from server-side Java technologies like Grails and JRuby to a client-side JavaScript approach using Node.js. This improves developer velocity and site speed by generating static pages and caching assets. Dust.js is used for simple JavaScript templates that are precompiled and optimized for client-side rendering. Server-side preprocessing of Dust templates allows for localization, formatting and A/B testing logic to be handled on the server.

Bridging the Gap with Dust.jsJeff Harrell

��

Jeff Harrell discusses PayPal's adoption of JavaScript templating to enhance design iteration speed, separate UI concerns, and bridge technology gaps within its application stacks. The implementation of Dust templates in place of JSP and XSL is aimed at improving development efficiency and fostering a shared codebase across Node.js, Java, and C++. By integrating modern JavaScript environments, PayPal seeks to modernize its legacy systems while maintaining a quick prototyping capability.

Dust.jsYevgeniy Brikman

��

The document discusses LinkedIn's adoption of the Dust templating language in 2011. Some key points: - LinkedIn needed a unified view layer as different teams were using different templating technologies like JSP, GSP, ERB. - They evaluated 26 templating options and selected Dust as it best met their criteria like performance, i18n support, and being logic-less. - Dust templates are compiled to JavaScript for client-side rendering and to Java for server-side rendering (SSR) through Google's V8 engine, allowing templates to work on both client and server. - SSR addresses challenges like SEO, supporting clients without JavaScript, and i18n by rendering

Dust[in]Veena Basavaraj

��

This document appears to be notes from a discussion between LinkedIn employees about the Dust templating engine. It mentions that LinkedIn forked Dust and built extensions to add template logic and helpers. Key helpers mentioned include @eq, @select, @lt, @lix for A/B testing, and @url for URL generation. It also discusses LinkedIn's use of Dust for rendering templates on the server for SEO, emails, and pages like profiles, search, and influencers recommendations.

Dust

1. Introduction To Dust

2. What is DUST

3. ▪ Dust is a Javascript templating engine ▪ Designed to run asynchronously on both the server and the browser ▪ Not truly Logic Less ▪ Dust works where Javascript works

4. Advantages –Template is compiled to Javascript –Available on client side, so faster rendering and less network load –Dust can precompile your templates , or dynamically load them –Dust works where Javascript works, No other dependencies

5. Example // Template Hello {name}! You have {count} new messages. // Data { "name": "Mick", "count": 30 } // Result Hello Mick! You Have 30 new messages.

6. Section and context –A simple key reference will look first in the current context and, if not found, search all higher levels up to the root looking for the name –It will not search downward –{#A}{anotherName}{/A} outputs "rootName"

7. Paths –If we want to work only with the data within a specific context, we can use dotted notation (called paths) to define the context –{A.B.name} will output "Bob" –Path notation allows you to reference a path outside a current context

8. Paths // Template {#A.B} Name in B = {name}, Name in A = {A.name} {/A.B} // Data { "name": "root", "anotherName": "root2", "A":{ "name":"Albert", "B":{ "name":"Bob" } } } //Result Name in B = Bob, name in A = Albert

9. Explicit Context Setting // Template {#A:A2} {#names} {.} - {type} {/names} {/A} // Data { "A": { names : ["Albert", "Alan"] }, "A2":{ "type":"Student" } }

10. Passing Parameters {#A.B foo=A.name bar=anotherName myName="shashi"} {foo} {name} {bar} {me} {/A.B}

11. References http://www.dustjs.com/ https://github.com/linkedin/dustjs

�ݺ�ߣ

Dust

Recommended

More Related Content

Similar to Dust (7)

Dust