Skip to content. | Skip to navigation

Personal tools
Log in
Sections
You are here: Home

TalkQuintagroup is a place to engage with us on topics important to you concerning the information technology industry. Read blogs from Quintagroup employees, customers, and analysts, visit our forums and let us know what you think. The topics are broad and relevant, including Zope and Plone hosting, Zope and Plone development, Plone skins, web design and content management solutions.

Tendencies in Multi-core computing

Recently there were loud requests to remove to remove GIL in Python 3k.

They've produced healthy discussion upon the topic:

I was pointed to a good writeup upon Hardware/Software overview of tendencies in multi-core computing. It sheds some light upon progress made in the area touched by Guido in different languages/systems/platforms.

 

If we’re going to live in a world where CPUs are cheap and parallelism is the norm, then we need to think in those terms. If we need Perl/Python/Ruby/etc. programs to interact with parallelized libraries written in C/C++/Fortran, where’s the harm in spawning another process? Let the two halves of the program communicate over some IPC mechanism (sockets, or perhaps HTTP + REST). That model is well known, well tested, well-understood, widely deployed and has been shipping for decades. Plus, it is at least as language-agnostic as Parrot hopes to become. (+2 points if the solution uses JSON instead of XML.)

Fourth, there’s Patrick Logan, who rightly points out the issue simply isn’t about a multi-core future, but also a multi-node future. Some applications will run in parallel on a single machine, others will run across multiple nodes on a network, and still others will be a hybrid of both approaches. Running programs across a network of nodes is done today, with tools like MapReduce, Hadoop and their kin.

If you have a grid of dual-core machines today, and need to plan out how to best use the network of 64-core machines you will have a decade from now, here’s a very simple migration plan for you: run 32x as many processes on each node!

With that said, here is my recipe for taming the multi-core dust bunny:

  • Determine what kind of parallelism makes sense for you: none, flyweight, fine-grained or coarse grained.
  • Avoid troublesome low-level concurrency primitives wherever possible.
  • Use tools like GHC’s Nested Data Parallelism for flyweight concurrency (one program, lots of data, spread out over multiple CPUs on a single machine).
  • Use tools like GHC’s Software Transactional Memory for lightweight concurrency (many interoperating processes managing shared data on a single machine).
  • Use tools like MapReduce and friends for heavyweight concurrency (work spread out across multiple cooperating processes, running on one or many machines).
Document Actions

Plone 3.0 release - my impressions

Sharing impressions about long-awaited Plone 3.0 release.

I've recently had a possibility to work with new long-awaited release of Plone - 3.0. It was a great experience I should confess, so many new features, such nice and necessary things that previous releases lacked, just amazing amount of new functionalities. Having read some documentations about Plone 3.0 features, I've tried everything by myself. So, what impressed me the most in this much more productive Plone release...

  • Every text field is clickable, thus - editable, i.e. it became much easier and less time-consuming to make changes. It's pretty nice that I can now click on any part of a document to do a quick update, correct a spelling error or do changes to any field in events items. There is no need now to reload the whole page to make corrections — simply edit it directly by clicking on it.
  • Versioning support - one click on History green tab takes me to the full history of a document edits, as simply as that. Edit notes can be put down after every page edit so that to remind yourself what particularly have been done. Even if no notes were left, there is a nice tool Comparing to other revision that clearly displays all the changes done, in different colors for better orientation. It is possible to revert to an earlier version of the document if needed, just by clicking on the corresponding version. All the old versions are kept together, called "working copies", and can be reached any time. Isn't it amazing? No more numerous undoes!
  • Plone 3.0 comes with a a new portlet architecture, more capable and higher performance portlets engine. There is no need to shift to Zope interface any longer to set any portlets you need. Everything is done simply and easily in Plone interface. This is especially convenient when setting portlets for a particular folder, different from what are there in the parent one. On the left and right side of every page there is a link to Manage portlets page.
  • WYSIWYG editor working here is new version of Kupu - 1.4, that has lots of new features implemented.
  • Plone 3.0 checks links and references, preventing potential link breakage. In case you want to remove any item from the site, Plone checks whether this item has been linked to from somewhere else. If this turns to be a working item, a warning appears, telling that this item is used somewhere, and that items you are attempting to delete may cause links in the site to break. There is even a listing of the documents that will get a broken link. I think that is a great idea to have this feature developed and implemented, getting rid of the risk of having broken links!
  • Sharing permissions have been also changed - now it is easy to control who has access to the content, who can add, edit, view, or review it.

That's probably all I've noticed so far.. I guess working with Plone 3.0 will be a pleasure!

Document Actions

Plone Book updates - Kupu 1.4 version released

Updates in Plone Book for Content Managers because of new Kupu release.

Plone Book for Content Managers has recently been updated due to the fact that new stable version of Kupu WYSIWYG editor was released - Kupu 1.4. This new Kupu release is compatible with Plone 3.0.

Kupu 1.4 has the drawer interface substantially changed, with this new drawer interface it became easier to select folders. Clicking on the title of a folder will navigate into the folder rather than selecting it. Kupu now uses radio buttons (or checkboxes for a multi selection drawer) to indicate the selection.

So, what changes have been done?

  • In Insert Tables with Kupu chapter information about paragraph styles was added, namely paragraph styles within tables are now available. Kupu allows setting paragraph styles within table cells. Different paragraph style can be set for every separate table cell. This new feature of Kupu is nicely described here.
  • There is a new anchor drawer which lets you create tables of contents for the current document, or simply link within the document. This renewed drawer is displayed and explained in How to Create FAQ Page with Kupu. What is more, management of anchors is now advanced: Kupu 1.4 allows creating and deleting anchors without directly creating links.
  • Internal and external link drawers also support linking to anchors within the remote documents. Thus, Insert Internal Link chapter has been updated, as well as Insert External Link, that was enlarged with an example about embedding external objects to the page, i.e. some support was added for inserting Flash content.
  • Image captioning now has a customizable template. Kupu insert image properties explains how to configure default image size.
  • Kupu now has a 'Save' button available straight near the rest buttons. More information about this can be found here.
Document Actions

New Chapter in Plone Book

Plone Book for Content Managers expanding, containing more and more useful information for content managers.

Plone Book for Content Managers is continuously enlarging. We are trying to keep you close to what new appears for enlightening content manager's work.

This time the thing is about Kupu paragraph styles. In case you need to change the size of letters or their color in Kupu WYSIWYG editor and you know that preferable way to do it is with the help of new paragraph styles. But how to do it correctly, so that generated HTML code does not have its specific bad tags.

The answer to this question you may find in How to add a new style to Kupu Paragraph Styles - a newly added chapter of Plone book. This article is devoted to adding new styles to Kupu, that can definitely give much better look to your content.

Document Actions

Open/close events of KSS Opener

How to apply custom reaction to open/close events of KSS Opener. How to disable default expand/collapse behaviour.

Besides defining ":opener-init" even that initializes opener, developer has ability to extend/override open/close events:

.term:opener-init{
evt-init-elementSelector: '.details';
}

.term:opener-open{
action-client: executeCommand;
executeCommand-commandName: replaceInnerHTML;
executeCommand-commandSelector: '#status';
executeCommand-html: 'expanded';
}

.term:opener-close{
action-client: executeCommand;
executeCommand-commandName: replaceInnerHTML;
executeCommand-commandSelector: '#status';
executeCommand-html: 'collapsed';
}

and HTML for the samle is:

<hr />
<div id="status">Current status</div>
<hr />

<div class="term">
History
<div class="details">
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vestibulum
iaculis eros eu purus. Integer accumsan leo id lorem viverra vulputate.
Donec feugiat nunc molestie massa nonummy pulvinar. Proin porta pede
sit amet lectus. Duis leo urna, tempor non, condimentum condimentum,
commodo non, libero. Integer feugiat, pede at.
</div>
</div>

The resulting behaviour on page is:

The important thing is that on open and close you can have client-side or server-side actions. You can disable default expand/collapse behaviour, with preventDefault parameter:

.term:opener-open{
preventDefault: true;
}
Document Actions

Controlling Controller of KSS Opener

KSS Opener offers several configurable parameters that enables its real-world use. One of the most useful ones is ability to control where controller (small clickable handle) is injected in the page.

In the case you need your opener controller to be inserted into specific place, you can use pair of controllerPlacementSelector parameters:

dl:opener-init{
evt-init-elementSelector: '> dd';
evt-init-controllerPlacementSelector: '> dt';
}

if the above sample is applied to following HTML code:

<dl>
<dt>History</dt>
<dd>
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vestibulum
iaculis eros eu purus. Integer accumsan leo id lorem viverra vulputate.
Donec feugiat nunc molestie massa nonummy pulvinar. Proin porta pede
sit amet lectus. Duis leo urna, tempor non, condimentum condimentum,
commodo non, libero. Integer feugiat, pede at.
</dd>
</dl>

And the result is:

The whole definition list has opener assigned. Controller (clickable handle) is inserted into <dt> element, not in root of list (that can confuse some browsers). This is why I avoided dl/dt/dd example in my introduction post.

Document Actions

Introduction of KSS Opener

KSS introduced revolutionary concept into Ajax/CSS development. However out-of-the-box feature set is limited, while offering quite good extensibility. Opener is KSS component that extends KSS selectors with the set of events to enable collapsible behaviour.

After installation product offers following event:

opener-selector:opener-init {
evt-init-elementSelector: element-selector;
}

All elements that matches opener-selector will get controller that will offer expand/collapse functionality with mouse click.

Real-life example is:

.term:opener-init {
evt-init-elementSelector: '.details';
}

and having HTML code:

<div class="term">
History
<div class="details">
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vestibulum
iaculis eros eu purus. Integer accumsan leo id lorem viverra vulputate.
Donec feugiat nunc molestie massa nonummy pulvinar. Proin porta pede
sit amet lectus. Duis leo urna, tempor non, condimentum condimentum,
commodo non, libero. Integer feugiat, pede at.
</div>
</div>

 

will produce into something like:

Document Actions

History of KSS Opener

In times of Plone1 there was linear (produced with list of html elements that had different class to represent embedding) Navigation Tree in Plone. We've done several attempts to rewrite it into nested html structures, then to improve tree generator, then to make it dynamic.

In Plone1 the navigation tree, nested structure by its nature and semantics, was rendered into ugly list of <a> tags that had just "navlevelX" class that made it possible for designers to style by some extent.

Then we had proper <ul><li> nested structure that was huge step forward.

Then we had icons eliminated, that is another big step (not perfect yet, complex hover/active styles still makes life of designer hard).

And now we have Plone-3.0 knocking our doors. The most prominent feature everybody will be talking about is Ajax in Plone. Some will be mentioning KSS that made thing happen for complex CMS.

We had some efforts to address each of the items above, but none of them has matured enough to find its way into Plone code-base. And now we are going to address Ajax aspect of navigation tree.

Document Actions

Enlargement of Plone Book

New chapters in the Plone Book for Content Managers.

Plone Book for Content Managers is becoming larger and larger with more and more useful information for Content Managers working with Plone-based sites.

Kupu chapter has recently been enlarged by an article concerning Kupu Toolbar Customization, in addition to this two articles about how to insert different content types into Plone site were published: Insert External Link and Insert Tables with Kupu.

If you are still unsure what is happening with HTML code read HTML filter, so to familiarize yourself with filters available for HTML code validation.
Another new article is How to Edit Footer. And the ways of organizing a navigation tree and navigation tabs on Plone site are described in Navigation on a Plone-site.

Document Actions

Plone Book Expansion

More chapters in the Plone Book for Content Managers.

Plone Book for Content Managers is expanding! One more chapter has lately been added to this book. New article titled Insert Internal Link with Kupu Visual Editor throws some light on creation of internal links within Plone site. Clear illustrations and screenshots make the process more understandable for content managers.

With the help of Kupu Resource Types internal links to different content types may be created: these may be a simple linkable object, collection of them and even a link to the exact part of the document (if it contains anchors) can be created.

Document Actions

Leave Testimonial

go here

Our RSS Feeds

Subscribe to our RSS feeds:

rss2-icon.png Quintagroup Blog
rss2-icon.png Python Blog
rss2-icon.png Plone Products
rss2-icon.png CMS.info Blog

Plone PDF brochure

Tag Cloud