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.x), Mootools, Extjs, jQuery, and YUI which were among the

  • 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. Dojo Toolkit is one of the earliest libraries to facilitate

  • 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.” The session itself is not actually about React, but

  • 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. Let’s take a closer look!

  • 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. TypeScript

  • 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. Features like structural typing and interfaces help us write code that is less prone to errors as well as being able to express

  • Functional reactive programming and Observables in JavaScript, TypeScript, and Dojo 2

    Functional reactive programming and Observables in JavaScript, TypeScript, and Dojo 2

    Dylan Schiemann | February 27, 2017

    Functional programming and reactive programming principles are not new to JavaScript, but their adoption has recently become widespread across most modern frameworks and toolkits. The ease of using these approaches has improved as we’ve finally seen the decline of legacy browsers, and as we’ve seen the introduction of functional and reactive paradigms within ES6 and

  • 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. However, it is not always optimal to package our application into a universal layer

  • 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. So with the new year upon us, it’s time to look at where we are,

  • TypeScript 2.1 Goodness Coming Soon to Dojo 2!

    Dylan Schiemann | December 14, 2016

    The TypeScript team has just announced the release of TypeScript 2.1 which contains several long-awaited features (pun intended) for Dojo 2. Rather than repeating the excellent summary from the TypeScript team, we’ll look at how a few of these features will improve Dojo 2!

  • 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. What is WebVR? WebVR is an experimental JavaScript API that provides access to Virtual Reality (VR) devices, such as the Oculus Rift, HTC Vive,

  • 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. SitePen is excited to be a member of this new organization!

  • 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. Because of our expertise in shaping the modern web and our ongoing work with Pulsiam’s application development efforts, I was invited to deliver a keynote about the past, present, and future of the web, as this

  • 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. As we work

  • TypeScript 2.0 Awesomeness

    Dylan Schiemann | September 1, 2016

    Over the past few years, TypeScript has iterated and greatly improved developer ergonomics. With our efforts on Dojo 2, we’ve been very excited about many of the features and improvements made, including several key improvements that have landed for TypeScript 2, which is currently in beta release!

  • 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. It has taken Dojo 2 a long

  • 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. The right architecture and an emphasis on

  • Building Better Enterprise Web Applications Part 2: Solutions

    Dylan Schiemann | June 29, 2016

    While there are many challenges today with building web applications, there are also many options to address the issues we face with technology, process, and people, allowing us to reap the benefits of the web as an application platform. Technology solutions While many of the challenges with today’s web applications come from the vast array of

  • 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.) Easy piloting

  • 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. Even 3 years later, there

  • 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. Developed by the Dojo Toolkit community nearly ten years ago, DOH’s main purpose was to provide functionality for unit testing JavaScript functions and custom widgets in a cross-browser compatible

  • 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. Many testing tasks

  • 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. They have really improved

  • 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. When we started writing tests for Dijit,

  • 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.0!

  • 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. While I was never sold on the approach of this API, I assumed long ago it was the API that would be used for

  • 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. The primary goal of this open source foundation union is to encourage greater collaboration between open source web projects, and also provide a home for

  • 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. To

  • 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. As noted in the Dojo 2 vision,

  • Simple Model-View synchronization with dstore and Dijit

    Dylan Schiemann | July 28, 2015

    Nearly every sufficiently large web application looks for a mechanism to efficiently synchronize or bind data between the Model and the View. There are many large scale application frameworks and approaches focused on this, whether the binding is one-directional like React, or follows other approaches such as those seen with AmpersandJS, Angular, Aurelia, Backbone, Ember,

  • 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.js environment with the AMD module pattern, other key

  • 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. There are a few features of the then method on a promise that are

  • 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. Dojo 2 is no exception, and one of our goals is therefore to make it as easily

  • 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. Complex queries can be formulated in your

  • We’re Contributing to Dojo 2!

    Torrey Rice | April 16, 2015

    At the end of 2014, we looked ahead to determine where to focus SitePen’s open source efforts in the coming year. After our successful contributions to dgrid and the new dstore package, it became increasingly clear that contributing to the future of Dojo was where our team would have the biggest impact and the most

  • 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. The dgrid’s Editor plugin makes it very easy to leverage

  • 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.8+, so it’s about time

  • 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. This

  • 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. Attendee response is always positive because people love that our instructors are actual, web developers themselves! “Lively”, “engaging” and “wow” are just a few words that describe our team of instructors; JavaScript and Dojo experts who

  • 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. Dojo’s AMD

  • 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. In order to keep our users informed of what’s going on, we wanted to write about

  • Dojo FAQ: How can I handle recoverable server errors transparently with dojo/request?

    Mangala SSS Khalsa | January 21, 2015

    A common scenario with web applications is accessing protected resources, which require authentication with the server in order to proceed. A common flow is as follows: User opens web site Web site presents authentication screen User enters credentials Web site presents protected information Authentication workflows This is simple enough to begin with, but what happens

  • 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. A store-based widget needs two things at minimum: a way to set the store and a

  • 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. A topic that’s been on my mind lately is how to choose a robust architecture that’s

  • 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. The CSS/HTML theme can be used independently of the widgets, but how do you use

  • 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. We’re going

  • Dojo FAQ: Dynamically loading CSS

    Paul Bouchon | July 2, 2014

    In large JavaScript applications, it can be beneficial to dynamically load CSS stylesheets. For example, if a certain JavaScript widget, such as a complex grid, uses a large standalone stylesheet for its display aesthetics, it would be optimal to only load this stylesheet if the widget is in use, rather than always including the CSS

  • 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. A well-designed REST backend can be a excellent foundation for manageable, scalable applications, that will

  • 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. However, these database capabilities have traditionally been difficult to use across browsers since Safari only supports WebSQL

  • 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. Adding selection functionality to a grid is a simple as mixing in the desired module:

  • 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. Our webcast covered: An overview of Intern’s numerous functional and unit testing features and capabilities Mocking objects and data Injecting dependencies Troubleshooting Future direction of Intern While it’s too late to attend this webcast and heckle us

  • 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. What Are They? Extension events are functions that are passed in lieu of an

  • Dojo FAQ: What is the difference between dojo/on and dojo/aspect?

    Nick Nisi | March 26, 2014

    dojo/on and dojo/aspect are two APIs that appear to do similar jobs but actually serve two different purposes. dojo/on is used to setup event listeners for DOM nodes and event-emitting objects. dojo/aspect provides Aspect Oriented Programming facilities so functionality can be run before, after, or around a method call and can even manipulate the input

  • 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. However, we may

  • 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. Cratchit to work

  • 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. In this tutorial,

  • 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. Here it is! Each week we’ll answer a commonly asked question about

  • 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. While it is easy enough to write feature detection tests with

  • 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. Generating documentation for any project and serving up

  • 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.  When

  • 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.6! Want to see a

  • 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. But what if you want your charts to match your website’s design or business’ branding? No worries: Dojo’s charting library allows you

  • 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. Without further ado, check out the Augmenting Objects tutorial for

  • 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. Dojo’s dojox/socket module provides access to this API with automated fallback to HTTP-based long-polling for browsers (or servers) that do not

  • 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. Through the delivery of our Dojo workshops, we’ve observed a number of common mistakes that

  • 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. This improves the performance

  • 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. We’ve always provided developers with a way to

  • 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. SitePen proudly contributed in the following areas: Helped make many of the more than 500 fixes to our documentation based on community feedback (thank you!) Helped

  • 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. We wanted grid/list functionality

  • 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. However, for many, upgrading from the legacy Dojo module format to AMD is daunting, since the new module formats look

  • Now Supporting all Major Toolkits!

    Now Supporting all Major Toolkits!

    Dylan Schiemann | July 19, 2012

    We have been providing JavaScript and Dojo support to freelancers, start-ups and Fortune 500 companies for nearly a decade. As we intently watch enterprise organizations everywhere begin to roll out AMD (read about why AMD matters) and the associated code improvements, we are thrilled with the industry’s direction toward toolkit interoperability! Why? Because! Our masterful

  • 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. SitePen: Why did

  • 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 is an emerging defacto standard for efficiently developing modular JavaScript applications and

  • 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. The AMD

  • 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. For the new features, I’m most excited about the work led by Bryan

  • Feature Detection and Device Optimized Builds

    Feature Detection and Device Optimized Builds

    Kris Zyp | June 12, 2012

    The mobile device revolution has placed new demands on web applications. Mobile devices generally have lower bandwidth and lower CPU capacity, forcing us to avoid large complex code. Fortunately, the mobile space has a greater percentage of users running modern browsers than on desktops, so it is feasible to write similar applications with much less

  • 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. So, how do you actually get

  • Only two stops left! Phoenix Mobile Festival and IBM Impact 2012.

    Angela Segovia | April 16, 2012

    Over the last few weeks, Dylan has given talks across the western United States and Europe and we’ve tracked his every move on our blog. Dylan will finish his trip with stops in Tempe, AZ and Las Vegas, Nevada. Phoenix Mobile Festival.  Tempe, AZ.  April 21. Speaking at the inaugural Phoenix Mobile Festival, Dylan will

  • 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.  There’s no doubt we will see many

  • 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. Learn Dojo – We are dedicated

  • 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.7,

  • 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. Let’s learn how to use it! This is an updated version of the original

  • 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. And the excitement around the potential of xstyle and put-selector was also

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