Blog
I was asked to talk about advanced JavaScript techniques at the last
monthly meeting of ClubAJAX — monthly get-together of
Dallas-area JavaScript programmers. Instead I ended up talking about
leveraging cool JavaScript features to implement well-known programming
techniques and paradigms: OOP,
AOP,
FP, and
so on.
[Read more]
[See details]
My presentation at ClubAJAX got off to a rocky start: I was let in the building 40 minutes after I was supposed to start the presentation. Everybody waited patiently. Thank you guys! As promised I publish slides along with relevant links (I had to skip most of planned demos).
[Read more]
Time to time I sync my blog software to the Django trunk and
introduce small enhancements. Some of them visible to my readers,
some of them are just for me. This time after reading Simon
Willison's post on rev=canonical I decided to add short URLs to my blog as well. This is a convention
to provide custom short URLs managing the mapping on your own web
site. In my opinion the idea is very cool.
[Read more]
Steve Yegge is one of the bloggers I read almost religiously. His posts are full of
insights on the software development topics and in general, and he is
always ready with an amusing anecdote from his rich life. His last post
Have you ever legalized marijuana? didn't disappoint either. The author explains "Shit's Easy Syndrome" (a
difficult topic even for seasoned bloggers) in a gay romp that takes a
reader from a light-hearted review of a book on "bugs in our mental
software" to hapless VPs to many technical difficulties of legalizing a psychoactive drug extracted from the plant Cannabis sativa. But the most entertaining and educating part is the incredible story of the author's life.
[Read more]
Explaining some dark corners of JavaScript, browsers, or Dojo for the 100th time I realized that I
already did it on numerous occasions, and some of my answers are published on public web sites. So I decided to round up the most general ones
I posted on StackOverflow and publish links to them here for a future reference.
[Read more]
As you may know today Google released Friend Connect.
I decided to give it a try. It took about 20 minutes to set up my blog
with 4 gadgets: Members, Sign In, Rate/Review, and Wall/Comments. It
took about 30 minutes to separate the skin from all these widgets, and
set up the Canvas so users can see gadgets in a separate window, if
they want to.
[Read more]
In the previous post we explored “array
extras” and how they can help us to write concise yet performant
and clean code. In this post we take a look at generalizing recursive
algorithms with recursion combinators — high-level functions that
encapsulate all boilerplate code needed to set up the recursion. These functions were added to dojox.lang.functional and will be officially released with Dojo 1.2.
In general the recursion is a form of
iterative problem solving in the same category as loops. There are
two major natural sources of recursive algorithms: recursive data
structures (lists, trees, and so on), and recursive definitions
(factorial, Fibonacci numbers, the GCD algorithm, etc.). The
recursion plays a prominent role in the functional programming (FP),
and one of the best articles on this topic is “Recursion Theory and
Joy” by Manfred von Thun, the creator of Joy (a purely functional
programming language with Forth-like syntax). Manfred's article
explains intricacies of recursion including the venerable Y
combinator, recursion combinators in general, and introduces a
practical set of recursion combinators, which will guide us in
this post.
[Read more]
If we look at the history of computer programming languages, we can see
that practically all new programming methodologies were about one
thing: taming complexity. The anarchy of earlier days of procedural programming (example: Fortran) gave way to structured programming (Pascal), which was refined with modular programming (Modula), and was reformulated when object-oriented programing went mainstream (C++, and much later Java). And it stopped there. The
focus shifted to different branches of computer programming, namely to
functional programming, and, to a lesser degree, logical programming.
The only major development in this branch was the rise of aspect-oriented programming (AOP) paradigm. Let's take a look at AOP in our favorite language:
JavaScript, and how Dojo helps the language with dojox.lang.aspect
package.
[Read more]
[Read more]
As you all know by now Dojo 1.1 was released in the wild. You can get a lot of useful links and info from James Burke's post on Dojo 1.1, but let me tell you why you should be excited:
- Dojo 1.1 is the first official release, which contains dojox.lang.functional. It was available in the trunk for awhile, but now you can use it without deploying Dojo courtesy of AOL CDN. I am psyched about it!
- Improvements in animation, animation helpers for dojox.gfx. A good examples of animation in action is dojo.moj.oe by Pete Higgins (internals were detailed in the blog post, and in the great Dojo Campus article), an example for dojox.gfx animation is the career test. Finally we are getting to the point when we create attractive GUI cross-platform without plugins.
- The Dojo API tool. As you know Dojo is essentially a federation of JavaScript modules. Every module can be a library on its own. Now we have a simple way to navigate them, read developer's documentation without diving into the source, and understand the API. When comments will be added to it shortly, you can add your own notes, and ask pointed questions. Developers are getting an essential tool to see how their modules are documented, what questions are raised most frequently, and so on. This tool will help us to document Dojo even better. All in all Neil Roberts and Tom Trenka did a great job!
- Numerous improvements and bug fixes — this is always good. The API is mainly unchanged, so the migration to Dojo 1.1 should be a no-brainer for most users.
I am pleased to see that social aspects of Dojo are getting attention: the redesigned Dojo web site, the Dojo API tool, Dojo Campus is always fun, Dojo forums are active, even the Dojo archive is now easy to navigate!
What's next? The next target is Dojo 1.2, which will see a lot of enhancements. In my crystal ball I can see myself diligently working on Charting with other volunteers. New graphics improvements and new dojox.lang modules are planned too. While we are busy pushing for 1.2, the maintenance release (Dojo 1.1.1) is planned as well.
[See details]
What makes JavaScript so different from other languages? Is it its
dynamic nature? Its prototype-based funky inheritance? No. The most
unusual thing for newcomers is how JavaScript programs handle the
workflow. The program looks like a bowl of spaghetti. There is no start
or end of the program. What we have here is a bunch of functions, which
are called in response to some external events. In most cases we have
no way to predict the order of these events. And we know that all
callbacks are called from a single thread. Of course we know that it is
not a nature of JavaScript but rather a limitation imposed by a
specific container of JavaScript programs — web browsers. Majority of
JavaScript code is written for browsers and now we have a perception
problem. But let's dig deeper to understand the problem better.
[Read more]
I just finished the first cut of the dojo.dnd 1.1 technical documentation. Let me use this post to remind you about the dojox.gfx 1.1 documentation. I hope I satisfied the curiosity of many developers, but the ultimate proof will be the number of simple questions on Dojo Forum. Let's hope it will go down. And don't forget that the Dojo Book has a DnD chapter too.
Both documents are hosted on Google Docs, and are "live" documents — as soon as I update the document it is updated for you too. I intend to update them on regular basis to track the current version.
If you found any mistakes, typos, omissions, or just unclear wording, please let me know. If you know a good trick to do with those packages, do not hesitate to share it on Dojo Campus as an article or a "cookie".
My next documentation goal is dojox.charting. Stay tuned!
[See details]
F/OSS is a phenomenon of the modern life. But what makes it successful? Ben Laurie is convinced that Open Source Is Just Economics.
I beg to differ. Yes, it does make sense for several companies to gang
together and develop something jointly. And they did it for years
without the open source. Not always successfully, but they did it. For
example, IBM has cooperated with Microsoft on OS/2 back in the days,
and there are more examples. What makes OSS so special? Ben's post has
links to other possible reasons. But I think I know the answer: global
meritocracy in informal communities— this is the mythical secret ingredient, which holds the whole system together.
[Read more]
Everybody knows that JavaScript is a
multi-paradigm language, and it can be used to program functionally.
Practically all functional idioms can be used directly: higher-order
functions, recursion, closures, and so on. The recent resurgence of
Functional Programming (FP) brings functional methodologies in the
mainstream. FP fundamentals gave us a lot of powerful idioms:
iterative functions, which can replace loops, list processing in
general, function manipulations, and many other things, which helps
us to keep our code small yet concise, more powerful, and more fun.
Let's take a look at how Dojo helps to leverage the functional
paradigm in the Core, and in the extended DojoX package
(dojox.lang.functional).
[Read more]