Category: Dojo Toolkit

  • What is a 2nd Generation Framework?

    What is a 2nd Generation Framework?

    Carrie Rice | August 3, 2020

    An article on 2nd Generation JavaScript Frameworks & Libraries: beyond Angular, React, and Vue! recaps Geertjan Wielenga’s talk on the evolution of JavaScript and the influence of the enterprise in recent years. Background Wielenga spoke of the pioneers of JavaScript frameworks and libraries including Dojo (1.

  • Progressively Adopting TypeScript in a Dojo Toolkit Application

    Progressively Adopting TypeScript in a Dojo Toolkit Application

    Rory Mulligan | June 3, 2020

    TypeScript has become a mainstay of modern web development libraries. Consuming functions and widgets written by a third party can be error-prone without some type of guidance. Introducing static typing to the interfaces doesn’t just reduce misuse, it has added benefits including intelligent code completion.

  • React Already Did That at All Things Open 2018

    React Already Did That at All Things Open 2018

    Dylan Schiemann | November 7, 2018

    All Things Open is a large, community-created open source conference in Raleigh, North Carolina, with nearly 4,000 attendees and 20 concurrent sessions. At this year’s event, I was invited to deliver a talk similar to one I had presented at JSConf titled “React Already Did That.

  • TypeScript 2.4: Dynamic imports and weak types

    TypeScript 2.4: Dynamic imports and weak types

    Anthony Gubler | June 28, 2017

    The TypeScript 2.4 release might be a minor update in terms of not requiring substantial changes within our open source work and customer projects, but it provides some major benefits that we are already leveraging throughout the Dojo 2 codebase.

  • TypeScript 2.3: The Sexy Default Type Argument

    TypeScript 2.3: The Sexy Default Type Argument

    Dylan Schiemann | May 9, 2017

    TypeScript 2.3 is the latest version in the quarterly release cycle from the TypeScript team. This release contains several useful additions to TypeScript which we have already started to leverage within some of our current projects.

  • Typings for dojox/gfx

    Dylan Schiemann | April 25, 2017

    dojox/gfx is Dojo 1.x’s vector graphics library, with support for SVG, Canvas, and other legacy rendering environments through a drawing API based on the semantics of SVG. This API also provides the foundation for dojox/charting. Often the biggest challenge in working with vector graphics is the large number of possible configuration settings and permutations.

  • What TypeScript can offer to Dojo 1.x

    What TypeScript can offer to Dojo 1.x

    Kit Kelly | March 29, 2017

    As many of you know, Dojo 2 is being built on TypeScript. Many of us involved in Dojo 2 believe that TypeScript brings several advantages to developing with web technologies these days.

  • Mixins and more in TypeScript 2.2

    Mixins and more in TypeScript 2.2

    Dylan Schiemann | February 22, 2017

    The TypeScript team recently announced the TypeScript 2.2 release candidate which will contain key improvements to the TypeScript language. Most notably, are the introduction of the object type and improved support for mixins and composable classes.

  • Dojo FAQ: How do I optimize a Dojo app for mobile?

    Dojo FAQ: How do I optimize a Dojo app for mobile?

    Nick Nisi | February 14, 2017

    Web applications can be deployed to many environments, including desktops, tablets, and mobile devices. We can even deploy web applications natively using a wrapper such as Apache Cordova to gain access to device features such as GPS, battery, and accelerometer data.

  • State of JavaScript 2017

    State of JavaScript 2017

    Dylan Schiemann | January 25, 2017

    It’s been two very active years since the release of ES6, and we’ve seen pretty substantial changes in how we build JavaScript applications. While some complain of fatigue, there’s never been a more exciting time to be a JavaScript engineer.

  • Exploring WebVR

    Dylan Schiemann | October 26, 2016

    This October, we delivered meetup talks on WebVR in London and Phoenix on the same day to share our early efforts in exploring WebVR with TypeScript, Dojo 2, Intern, and A-Frame.

  • Announcing the JS Foundation!

    Dylan Schiemann | October 17, 2016

    The official name of the rebranded and relaunched merging of the jQuery Foundation and the Dojo Foundation is the JS Foundation.

  • SafetyNet 2016 recap

    Dylan Schiemann | October 7, 2016

    SafetyNet is an annual conference hosted by Pulsiam and is focused on trends in software for the safety industry.

  • Improving TypeScript modules

    Dylan Schiemann | September 29, 2016

    One of the main challenges with creating modern JavaScript web applications is the relatively incomplete approach to ES modules. As an interim solution until all necessary use cases are solved, many developers create source code with ESM, and then transpile to either AMD, CJS, or UMD for easy usage within today’s browsers.

  • The long and winding road to Dojo 2

    Kit Kelly | August 24, 2016

    Recently on GitHub, someone accused Dojo 2 of being vapourware. This opinion came from a position of misinformation. I was glad the individual then engaged with the Dojo 2 project to understand where we are today. We are making swift progress and a beta is on the horizon.

  • Mixing Dojo widgets and Angular 2 components

    Anthony Gubler | August 19, 2016

    We were recently asked about options for mixing Dojo widgets and Angular 2 components into the same application: Is it possible to render an Angular 2 component and Dojo widgets on the same page? Are there any special configuration settings needed? What’s the best way for Angular 2 and Dojo to communicate and/or send messages?

  • Building Better Enterprise Web Applications Part 3: SitePen solutions

    Dylan Schiemann | June 30, 2016

    In this installment of our series on building web applications, we look at the SitePen approach to solving challenges in web application development. We employ all of the solutions described in part 2 of the blog series. Additionally, we have some overarching principles we apply to our work.

  • Building Better Enterprise Web Applications: Challenges

    Dylan Schiemann | June 28, 2016

    Web applications provide many benefits. Most organizations seek to improve the efficiency and effectiveness of business processes through the use of software. The benefits of web applications include: Simple distribution model for end users (e.g. no installation required) Instant propagation of changes Unified code base to support many platforms (desktop, tablet, mobile, etc.

  • Dojo FAQ: Is there a modern theme for Dojo?

    Dylan Schiemann | June 16, 2016

    One of the additions of the recent Dojo 1.11 release is a modern flat theme created with the Stylus preprocessor. The flat theme allows you to apply a modern, flat look and feel to existing Dojo applications.

  • Dojo is Doing it Again

    Kit Kelly | June 9, 2016

    Peter Higgins, former project lead for Dojo, gave an excellent talk at JSConf in 2013 titled “Dojo Already Did That” (which reflected a humorous meme started at the first JSConf). It was highly informative about how Dojo had already solved problems that the JavaScript community were solving again in 2013.

  • Migrating from DOH to Intern

    Dylan Schiemann | June 6, 2016

    Until a few years ago, our testing efforts with Dojo were focused on the Dojo Object Harness (DOH), a very early unit and functional testing suite.

  • Simplifying Intern tests with Command helpers

    Jason Cheatham | April 19, 2016

    Intern, via the Leadfoot WebDriver library, provides a lot of low-level control over the browsers it uses to run tests. Tests can navigate to new pages, resize the browser window, examine elements on a page, and interact with controls like inputs and buttons. Unfortunately, with all this power can come great complexity.

  • 2016 Esri DevSummit Recap

    Dylan Schiemann | March 31, 2016

    Esri, the creators of great mapping technology, hosts their DevSummit every March in Palm Springs, CA. Esri creates their popular ArcGIS for JavaScript API by leveraging the Dojo Toolkit. Esri trends Each year Esri announces a number of new features and technologies at the DevSummit, and this year was no exception.

  • Simplified Dijit Functional Testing

    Dylan Schiemann | January 13, 2016

    One of the nice features of testing with Intern and Leadfoot is the ease of authoring functional tests to mimic end-user behavior. The API for retrieving relevant DOM nodes is relatively straightforward, usually with a single line of code needed to get a reference to the relevant node.

  • dgrid 1.0 Released!

    Ken Franqueiro | January 11, 2016

    It’s been over a year since the release of dgrid 0.4, which brought about some major changes, including integration with the new dstore API. Since then, we (and others) have used it in numerous applications, and we’ve continued to refine it. Now, at long last, we’re proud to announce dgrid 1.

  • Death of Object.observe()

    Kit Kelly | November 6, 2015

    Adam Klien, software engineer at Google, announced on ESDiscuss that they were withdrawing the proposal to implement Object.observe and plan to remove it from V8 by the end of the year.

  • October jQuery Foundation board meeting

    October jQuery Foundation board meeting

    Dylan Schiemann | October 27, 2015

    In mid-October, I attended my first jQuery Foundation boarding meeting. In case you missed the news, we announced in early September that the Dojo Foundation and jQuery Foundation are merging.

  • SitePen JavaScript Support in Action

    Dylan Schiemann | September 30, 2015

    SitePen’s team of JavaScript experts provide high quality development and production support to a wide range of companies, from the Fortune 500 to small startups. Recently, we had the opportunity to assist BuyWinR, a company based in Brisbane, Australia. In this case, we went from initial inquiry to solution in less than 48 hours.

  • Recent TypeScript talks

    Dylan Schiemann | September 8, 2015

    SitePen is a huge supporter of TypeScript. It allows our developers to write using modern standards support for ES6 and some ES7 features while still targeting ES5 browsers. It also includes a type system that adds to our code’s integrity and makes it easier to write good software.

  • Dojo + Koa

    Paul Bouchon | June 19, 2015

    Dojo and its AMD loader provide outstanding tools for structuring a Web application on the client-side. However, the notion of “writing a JavaScript application” has widened in definition over the past few years with the increased popularity of Node.js. Though Dojo can be used in a Node.

  • Dojo FAQ: How can I sequence asynchronous operations?

    Dojo FAQ: How can I sequence asynchronous operations?

    Mangala SSS Khalsa | June 10, 2015

    Dojo’s Deferred module provides a convenient way of managing asynchronous operations. If you’re new to deferreds, you can get a good introduction by reading our blog post and some tutorials on Getting started with Deferreds and Dojo Deferreds and Promises.

  • Multi-Platform Distribution with TypeScript

    Ken Franqueiro | June 1, 2015

    Over the past several years, JavaScript has grown to be relevant not only for rich browser applications, but also for server and console applications. Many types of JavaScript libraries can be useful on both ends of this spectrum.

  • dstore 1.1 released

    Kris Zyp | April 17, 2015

    We have released dstore version 1.1, which features a new set of stores for local DB storage. This feature provides the ability to store data locally in browsers, and use high-performance querying capabilities through the disparate technologies of IndexedDB and WebSQL (and localStorage), through the consistent dstore interface.

  • Minimizing Dijit Instances in dgrid

    Kris Zyp | April 14, 2015

    Dijit and dgrid provide a powerful set of user interface components, allowing for fast construction of sophisticated web applications with excellent performance and interactivity. However, one particular configuration of dgrid that can impact memory and performance: heavy use of persistent Dijit editors within grid cells.

  • Memory Consumption: the Externality of Programming

    Memory Consumption: the Externality of Programming

    Kris Zyp | March 17, 2015

    Performance is a critical part of most applications. Research continually shows that good performance is essential for a good user experience. Reasonable load times, smooth animations, and responsive interaction gives user a sense of interaction and immersion, whereas slow load times frustrate users, and choppy animation and interaction quickly makes an experience awkward and disconcerting.

  • Understanding Deferreds and Promises in Dojo

    Understanding Deferreds and Promises in Dojo

    Dean Landolt | March 6, 2015

    It’s been a while since we’ve dove into Dojo’s Deferred module on the SitePen blog—the last time was back in 2010 when we introduced the promise-inspired improvements that landed with Dojo 1.5. Quite a lot has happened since on the topic, including a ground-up rewrite of Dojo’s asynchronous foundations in 1.

  • Optimized Navigation: Isomorphic Resources

    Kris Zyp | February 27, 2015

    When building web applications, developers often face the dilemma of whether to use traditional server-side rendered pages, or client-centric applications that rely on Ajax/JSON data requests, with client-side rendering of data. These two approaches also tend to dictate navigation (among other things), leading to traditional page navigation or a single-page application (perhaps with hash-based navigation).

  • From DOH to Intern: Updating Dojo core’s tests

    Dylan Schiemann | February 18, 2015

    One of the primary motivations for creating Intern was to make support for continuous integration testing much easier to achieve with JavaScript-based application development. We recently converted the vast majority of the unit tests in Dojo core from DOH to Intern, in order to streamline the process of regression testing patches for Dojo 1.x.

  • Online Dojo workshops!

    Dylan Schiemann | February 17, 2015

    We’ve offered our full line-up of public Dojo training workshops for over eight years at locations around the world.

  • Patching Modern Dojo

    Matthew Wistrand | January 28, 2015

    While it will not happen often, there may be times when you need to patch your Dojo source. Perhaps you discovered a bug and are waiting for the fix to be committed or released, or your application uses an older version of Dojo but you want to use features found in newer releases.

  • The road to Intern 3

    Colin Snover | January 22, 2015

    We normally try to schedule new minor releases of Intern about once every four to six weeks, but when we are working on a major release, there will often be a larger than usual gap in the release cycle.

  • Dojo FAQ: Testable store-backed widget

    Brandon Payton | January 14, 2015

    As object stores are frequently used in Dojo-based applications, developers often ask about a good way to utilize stores in their custom widgets. Here we present a common pattern for doing just that in a two-stage approach, starting simple.

  • Robust JavaScript Application Architecture

    Dylan Schiemann | January 8, 2015

    In October, 2014, I was coerced invited to deliver a talk at the first FullStack conference in London, a conference focused on Node.js, JavaScript and hackable electronics. The conference was an interesting cross-section of all things related to JavaScript.

  • Dojo FAQ – How do I use Bootstrap with Dijit?

    Ed Hager | August 13, 2014

    Bootstrap is a framework created by Twitter’s developers to consolidate their HTML/CSS design and widgets. Bootstrap provides a clean responsive design, but the set of widgets it includes is limited, especially when compared to what’s available in the Dijit library.

  • Mocking data with Intern

    Colin Snover | July 14, 2014

    When writing tests for an application, it’s prudent to add mock or stub data in order to allow code to be properly tested in isolation from other parts of the system. Within a normal Dojo application, there are typically three places where mocking will occur: I/O requests, stores, and module dependencies.

  • FAQ: How can I create a JSONP service-based store?

    Mangala SSS Khalsa | July 9, 2014

    Dojo’s store API is a common interface for providing data to user interface widgets, such as dgrid, Dijit Select, and Dojo Charting. The beauty of having a consistent API is that once you’ve defined an interface for a data source, that data becomes easily available to all widgets that support the store API.

  • REST tips

    REST tips

    Kris Zyp | June 24, 2014

    At SitePen, we have long been advocates for building web applications on a RESTful architecture. Over the last several years, it has been exciting to see organizations increasingly provide RESTful endpoints for the Dojo-based front-ends that we support and develop.

  • Local Database Stores

    Kris Zyp | June 17, 2014

    Modern browsers have powerful new database capabilities that enable applications to store data locally, and perform advanced indexed queries without a network connection. Applications can be built with offline support without any disruption to data interaction, including searching.

  • How can I debug Intern tests?

    Mangala SSS Khalsa | May 23, 2014

    Intern is a great test stack for writing full-featured unit and functional tests, with remote WebDriver-based testing (e.g. BrowserStack) and continuous integration (e.g. Travis CI). Debugging failing tests can be a challenge if you don’t know the most efficient techniques for troubleshooting platform-specific issues or problems with your test cases.

  • Dojo FAQ: How does selection work with dgrid?

    Mangala SSS Khalsa | May 8, 2014

    dgrid’s Selection mixin dgrid is SitePen’s lightweight, modular, and easily extensible modern grid component, designed for use with AMD and Dojo. The Selection and CellSelection mixins enable selection of rows or cells, both from mouse or keyboard actions and programmatically.

  • Intro to Intern webcast

    Intro to Intern webcast

    Dylan Schiemann | April 24, 2014

    Last month, we conducted a live webcast to provide an Introduction to Intern, SitePen’s open source testing framework.

  • Extension Events

    Extension Events

    Mangala SSS Khalsa | April 11, 2014

    When working in an event-driven environment such as the web, it is important to utilize tools that allow you to create succinct, easy-to-read code that’s extensible and flexible. One great mechanism that Dojo provides is the ability to use extension events.

  • Dojo FAQ: How do you set a default selected RadioButton?

    Mangala SSS Khalsa | February 19, 2014

    The widgets provided in Dojo’s Dijit library include not only advanced widgets not provided by HTML, but also enhanced versions of the basic HTML form elements, like <input>. Dijit’s dijit/form/RadioButton provides the same basic functionality as an HTML radio button, so let’s look at how you set one to be checked by default.

  • Creating Dojo Widgets with Inline Templates

    Creating Dojo Widgets with Inline Templates

    Nick Nisi | February 13, 2014

    Many Dojo widgets make use of client-side templating for generating the UI. Template HTML files are brought in to the page with dojo/text, parsed and converted to DOM nodes, and placed on the page, allowing our code to make substitutions, instantiate widgets within the template, and hook up events and attach points.

  • Dojo FAQ: How do I use CORS with Dojo?

    Dojo FAQ: How do I use CORS with Dojo?

    Mangala SSS Khalsa | January 15, 2014

    In web browsers that support Cross-Origin Resource Sharing (CORS) via XMLHttpRequest objects, Dojo’s XHR mechanism can make cross-domain requests out of the box.

  • A SitePen Christmas Special

    Torrey Rice | December 3, 2013

    What a great year 2013 has been! We’re feeling (collectively) like Ebenezer Scrooge in the final chapters of Charles Dickens’ A Christmas Carol – except we haven’t been jerks up ’til now and we think working at SitePen is a year-round Christmas vacation, unlike the earlier chapters wherein Scrooge forces poor Mr.

  • Building an application with xstyle

    Kris Zyp | September 10, 2013

    In this post, we want to walk through how you would get started building an application using xstyle, an extensible CSS framework. xstyle provides extensions that allows us to declaratively describe an user interface, making use of data bindings, element generation, and components, giving us an elegant means to create an application.

  • Dojo FAQ: How do you cleanly remove aspect handles?

    Dojo FAQ: How do you cleanly remove aspect handles?

    Mangala SSS Khalsa | August 19, 2013

    In addition to a simple, consistent, cross-browser interface to DOM events, dojo/on provides for very convenient clean-up – the function returns a handle with a remove method that will un-register the event listener. Clean-up concerns are not limited to DOM events, so Dojo provides the same interface for dojo/aspect and dojo/topic.

  • Dojo FAQ: dojo/domReady vs dojo/ready

    Dojo FAQ: dojo/domReady vs dojo/ready

    Matthew Maxwell | April 17, 2013

    We answer many, many, many questions on a daily basis through our Dojo training workshops, JavaScript support plans and during our customers’ development projects. We have bucket-loads of answered questions. What to do with them all… Oh? Provide you with the answers? Ok.

  • Dojo Tutorial: Feature Detection and Device Optimized Builds

    Dojo Tutorial: Feature Detection and Device Optimized Builds

    Dylan Schiemann | January 25, 2013

    As part of our great updates to the Dojo Tutorials for Dojo 1.8, we’ve been busy creating several new tutorials. Feature Detection and Device Optimized Builds Dojo 1.7+ now uses the popular has() pattern for feature detection in combination with a has()-aware build system.

  • Generating and Viewing Custom Dojo API Documentation

    Generating and Viewing Custom Dojo API Documentation

    Paul Bouchon | January 18, 2013

    When developing a JavaScript framework that others will consume, it’s hugely beneficial to provide clean, organized API documentation to accompany your codebase. With the August release of Dojo 1.8, we saw a brand new, extensible documentation parser, which is used to generate output for Dojo’s API viewer.

  • Dive Into Dijit Forms with AMD

    Mike Wilcox | November 16, 2012

    As was illustrated with our Dive Into Dijit with AMD post, the Dijit library provides an extremely powerful, flexible set of Dojo-based widgets with which you may easily enhance the look and functionality of your web application.  These widgets include drop down / popup menus, dialogs, page layouts, trees, progress bars, and form elements.

  • Dojo Tutorial: Key Events

    Dojo Tutorial: Key Events

    Dylan Schiemann | November 15, 2012

    As part of our great updates to the Dojo Tutorials for Dojo 1.8, we’ve been busy creating several new tutorials. Key Events This tutorial teaches you how to easily handle keyboard events with Dojo’s event normalization and dojo/keys implementation. Check out the Key Events tutorial for Dojo 1.8, 1.7, or 1.

  • Dojo Charting: Dive Into Theming

    Dojo Charting: Dive Into Theming

    Mike Wilcox | November 9, 2012

    The previous installment of the Dive Into Dojo series shows how easy it is to Dive Into Dojo Charting. It comes with dozens of stylish themes you can effortlessly plug into any chart.

  • Dojo Tutorial: Augmenting Objects

    Dojo Tutorial: Augmenting Objects

    Dylan Schiemann | November 8, 2012

    As part of our great updates to the Dojo Tutorials for Dojo 1.8, we’ve been busy creating several new tutorials. Augmenting Objects In JavaScript applications, you’re working with objects all day long. This tutorial covers the features found in dojo/_base/lang for augmenting your objects efficiently.

  • Dojo WebSocket with AMD

    Dojo WebSocket with AMD

    Kris Zyp | November 5, 2012

    Dojo has an API for Comet-style real-time communication based on the WebSocket API. WebSocket provides a bi-directional connection to servers that is ideal for pushing messages from a server to a client in real-time.

  • Debugging Dojo: Common Error Messages

    Matthew Maxwell | October 31, 2012

    Debugging JavaScript can be a tedious and frustrating chore. To compound the already difficult task of debugging, browser vendors each have their own style of error messaging, some of which are confusing, cryptic, or downright misleading to the untrained eye.

  • Working with Dojo and AMD in Production

    Working with Dojo and AMD in Production

    Dylan Schiemann | August 27, 2012

    In our recent post on dgrid and Dojo Nano, we showed a technique of using nested require statements in order to make use of optimized layers using the Dojo build system. As a refresher, a layer is Dojo’s terminology for a file that combines many JavaScript resources into a single file.

  • RIATeam Loves dgrid

    Dylan Schiemann | August 22, 2012

    Juan Carlos Galindo Navarro of Venezuela-based RIATeam shares his early dgrid experience with SitePen. Here’s what he had to say. SitePen: How did you learn about dgrid? RIATeam: As a lover of the progress that Dojo Toolkit provides the community, I am always on the lookout for news and features shown in the SitePen Blog.

  • Introducing dojo/request

    Introducing dojo/request

    Bryan Forbes | August 21, 2012

    As Dojo moves toward its 2.0 release, our focus has been on giving developers tools that will help them be productive in any JavaScript environment. This means creating consistent APIs across all environments. One area that has been sorely lacking, in this regard, is Dojo’s IO functions.

  • Dojo 1.8 Documentation Highlights

    Dojo 1.8 Documentation Highlights

    Dylan Schiemann | August 16, 2012

    With Wednesday’s release of Dojo 1.8, there are many exciting improvements to check out! Our top goal for this release was to significantly improve the quality of Dojo’s documentation.

  • The SitePen Insider

    The SitePen Insider

    Dylan Schiemann | August 3, 2012

    Want an easy way to keep up with SitePen efforts on Dojo, dgrid, AMD, JavaScript, and the open web? Then click the Keep In Touch button at the end of this blog and sign up now! To see what types of things you can expect, check out the July edition of the SitePen Insider! With

  • EPiServer Leverages dgrid

    Dylan Schiemann | July 26, 2012

    Linus Ekström of Stockholm-based EPiServer shares his early dgrid experience with SitePen. Here’s what he had to say. SitePen: How did you learn about dgrid? EPiServer: The Dojo website and SitePen blogs. SitePen: Why did you choose dgrid? EPiServer: The existing DojoX DataGrid was too complex to set up and extend.

  • How To Migrate a Module to AMD

    How To Migrate a Module to AMD

    Kris Zyp | July 24, 2012

    Dojo 1.7 added full support for asynchronous module loading, defined with the widely adopted asynchronous module definition (AMD) format. The new module loader and module format offer faster module loading, better performance, and wide interoperability.

  • KLP uses dgrid

    Carrie Rice | July 11, 2012

    As a SitePen customer, Øyvind Aaraas of KLP decided to try out dgrid on one of his company’s web applications.   When asked about his early experience with dgrid, here’s what he had to say! SitePen: How did you learn about dgrid? KLP: We follow the SitePen blog and learned of it there.

  • AMD for the Business-Side

    AMD for the Business-Side

    Dylan Schiemann | July 10, 2012

    You may have seen our recent blog entitled “AMD: The Definitive Source” which exhaustively explained Asynchronous Module Definition. AMD is a topic with significant technical nuances but the purpose of THIS article is to explain the value of AMD for your business.

  • AMD: The Definitive Source

    Kris Zyp | June 25, 2012

    So what is AMD? As web applications continue to grow more advanced and more heavily rely on JavaScript, there has been a growing movement towards using modules to organize code and dependencies. Modules give us a way to make clearly distinguished components and interfaces that can easily be loaded and connected to dependencies.

  • 18 things to look forward to in Dojo 1.8

    Dylan Schiemann | June 15, 2012

    After many months of work, Dojo 1.8 Beta is almost here. We expect beta to be ready for use on June 22, 2012, with the final 1.8 release due 4-6 weeks later! dojo/request We’re very excited about this release for many reasons.

  • dgrid and Dojo Nano Build

    Dylan Schiemann | June 11, 2012

    You’ve likely read that the new dgrid can be as small as 32KB gzipped when including just its minimal dependencies. However, if you use the standard settings for the Dojo Web Builder or a standard Dojo build profile, you end up with a build that’s closer to 100KB gzipped.

  • Top Ways Dojo Can Improve Your Mapping App

    Top Ways Dojo Can Improve Your Mapping App

    Angela Segovia | March 28, 2012

    The 2012 ESRI Developer Summit is attended by 1,700 developers, half are attending for the first time and thirty percent are from international locations! Dylan continues to mingle with like-minded Dojo enthusiasts from around the world, including people from the US, Canada, UAE, Japan, England, Germany, France, Switzerland, Sweden, Australia, New Zealand, and the Netherlands! 

  • Eleven Trends for 2012: The Year of Dojo

    Eleven Trends for 2012: The Year of Dojo

    Angela Segovia | January 30, 2012

    Most 2012 trend lists include 12 trends. (Get it?  12 in ’12.  Of course you do.).  Because we are not fond of adding unnecessary or filler content (read code), Dylan has come up with 11 trends for 2012. 1.  Mobile Mobile will gain even more momentum in 2012.

  • The Year of Dojo is Here!

    The Year of Dojo is Here!

    Angela Segovia | January 17, 2012

    Welcome to 2012 – The Year of Dojo!  We are expecting an amazing year! Make SitePen your one stop shop for all of your web application needs; Dojo workshops, JavaScript support and web app development.  Together, with SitePen, you will meet your 2012 goals!  When you’re happy, so are we.

  • Touching and Gesturing on iPhone, Android, and More

    Touching and Gesturing on iPhone, Android, and More

    Colin Snover | December 7, 2011

    One of the most important parts of creating an effective and intuitive user interface on touch-enabled smartphones has nothing to do with visual appearance—instead, it has to do with creating an interface that properly responds to user input based on touch. For Web applications, this means replacing mouse events with touch events. In Dojo 1.

  • Dojo Drag’n’Drop Redux

    Dojo Drag’n’Drop Redux

    Colin Snover | December 5, 2011

    dojo/dnd is one of Dojo’s core APIs and is designed to manage the process of dragging and dropping items between two or more containers. It offers advanced features like multiple selections, item acceptance filtering on drop targets, and other behavioral tweaks.

  • Rich Web Experience 2011 – And so it was!

    Rich Web Experience 2011 – And so it was!

    Angela Segovia | December 2, 2011

    SitePen’s Dylan Schiemann delivered the last of his three Rich Web Experience 2011 presentations yesterday, Never Bet Against the Open Web. Dylan had this to say about his time at #RWX2011: The level of interest in AMD, object stores, and mobile is impressive.

We use cookies to ensure that we give you the best experience on our website. If you continue to use this site we will assume that you are happy with it.Privacy Policy