Blog

February 11, 2016 by chrissy

Introducing Association Engine

Association Engine, previously known as Big Purple Suite, has been released into the wild. This suite of plugins for WordPress leverages Abila’s netFORUM xWeb, seamlessly connecting your iWeb back-office and website. Member self-management, membership join/renew, Single Sign On (SSO), an integrated cart, event registration, and Vantiv and Sage payment gateway integration are just a few of the features of this powerful set of tools. Learn more at the new Association Engine web site.

Want a demo? Contact us, and we will be happy to give you a tour.

Your Name*
First Last
Your Email*
Message*
Please include your phone number if you would like us to call you.
- Add me to your mailing list

February 23, 2015 by chrissy

Pongos Interactive Launches the Big Purple Suite of WordPress Plugins on the Abila Marketplace for Nonprofits and Associations

Users can now combine the ease of use and visual flexibility of WordPress with Abila netFORUM’s administrative power

Crofton, Md. February 23, 2015 – Pongos Interactive today announced it has launched the Big Purple Suite of WordPress plugins on the Abila Marketplace, designed to provide nonprofits and associations with quick and easy access to tools and services to enhance their existing Abila products.

Pongos Interactive’s Big Purple Suite of WordPress plugins lets you combine the ease of use and visual flexibility of WordPress with Abila netFORUM’s administrative power for optimal overall user experience.

“We’re very excited to offer WordPress users a way to provide a seamless Abila netFORUM user experience to their members,” said Chrissy Rey. “The Big Purple Suite of WordPress plugins will allow them to engage their members in new ways, using the familiar WordPress dashboard.”

Big Purple Pro for Abila netFORUM Pro^TM Key Features:

Account creation, login and password reset
Single-Sign On (SSO)
Easy integration with third party software
Member self-service dashboard for membership, events, products & personal profile
Custom post-login redirects to WordPress pages or 3rd Party integrations
An eWeb alternative for all but financial transaction screens

Big Purple Enterprise for Abila netFORUM Enterprise^TM Key Features:

A flexible, modular, eWeb alternative
Plug financial leaks by enforcing business rules using Big Purple’s custom permissions logic.
Increase donations with page-targeted campaigns.
Reduce member support calls with engaging user interfaces

“We’re excited to have Pongos Interactive be a part of the Abila Marketplace,” said Céline Felan, Program Manager for Abila. “Our partners are such an important part of our success. They offer key products and services that truly help our customers by extending the value of our nonprofit and association solutions.”

Abila Marketplace

The Abila Marketplace is a rich, interactive, engaging platform that showcases add-ons, customizations, and services offered by Abila’s Partner Ecosystem for its award-winning products and solutions. Customers and prospective customers can quickly and easily navigate the site to find the information they need, including descriptions, demos, pricing, ratings/reviews, and contact information. The Abila Marketplace is a first-of-its-kind designed specifically for nonprofits and associations.

About Pongos Interactive

Since 2008, Pongos Interactive has been creating user-centric digital presences for non-profits, associations, and businesses of all sizes. The Pongos team creates quality WordPress themes, plugins, communities, and integrations. Our talented developers also build mobile apps, games, and interactive elements for web, desktop, and devices. We love to empower our clients, and can provide training on just about everything we do. Learn more at www.purplepongos.com and www.pongos.com.

About Abila

Abila is the leading provider of software and services to associations and nonprofit organizations that help them make better decisions, execute with greater precision, increase engagement, and generate more revenue. With Abila solutions, association and nonprofit professionals can use data and personal insight to make better financial and strategic decisions, enhance member and donor engagement and value, operate more efficiently and effectively, and increase revenue to better activate their mission. Abila combines decades of industry insight with technology know-how to serve more than 8,000 customers across North America. For more information, please visit www.abila.com.

Media Contact:
Chrissy Rey
chrissy@pongos.com
(855) GOPONGO [467-6646] (301) 789-1815 ext. 700

December 1, 2013 by Randy Sandberg

Testing with Your Users in Mind

Editor’s note: Randy Sandberg is Pongos Interactive’s Chief User Advocate, and heads up our testing department.
>>>>>>
“Fundamentally you can’t do your own QA, it’s a question of seeing you own blind spots.” ~ Ron Avitzur

If you look carefully at the quote above you’ll find a typo. The point being that programmers are not best suited to find their own bugs. Just like writers rely on editors to catch their “bugs”, programmers use testers for the same purpose. That is, it takes a combination of highly skilled programmers and testers to create a quality software product.

Within the development community, it’s a well known fact—given today’s complex software—one cannot test every aspect of a project. Typical budgetary and timeline constraints only enhance this fact. Thus testers, with the help of other stakeholders, decide where to focus their efforts. This is called managing risks. That is, a decision not to test something saves time and money but increases the risk of bugs getting released into the wild.

How does one decide what to test and more importantly what not to test? The exact formula is beyond the scope of this article, but with your users in mind, three questions should be answered. First, what devices/operating systems/browsers do the majority of your visitors use? Second, what current features are popular and what upcoming features have your users most requested? And finally, if a particular feature were to break, what would the impact be on your users and your organization?

These questions help form a “Do Not Break” list of devices, operating systems, browsers, and features to focus limited testing efforts on. Once a plan of action has been made, and testers know what to do via test cases, then the process goes something like this:

1. Tester finds a bug and writes a problem report. The report includes a descriptive title, what the tester expected to happen, what actually happened, detailed steps to recreate the bug, and any other noteworthy information including screenshots and videos.
2. Programmer reproduces the bug, attempts to fix the bug, and then sends the problem report back to the tester for regression testing. Regression testing helps show the bug was fixed without introducing any new bugs.
3. Tester repeats the original steps and, if the bug can no longer be reproduced, closes the bug. Otherwise the tester sends the report back to the programmer for further investigation.

Testing with your users in mind not only saves time and money during the project, but ultimately pays off over the long term as well given less support issues and increased user appreciation as well as engagement. Oh, and as for the typo mentioned earlier, here’s how the quote should look: “Fundamentally you can’t do your own QA, it’s a question of seeing your own blind spots.”

August 20, 2013 by chrissy

Separating Content from Appearance: Semantic Markup

As a young web developer back in the mid-90’s, we didn’t worry about stuff like separating content from appearance. We just built our frame sets and table-based layouts, added all the fonts and styling inline, and just let everyone gaze in awe at the mere fact we could make one of those magical “web thingamajigs.” Plus we walked up-hill both ways to school, in the snow, and with no shoes. GET OFF MY LAWN!!

Where was I? Oh, yes, separating content from appearance. These days, things are very different, and with the advent of content management systems, it’s become increasingly important to truly separate your content from the appearance. This is the first in a series of articles that will explore some best practices for making your content portable.

Semantic Markup

Whenever I teach a basic web development class, I try to split a web page up like so:

Content is handled by HTML
Appearance is handled by CSS (and images)
Interactivity is handled by a client-side languages such as JavaScript and server-side languages such as PHP

For now let’s focus on the Content in HTML part of that list, which has a fancy name for it: semantic markup.

When you use semantic markup, all of your HTML will define the meaning of the content, and not its appearance. Sounds simple, right?

Read through your markup. Do any of the terms you used impart visual information? For example:

<i>Look at me!</i>

<div id="left-col">...</div>

<span class="red-highlight">Some important info to highlight</span>

Think about how you could adjust those lines of code without using any visual terms.

Let’s say, for example, you used the “red-highlight” class from the example above in a client’s site, because it went well with the logo, and it was defined like this:

.red-highlight {
   background: #ff0000;
}

Then imagine, a few months later, the client comes to you and says, “We’ve updated our logo, and it’s now blue and green. That red-highlighted text looks horrible with it. Make it green instead!” Would you do this?

.red-highlight {
    background: #ffff00
}

Really? You would have a “red highlight” that is actually green? I hope not. Maybe it would have been better to think about why the content is getting highlighted in the first place. Maybe it’s urgent information for visitors, so let’s use a word that correlates with the meaning behind the content, and not its appearance, to define the class:

.urgent {
    background: #ffff00
}

You might be wondering why this is so important. It’s all about portability! Web sites get redesigned all the time, and if you use visual terms to identify your content, then you’ll either have to change the terms, or updating the styling so it no longer reflects the meaning behind the identifier.

Grids and Frameworks

There are some great, widely-used, responsive frameworks out there, such as Foundation and Bootstrap, that might just be undermining the whole semantic markup crusade. While it’s not very obvious at first, this markup is not semantic:

<div class="rows">
   <div class="columns large-8 small-6">...</div>
   <div class="columns large-4 small-6">...</div>
</div>

The classes are dividing the content of the page up visually, and the terms “rows”, “columns”, “large-8,” “large-4,” and “small-6” specify appearance. In general, if a grid or framework uses terms such as rows, columns, large, medium, small, center, tiny, any other word that specifies appearance, or abbreviations of those words, that grid or framework is not totally semantic.

Don’t get me wrong. I’m not telling you not to use these frameworks, especially since we use them here at Pongos to help speed development, but you do need to be aware that when you use them your markup won’t be totally semantic. I find these to be less offensive to my semantic super senses than the “red-highlight” example I used earlier.

If you want to stay totally semantic, there is a Semantic Grid system that’s worth a look.