RSS Feed

Teaching Open Source Planet

Teaching Open Source Planet is a Planet, a collection of personal blogs by Teaching Open Source community members working to bring the open source way into academia. We write about our inspirations and experiences in learning, teaching, and collaborating within free and open communities. In the spirit of freedom, we share and criticize in order to collectively improve. We hope you enjoy reading our thoughts; if you’re fascinated by what you see, consider adding your voice to the conversation.

Learning Theories at a glance

The cmap at this location gives an overall picture of the established learning theories:

A Handy Visual Featuring The 7 Learning Styles

A Handy Visual Featuring The 7 Learning Styles

"One of the most popular theories that inform pedagogy is Howard Gardner's multiple intelligences theory. This theory posits the existence of seven different areas of intelligence that characterize the learning style one is more comfortable with. The visual below provides a very great overview of these 7 learning styles. If you want to learn more about Howard's multiple intelligences theory I would highly recommend his seminal work "Multiple Intelligences: New Horizons in Theory and Practice"."

Different learning styles are a neuroscience myth

Many of us are very familiar with the visual, auditory and kinesthetic learning styles.

However, these different learning styles are now being regarded as a neuroscience myth. You can read what Olivia Goldhill has to say about this neuroscience myth in this article:

My Open Tasks This Heartbeat

Happy New Year!

This heartbeat (ending Jan 22nd) is particularly crazy fun, as we prepare for the Leadership Summit in Singapore.  I’ m again experimenting with Open Tasks, this time asking for skill-specific help developing learning content for workshops:

1. Open is an Attitude

2. Rapid Prototyping

3. How to Run an Excellent Event

Each of these present a creative and fun challenge, both in content and format (1 hour workshops).  There are both very small, and larger chunks of work depending on your background and time.  When we’re done these will be shared for the world to use as well.

I can probably do a much better job of framing the opportunity in Github, and thus grateful for suggestions to improve the outline next time.   Always Learning!

CC BY-SA 2.0 ‘Teaching Open Source Practices’ by Image By



My 2016 #FOSS Project — Secret Shopper

In the first 6 months of 2016, I have a personal goal of contributing code to 10 Open Source Projects. I’m looking for projects with potential to teach us how to design for the success of contributors, like myself, who bring intermediate to advanced skill-sets and experience.  

I’ll be contributing code under another name, ala Secret Shopper, and sharing what I learn in a July post.

I am looking for nominations for Open Source projects that:

  • Are available on the web using web technologies.
  • Have a released version of their software
  • Have an existing community, or set of core contributors.
  • Want to improve their contributor design for intermediate and experienced developers.
  • Feel they have something they can teach others about community design.
  • Invested in increasing diversity of their contributor base.
  • Bonus: ‘Open’ Education focus.

What projects will get:

  • One or more code contributions from me –  I can’t promise they’ll be valuable, but I’ll do my best;)
  • Review of the experience (which is the actual contribution)
  • Inclusion in a blog post with my findings(in July)

What I hope for myself:

  • Emerge with a set of best practices for projects who want to help intermediate and experienced developers successfully join their project as contributors.
  • A User story of an experienced developer attempting to join a new community, through a first contribution.
  • New and fresh understanding for the experience of stepping into a project as a new code contributor.

If you would like to nominate a project – please do so in comments.

If you would like to nominate a project – please do so in comments on Medium.

Excited to play in FOSS communities this year!

We Can Code It — CC BY-NC-ND 2.0 by Charis Tsevis


Glucosio in 2016

Happy New Year, friends!

Our core team and contributors have much to be proud about reflecting on the work we did in the past few months. While there are many things to be proud of, I think one of the biggest accomplishments was we built an open source project and released a product to Google Play in under four months. We then went on to do four more releases and are growing our user base internationally on a daily basis.

Glucosio for AndroidGlucosio for Android

We have had an astounding amount of coverage from the media about the vision we have for Glucosio and how we can use open source software to not only help people with diabetes improve their outcomes but further research through anonymous crowdsourcing.

I’m proud of the work our core team has put in over the past few months and excited what the new year has in store for us as a project. One big change next year is we will be formally be under the leadership of a non-profit foundation (Glucosio Foundation) which should help us be more organized but also have the financial and legal structure we need to grow as a project and deliver on our vision.

I’ve been able to meet and talk with third parties like Dexcom, Nightscout Foundation and many others including individual developers, researchers and other foundations who are very interested in the work we are pioneering and are interested in partnering, supporting or collaborating with Glucosio.

One exciting thing we hope to kick off in the New Year are Diabetes Hack Days, where organizers around the world can host hack days in their community to get people to come together to hack on software and hardware projects that will spur new innovation and creativity around diabetes technology. Most importantly though, we are very excited to launch our API to researchers next year so they can begin extracting anonymized data from our platform to help further their diabetes research.

We also look forward to releasing Glucosio for iOS in the first quarter of 2016 which has had a lot of interest and been under development for a couple months now.

In closing, we would like to invite developers, translators, and anyone else to get in touch and get connected with our project and start contributing to the vision we have of amazing open source software to help people with diabetes. We’d also ask you to consider a donation to the project, which will help us in our launch of our iOS in Q1 of 2016, and help us more rapidly produce features by offering bounties via BountySource and expand into a more mature open source project.

Remembering Ian Murdock

Ian MurdockPhoto by Yuichi Sakuraba / CC BY

There is clearly great sadness felt in the open source community today after learning of the passing of Ian Murdock who founded the Debian Linux Distribution and was the first Debian Project Leader. Ian is the “ian” in Debian and Deb, his then-girlfriend (Debra Lynn) for those not familiar with the history of the naming of the project.

I was fortunate to meet Ian Murdock some years ago at an early Linux Conference (LinuxWorld) and it was very inspiring to hear him talk about open source and open culture. I feel still today that he was one of the many people who helped shape my own direction and contributions in open source. Ian was very passionate about open source and helped create the bricks (philosophy, vision, governance, practice) that power many open source projects today.

If it were not for Ian, we would not have many of the great Debian forks we have today including the very popular Ubuntu. There is no doubt that the work he did and his contributions to the early days of open source have had an impact across many projects and losing Ian at such a young age is a tragedy.

That said, I think the circumstances around Ian’s death are quite concerning as we have seen the tweets he made. I do hope that if Ian suffered excessive force at the hands of the San Francisco Police Department that justice will eventually be served.

I hope that we can all reflect on the values that Ian championed and the important work that he did and celebrate his contributions, which have had a very large and positive impact on computing.

Thank you Ian!

Extended Attributes

While working on support for FreeBSD’s extended attributes in python, I tried to be conscious of other implementations of extended attributes in different operating systems, that way I wouldn’t be inadvertently causing the sane problem that I was trying to fix: reliance on a particular API’s semantics.

What are extended attributes?

To put it very simply, extended attributes are metadata that are attached to files. Typically, they’re key/value pairs that the filesystem associates with a particular file on the filesystem, though that doesn’t always have to be the case.

How they’re implemented depends on both the filesystem, as well as the operating system. This means that implementations on the same filesystem (UFS, for example) can be complete incompatible across operating systems (Solaris and FreeBSD).

Extended attributes are not mandated by any standard. The tooling and APIs are quite different across operating systems and some operating systems (OpenBSD, HP-UX) don’t implement them at all. Because support is non-standard and spotty, it’s rare to see them used in cross-platform software. I’d be super-interested in seeing some counter-examples to this.

Extended attributes are sometimes namespaced. That is to say, there exists some top-level grouping of attributes. Other than the top-level namespace, there usually isn’t hierarchy to attributes, other than any arbitrary user-defined hierarchy. Namespaces are usually system and user, although this isn’t necessarily consistent, as we’ll see. Extended attributes under the system namespace are only modifiable by root (and sometimes only queriable by root).


ssize_t getxattr(const char *path, const char *name,
                 void *value, size_t size);
ssize_t lgetxattr(const char *path, const char *name,
                 void *value, size_t size);
ssize_t fgetxattr(int fd, const char *name,
                 void *value, size_t size);

ssize_t listxattr(const char *path, char *list, size_t size);
ssize_t llistxattr(const char *path, char *list, size_t size);
ssize_t flistxattr(int fd, char *list, size_t size);

int removexattr(const char *path, const char *name);
int lremovexattr(const char *path, const char *name);
int fremovexattr(int fd, const char *name);

int setxattr(const char *path, const char *name,
              const void *value, size_t size, int flags);
int lsetxattr(const char *path, const char *name,
              const void *value, size_t size, int flags);
int fsetxattr(int fd, const char *name,
              const void *value, size_t size, int flags);

The linux API is actually a fairly nice one, and for the rest of this post I’m going to use it as my point of comparison. The return values of the getxattr and listxattr functions are the total size of the attribute, not the size of the data returned. This lends itself to a nice idiom for checking whether or not truncation occurred:

char buf[BUFSIZ];
ssize_t res;

res = getxattr("/home/worr/foo", "", buf, sizeof(buf)) > sizeof(buf);
if (res > sizeof(buf))
    /* truncation occured */
else if (res == -1)
    /* error occurred */

If value is NULL in a call to getxattr or listxattr, the size of the buffer required to hold the contents of the EA will be returned. This allows you to query the amount of space required to hold the return value, allocate it, and then call the function again to populate that. That’s unfortunately racey, so it’s preferable to call and then realloc if truncation.

Linux extended attributes are namespaced, and the namespace is specified as part of the attribute name. Namespaces are separated from attribute names by a .. Currently, they support the common system and user namespaces, as well as security and trusted.

It’s important to note that listxattr will never retrun EPERM. If there are EAs that the current user cannot access, they just won’t be returned.

The attribute list returned by listxattr is NULL-delimited, and all of the attribute names returned by listxattr are fully-qualified.


It seems funny that I’m going to talk about AIX’s interface right after linux’s, but that’s largely because it’s…almost exactly the same.

ssize_t getea(const char *path, const char *name,
        void *value, size_t size);
ssize_t fgetea(int filedes, const char *name, void *value, size_t size);
ssize_t lgetea(const char *path, const char *name,
        void *value, size_t size);

ssize_t listea(const char *path, char *list, size_t size);
ssize_t flistea (int filedes, char *list, size_t size);
ssize_t llistea (const char *path, char *list, size_t size);

int removeea(const char *path, const char *name);
int fremoveea(int filedes, const char *name);
int lremoveea(const char *path, const char *name);

int setea(const char *path, const char *name,
        void *value, size_t size, int flags);
int fsetea(int filedes, const char *name,
        void *value, size_t size, int flags);
int lsetea(const char *path, const char *name,
        void *value, size_t size, int flags);

Just like linux, getea and listea return the size of the actual attribute value, which makes checking for truncation super easy. They also support getting called with a zero size, which will just return the size of the list or attribute value without writing any data to value.

The only key difference is that is that they use the character 0xF8 to separate the namespace from the attribute name. So querying for system attributes involves querying the name 0xF8SYSTEM0xF8attr.

There’s also the statea family of functions, which will fill in a struct stat64x, but that’s of little consequence to us here.

FreeBSD / NetBSD

extattr_get_fd(int fd, int attrnamespace, const char *attrname, void *data, size_t nbytes);
extattr_get_file(const char *path, int attrnamespace, const char *attrname, void *data, size_t nbytes);
extattr_get_link(const char *path, int attrnamespace, const char *attrname, void *data, size_t nbytes);

extattr_set_fd(int fd, int attrnamespace, const char *attrname, const void *data, size_t nbytes);
extattr_set_file(const char *path, int attrnamespace, const char *attrname, const void *data, size_t nbytes);
extattr_set_link(const char *path, int attrnamespace, const char *attrname, const void *data, size_t nbytes);

extattr_delete_fd(int fd, int attrnamespace, const char *attrname);
extattr_delete_file(const char *path, int attrnamespace, const char *attrname);
extattr_delete_link(const char *path, int attrnamespace, const char *attrname);

extattr_list_fd(int fd, int attrnamespace, void *data, size_t nbytes);
extattr_list_file(const char *path, int attrnamespace, void *data, size_t nbytes);
extattr_list_link(const char *path, int attrnamespace, void *data, size_t nbytes);

FreeBSD and NetBSD both use the same functions for the extended attribute calls. The most obvious difference is that the attribute namespace is no longer part of the attribute name. Each namespace is defined as an constant, and must be passed separately.

Almost seemingly as a result of this difference, extattr_list can now error with EPERM, rather than hiding the attribute names that the caller doesn’t have access to.

The other, more annoying difference, is the return value of the extattr_get and extattr_list functions. Rather than behaving like linux, AIX or OS X, they instead return the number of bytes written, making truncation detection harder. This basically requires that you make two calls if you want to ensure that no truncation will occur.


getxattr(const char *path, const char *name, void *value, size_t size, u_int32_t position, int options);
fgetxattr(int fd, const char *name, void *value, size_t size, u_int32_t position, int options);

listxattr(const char *path, char *namebuf, size_t size, int options);
flistxattr(int fd, char *namebuf, size_t size, int options);

removexattr(const char *path, const char *name, int options);
fremovexattr(int fd, const char *name, int options);

listxattr(const char *path, char *namebuf, size_t size, int options);
flistxattr(int fd, char *namebuf, size_t size, int options);

OS X differs in a few ways. Notably, their functions all take an options arg. Rather than calling an entirely different function to prevent following symlinks, you can pass the XATTR_NOFOLLOW to prevent traversing symlinks.

Another, fairly curious difference is the position argument that’s part of the prototype for getxattr. To really get a handle on this, we’re going to dive into the wonderful world of forks.


Forks are kind of like having multiple datastreams for the same file. The data that we typically think of being stored in a file is dumped into one fork (in the case of Mac OS, the data fork) and metadata, resources or any other type of data could exist in other forks, wholly independent.

On Mac OS filesystems (MFS, HFS, HFS+), each file could have at least a resource fork for the purpose of storing resources about a given file. This was used for things like splitting up icons that Finder would use to represent a file, or for separating presentation and content of text documents.

HFS+ (maybe HFS too? I’m not sure) allowed for any number of named forks.

Back to OS X

Extended attributes on OS X are actually just named forks. The extended attribute API wholly supplanted the old resource manager API. To ensure that applications could seek to arbitrary points in a fork, OS X’s extended attribute API includes a position argument.

getxattr is similar to Linux, in that it returns the size of the attribute’s data, not just the number of bytes read. This makes truncation detection pretty easy.

It is worth noting that extended attribute names in OS X are not namespaced in any special way.


Solaris gets weird. Solaris is probably closest to OS X in its implementation of extended attributes, in that extended attributes are just named forks. However, Solaris includes only one specialized function call to deal with extended attributes.

int attropen (const char *path, const char *attrpath, int oflag, ...);
/* the varargs can include a mode argument of type mode_t */

But even this isn’t required, since you can get the same results from using a combination of open and openat:

int fd = open(path, O_RDONLY);
int attrfd = openat(fd, attrpath, oflag|O_XATTR, mode);

From there, all of the *at functions can be used to operate on extended attributes with some restrictions:

Otherwise, extended attributes are treated like regular files.

This sucks

This is awful when trying to expose a generic, cross-platform API for extended attributes; the only one that I’ve found is written for perl. I had to add support for FreeBSD in Go, Python and Rust - and none of these deal with Solaris or AIX! Adding FreeBSD support was pretty rough, largely since implementors assume that every OS has a Linux-compatible API.

No OS has a Linux-compatible extended attribute API

Honestly, I wonder if this contributes to the lack of cross-platform apps that use extended attributes. They’re super useful in any case where it’s necessary to track metadata about files without having to keep track of it in a separate database. That’s honestly fraught with peril anyway, since you’re dependent on the name of the file (or whatever identifier you use in your db) staying constant across renames, deletes, etc.

Where to go from here?

A C wrapper lib around all of these implementations would be nice, but there are some obvious trade-offs that need to be made.

The way that I’ve done this in Python and Rust has been to:

Maybe when I get some time, I’ll start working on one.

Finally: please, please stop assuming that the whole world is Linux.


How to avoid 'death by PowerPoint'

Many of us use PowerPoint to make presentations. However, not everyone succeeds in making a fantastic presentation which the audience enjoy listening and interacting with the speaker.

Many PowerPoint presentations are boring, have too much textual information and speakers tend to read from the text typed on the PowerPoint.

Jane Wakefield, a Technology reporter, has written an enjoyable article entitled 'How to avoid 'death by PowerPoint'.

The URL of this article is:

Surfacing Teachable Moments in Community

I’m still figuring out how to cross-post well with Medium .  And if I want to, trying embed for fund.

Surfacing Teachable Moments in Community


Leadership Summit Planning

With a successful Mozlando for the Participation Cohort still in our rear-view mirror, we are excited to begin the launch process for the Leadership Summit, happening next month in Singapore

What is the Leadership Summit?

As part of the Participation Team’s Global Gatherings application process for this event,  we asked people to commit to developing and being accountable to recruit and organize contributors in order grow the size and impact of their community in 2016.  We ran also ran a second application process this month, to identify new and emerging leaders – bringing our invited total to 136.

The Leadership Summit will bring together this group for two days of sessions and experiences that will:

Help Participation Leaders will feel prepared (skills, mindsets, network) and understand their role as leaders/mobilizers who can unleash a wave of growth in our communities, in impact and in numbers.

Help Participation Leaders leave with action plans and commitments, specific to growing/evolving their communities and having impact on Connected Devices and a Global Campus Campaign.

Help everyone leave feeling that “we’re doing this together.” Everyone attending (volunteer and staff Mozillians) will feel like a community that is aligned with Mozilla’s overall direction, and who now trust one another and have each others back.



“You mentioned Connected Devices and a Global Campus Campaign?  Say more…”

Sure! In setting goals for 2016, we realized that focusing on one or two truly impactful initiatives, will bring us closer to unleashing the Participation Mozilla needs, while providing opportunity for individuals to connect their ideas, energy and skills in the way that feels valued and rewarding.

To that end, we are currently developing a list of sessions and experiences for the Leadership Summit that will set us up for success in 2016 as community leaders, and on each of our three focus areas:

We will say more about each as we get closer to the Summit, as well as including the opportunity to connect personal goals through 1:1 coaching for all attending.

“What about Reps and other functional areas?”

Fear not!  Sessions and experiences will include:

Alignment for Reps around changes in the program, what’s expected of them, and what they can expect from Council and staff in 2016

Opportunity for volunteers in specific functional areas to build relationships with staff in those areas

This event will complete the process of merging participants from three events into one activated cohort – this is our beginning, and I am excited, I hope you are too!

Feature Image by ‘Singapore’ CC by 2.0 David Russo


Cara Membuat Gambar Kronologi Facebook Keren Unik Kreatif

Cara Membuat Gambar Kronologi Keren  -  Dalam dunia internet khususnya sosial media gambar menjadi salah satu hal yang paling banyak di share di status maupun komentar facebook. Salah satu gambar yang menjadi perhatian pengguna facebook satu dengan yang lainnya adalah kronologi facebook dimana ketika teman sobat melihat profil facebook milik sobat mereka akan melihat gambar kronologi tersebut.

12 Situs Cara Membuat Logo Online Gratis Paling Keren Sendiri

12 Situs Tempat Untuk Membuat Logo Online  Akan membantu sobat yang belum begitu memahami tentang program graphic design seperti photoshop, coreldraw, freehand, xara, serif, acdc, GIMP, dan lain sebagainya. situs ini akan memanjakan siapapun juga bahkan yang sama sekali tidak mengenal dengan program designer apapun di komputer. saya yakin Siapapun dan apapun profesi sobat tentunya nama Logo sudah

Cara Membuat Gambar Foto Bergerak Mudah Dan Cepat Tanpa Software

Cara Membuat Gambar Bergerak -  Jika dilihat dengan mata biasa gambar yang bergerak ini seolah terlihat hanya sebuah gambar tunggal, namun jika sobat mau membedah / mengedit gambar tersebut dengan program tertentu ternyata gambar tersebut terdiri dari beberapa gambar yang disatukan dan sudah di atur dengan ritme dengan waktu yang sudah direntukan. gambar GIF ini bisa bergerak dengan cepat atau

A Very Short Introduction to Educational Technology

This is a short presentation by Mike Sharples of the Institute for Educational Technology in the UK's Open University:

Open Educational Resources blog for Cambodia

Here is the Open Educational Resources blog for Cambodia:

It is managed by the Ministry of Cambodia.

Machine Learning is next big thing in programming

There is a news report The Straits Times entitled “Machine Learning is next big thing in programming”:

Some news on live holographic lecture

There is a news item entitled “NTU conference treated to live holographic lecture” in The Straits Times.

You can read it online at

"Just What Will We Learn In The Future And How?" - opinion in The Straits Times

There is an opinion written by Warren Fernandez of The Straits Times at:

Students Don't Perform Better With Technology Use In School - OECD

Here is the URL of the article on "Students Don't Perform Better With Technology Use In School - OECD":

Revisiting the Word ‘Recognition’ in #FOSS and the Dream of Open Credentials

I think a lot about ways we can better surface Participation as real-world offering for professional and personal development.

And this tweet from Laura  triggered all kinds of thinking.

Most thinking was reminiscent at first. 

Working on open projects teaches relevant skills, helps establish mentorship relationships and surfaces hidden strengths and talents. It’s my own story.

And then reflective..

The reason we’ve struggled to make participation a universally recognized opportunity for credential building, is our confusion over the term ‘recognition’. In Open Source we use this term to mean of similar, yet entirely different meanings:

* Gratitude (“hey thanks for that !”)

* You’re making progress (“great work, keep going! “)

* Appreciation (“we value you”)

* You completed or finished something (congratulations you did it!)

In my opinion, many experiments with badges for FOSS participation have actually compounded the problem: If I am issued a badge I didn’t request( and I have many of these) , or don’t value ( I have many of these too) we’re using the process as a prod and not as a genuine acknowledgement of accomplishment.  That’s OK, gamification is OK – but it’s not credential building in the real-world sense, we need to separate these two ‘use cases’ to move forward with open credentials. 

And I kept thinking…

The Drupal community already does a good job at helping people surface real-world credentials. member profiles expose contribution and community leadership, while  business profiles  demonstrate (and advertise) their commitment through project sponsorship, and contribution.  Drupal also has this fantastic series of project ladders which I’ve always thought would be a great way to experiment with badges, designing connected learning experiences through participation.  Drupal ladders definitely inspired my own work with around a ‘Participation Standard‘ , and I wonder how projects can work together a bit more on defining a standard for  ‘Distributed Recognition’ even between projects like Mozilla, Drupal and Fedora.  

And the relentless thinking continued…

I then posed the question in our Discourse — asking what ‘Open Credentials’ could look like for Participation at Mozilla . And there are some great responses so far, including solutions like Makerbase and   reminder of of how hard it current is to be ‘seen’ in the Mozilla community, and thus how important this topic actually is.









And the thinking will continue, hopefully as a growing group ….

What I do know is that we have to stop using the word recognition as the catch all, and that there is huge opportunity to build Open Credentials through Participation and leadership framework might be a way to test what that looks like.

If you have opinions – would love to have you join our discussion thread!

image by jingleslenobel CC by-NC-ND 2.0


On the relative openness of text/document formats: .txt and .csv

My friend and research colleague Todd Fernandez writes: I know the ODF (Open Document Format) is generally the preferred format from an open documents standpoint. My question is whether you [and other Free/Libre groups] would consider .txt files in Unicode and .csv (comma-separated value) data files considered equivalently open?

First of all, I can’t answer for FSF or other groups — so what you’re getting is the Mel answer to “are .txt and .csv files open?” This email reply is getting so long that I’ll turn it into a blog post.

The Mel answer is “yes.” I consider .txt files in Unicode and .csv to be “open.” In fact, I personally prefer to use them over ODF, which I’m rarely able to open with the software pre-installed on most computers I encounter.

In the paragraphs that follow, I’ll get into more detail behind my reasoning. To define “open” and “free,” I’ll loosely use the Open Source Definition (OSD) and the Free Software Definition, noting that these were created for software and need to be adapted for a discussion on file formats.

In discussing these file formats, I’ll cover .txt first, since .csv builds on top of .txt. The file extension”.txt” can mean a lot of things, and each of those things has different levels of open-ness (from a more legal-ish open standards standpoint, see definitions above) and accessibility (from a “how many people are able to read/write them on their computers with their current software” standpoint). I personally care about both.


You asked specifically about Unicode, but “.txt” can also mean ASCII, which is/was an American-developed standard for text information. I’ll start here, since ASCII was where Unicode began (in fact, ASCII’s 128 characters are Unicode’s first 128 characters).

ANSI X3.4-1968 is the document describing this encoding. It is a standard that’s widely used and published, lots of programs can access it, and you can use it in your programs without too much effort and without licensing costs (as far as I can tell; I can’t easily find the exact legal status). Basically, if I translate the Open Source Definition from software to file formats, I can’t find evidence that ANSI X3.4-1968 itself contradicts any of its criteria. I know this is different than proving that it absolutely meets all these criteria, but this is good enough for me.


As an interesting side note: ASCII is an ANSI standard (American National Standards Institute, hence the ANSI- prefix on its standards document). ANSI’s definition of “open” is about “do stakeholders have access to the consensus decisionmaking process that forms the standards?” and “are licensing fees and getting permission to use the standard at a reasonable and not overly burdensome level?” rather than “are there no licensing fees and permissions needed at all?” The latter corresponds to part of the 4 requrements for “freedom” according to the FSF, so it’s possible for something to be “open” according to ANSI but not “free” according to the FSF.

It would be interesting to go through and do a more rigorous look on whether ASCII’s legal/licensing criteria meets the Four Freedoms. I’m not a lawyer, but I’d be interested in what a lawyer would say.


“.txt” can also mean UTF, or Unicode Transformation Format; this is what your email asked about. The “A” in ASCII stands for “American,” and “American” in this case meant “monolingual,” meaning that if you wanted to type something outside ASCII’s 128-character, heavily-biased-towards-American-English set, you were flat out of luck. Unicode took the first 128 characters of ASCII, then… kept on going. Unicode is a more internationally-savvy superset of and successor to ASCII.

UTF-8 and UTF-16 are two Unicode variants in common use. The numbers refer to the number of bits per character, which you can think of as “UTF-16 has more letters in its gigantic international meta-alphabet than UTF-8.” UTF standards are developed by the Unicode Consortium, which I keep mistakenly typing as the “Unicorn Consortium” (which would be kinda awesome).

Unicode’s copyright permissions language seem very, very similar to the 4 requirements of the FSF for freedom. Since ASCII is a subset of Unicode, this makes me even more comfortable saying that ASCII is also “open.” However, I am not a lawyer, nor am I using “open” in a legally rigorous sense here — remember, I am a non-legally-trained engineer going “yeah, I don’t see anything that contradicts the definitions made for Open and Free software, if we were to translate it to file-formats-land.”


CSV is a format that’s layered atop plaintext (ASCII, UTF, whatever). In other words, you use plaintext to write a CSV document. CSV itself is not formally specified, which means it’s a free-for-all, and… you can use it for whatever, because you’re pretty much making it up. It’s just that you’re just making it up in the same way lots of other people have made it up.

Then again, “official standards” are just a group of people who have made things up and have agreed to stamp the label of “official” on their work; it’s still a social construct that depends on how many other people agree with them. (I can make something an “official” standard according to Mel, but if nobody else agrees with me, my standard is useless.)

Anyway, I’m not sure if that qualifies CSV as “open,” but it’s certainly not “closed.” To me, CSV is just as open as whatever underlying plaintext (.txt) format it’s using. But again, I’m not a lawyer, don’t work for the FSF, etc. This is just one hacker’s opinion, and I’d love to hear what others think.

Google Berganti wajah Baru, Lebih Cepat dan Simple

Google Berganti wajah Baru, Lebih Cepat dan Simple - Mungkin berita ini banyak yang sudah mengetahui namun siapa tahu masih ada yang belum tahu tentang berita google terbaru. Google plus adalah jejaring sosial terbesar yang bisa di akses dengan gratis untuk siapapun juga. Malam ini saya coba membuka akun google plus milik saya,  saya melihat ada yang berbeda dari biasanya. saya melihat sebuah

Openly Thankful

ThankfulSo next week has a certain meaning for millions of Americans that we relate to a story of indians and pilgrims gathering to have a meal together. While that story may be distorted from the historical truth, I do think the symbolic holiday we celebrate is important.

That said, I want to name some individuals I am thankful for….



Lukas Blakk

I’m thankful for Lukas for being a excellent mentor to me at Mozilla for the last two years she was at Mozilla. Lukas helped me learn skills and have opportunities that many Mozillians would not have the opportunity to do. I’m very grateful for her mentoring, teaching, and her passion to help others, especially those who have less opportunity.

Jeff Beatty

I’m especially thankful for Jeff. This year, out of the blue, he came to me this year and offered to have his university students support an open source project I launched and this has helped us grow our l10n community. I’m also grateful for Jeff’s overall thoughtfulness and my ability to go to him over the last couple of years for advice and feedback.

Majken Connor

I’m thankful for Majken. She is always a very friendly person who is there to welcome people to the Mozilla Community but also I appreciate how outspoken she is. She is willing to share opinions and beliefs she has that add value to conversations and help us think outside the box. No matter how busy she is, she has been a constant in the Mozilla Project. always there to lend advice or listen.

Emma Irwin

I’m thankful for Emma. She does something much different than teaching us how to lead or build community, she teaches us how to participate better and build better participation into open source projects. I appreciate her efforts in teaching future generations the open web and being such a great advocate for participation.

Stormy Peters

I’m thankful for Stormy. She has always been a great leader and it’s been great to work with her on evangelism and event stuff at Mozilla. But even more important than all the work she did at Mozilla, I appreciate all the work she does with various open source nonprofits the committees and boards she serves on or advises that you do not hear about because she does it for the impact.


Jonathan Riddell

I’m thankful for Jonathan. He has done a lot for Ubuntu, Kubuntu, KDE and the great open source ecosystem over the years. Jonathan has been a devout open source advocate always standing for what is right and unafraid to share his opinion even if it meant disappointment from others.

Elizabeth Krumbach Joseph

I’m thankful for Elizabeth. She has been a good friend, mentor and listener for years now and does so much more than she gets credit for. Elizabeth is welcoming in the multiple open source projects she is involved in and if you contribute to any of those projects you know who she is because of the work she does.


Paolo Rotolo

I’m thankful for our lead Android developer who helps lead our Android development efforts and is a driving force in helping us move forward the vision behind Glucosio and help people around the world. I enjoy near daily if not multiple time a day conversations with him about the technical bits and big picture.

The Core Team + Contributors

I’m very thankful for everyone on the core team and all of our contributors at Glucosio. Without all of you, we would not be what we are today, which is a growing open source project doing amazing work to bring positive change to Diabetes.


Leslie Hawthorne

I’m thankful for Leslie. She is always very helpful for advice on all things open source and especially open source non-profits. I think she helps us all be better human beings. She really is a force of good and perhaps the best friend you can have in open source.

Jono Bacon

I’m thankful for Jono. While we often disagree on things, he always has very useful feedback and has an ocean of community management and leadership experience. I also appreciate Jono’s no bullshit approach to discussions. While it can be rough for some, the cut to the chase approach is sometimes a good thing.

Christie Koehler

I’m thankful for Christie. She has been a great listener over the years I have known her and has been very supportive of community at Mozilla and also inclusion & diversity efforts. Christie is a teacher but also an organizer and in addition to all the things I am thankful for that she did at Mozilla, I also appreciate her efforts locally with Stumptown Syndicate.

trust issues and the order of law and technology cf @FrankPasquale

I’ve cut to the last chapter of Pasquale’s The Black Box Society, “Towards an Intelligible Society.” I’m interested in where the argument goes. I see now that I’ve gotten through it that the penultimate chapter has Pasquale’s specific policy recommendations. But as I’m not just reading for policy and framing but also for tone and underlying theoretical commitments, I think it’s worth recording some first impressions before doubling back.

These are some points Pasquale makes in the concluding chapter that I wholeheartedly agree with:

There is quite a bit in the conclusion about the specifics of regulation the finance industry. There is an impressive amount of knowledge presented about this and I’ll admit much of it is over my head. I’ll probably have a better sense of it if I get to reading the chapter that is specifically about finance.

There are some things that I found bewildering or off-putting.

For example, there is a section on “Restoring Trust” that talks about how an important problem is that we don’t have enough trust in the reputation and search industries. His solution is to increase the penalties that the FTC and FCC can impose on Google and Facebook for its e.g. privacy violations. The current penalties are too trivial to be effective deterrence. But, Pasquale argues,

It is a broken enforcement model, and we have black boxes to thank for much of this. People can’t be outraged by what they can’t understand. And without some public concern about the trivial level of penalties for lawbreaking here, there are no consequences for the politicians ultimately responsible for them.

The logic here is a little mad. Pasquale is saying that people are not outraged enough by search and reputation companies to demand harsher penalties, and this is a problem because people don’t trust these companies enough. The solution is to convince people to trust these companies less–get outraged by them–in order to get them to punish the companies more.

This is a bit troubling, but makes sense based on Pasquale’s theory of regulatory circularity, which turns politics into a tug-of-war between interests:

The dynamic of circularity teaches us that there is no stable static equilibrium to be achieved between regulators and regulated. The government is either pushing industry to realize some public values in its activities (say, by respecting privacy or investing in sustainable growth), or industry is pushing regulators to promote its own interests.

There’s a simplicity to this that I distrust. It suggests for one that there are no public pressures on industry besides the government such as consumer’s buying power. A lot of Pasquale’s arguments depend on the monopolistic power of certain tech giants. But while network effects are strong, it’s not clear whether this is such a problem that consumers have no market buy in. In many cases tech giants compete with each other even when it looks like they aren’t. For example, many many people have both Facebook and Gmail accounts. Since there is somewhat redundant functionality in both, consumers can rather seemlessly allocate their time, which is tied to advertising revenue, according to which service they feel better serves them, or which is best reputationally. So social media (which is a bit like a combination of a search and reputation service) is not a monopoly. Similarly, if people have multiple search options available to them because, say, the have both Siri on their smart phone and can search Google directly, then that provides an alternative search market.

Meanwhile, government officials are also often self-interested. If there is a road to hell for industry that is to provide free web services to people to attain massive scale, then abuse economic lock-in to extract value from customers, then lobby for further rent-seeking, there is a similar road to hell in government. It starts with populist demagoguery, leads to stable government appointment, and then leverages that power for rents in status.

So, power is power. Everybody tries to get power. The question is what you do once you get it, right?

Perhaps I’m reading between the lines too much. Of course, my evaluation of the book should depend most on the concrete policy recommendations which I haven’t gotten to yet. But I find it unfortunate that what seems to be a lot of perfectly sound history and policy analysis is wrapped in a politics of professional identity that I find very counterproductive. The last paragraph of the book is:

Black box services are often wondrous to behold, but our black-box society has become dangerously unstable, unfair, and unproductive. Neither New York quants nor California engineers can deliver a sound economy or a secure society. Those are the tasks of a citizenry, which can perform its job only as well as it understands the stakes.

Implicitly, New York quants and California engineers are not citizens, to Pasquale, a law professor based in Maryland. Do all real citizens live around Washington, DC? Are they all lawyers? If the government were to start providing public information services, either by hosting them themselves or by funding open source alternatives, would he want everyone designing these open algorithms (who would be quants or engineers, I presume) to move to DC? Do citizens really need to understand the stakes in order to get this to happen? When have citizens, en masse, understood anything, really?

Based on what I’ve read so far, The Black Box Society is an expression of a lack of trust in the social and economic power associated with quantification and computing that took off in the past few dot-com booms. Since expressions of lack of trust for these industries is nothing new, one might wonder (under the influence of Foucault) how the quantified order and the critique of the quantified order manage to coexist and recreate a system of discipline that includes both and maintains its power as a complex of superficially agonistic forces. I give sincere credit to Pasquale for advocating both series income redistribution and public investment in open technology as ways of disrupting that order. But when he falls into the trap of engendering partisan distrust, he loses my confidence.

The Journey Continues – Mozlando is Coming!

It’s the most wonderful time of the year!  The ‘Mozilla Coincidental Work Week’ brings everyone at Mozilla together in the same city, at the same time for the opportunity of collaboration – this time in Orlando Florida (Dec 7 – 11) !

‘Mozlando’ is the next stop on our Participation Cohort’s journey –  a perfect environment for goal-setting focused on building high impact participation opportunities with product teams.  Truly – a  beautiful opportunity to invest in, and with each other.

IMG_2015-11-18 15:36:44

Over 100 volunteers will have the opportunity to work directly with teams helping design and strengthen goals which in many (and most)  cases includes Participation.  For those invited by the Participation Team, we will of course, be dedicating ourselves to that focus.


We have three distinct volunteer groups attending Orlando:

  1. Those invited by the Participation Team.
  2. Those invited by another functional area, but who are also part of the Participation Cohort.
  3. Those who were invited by another functional area, but currently have no Participation connection.
    1. Subset: those in this group who may, informally, have Participation goals in their work.

We will reach out with offers for 1:1 coaching for all in groups 1 & 2.  And for the subset of the 3rd group, will reserve blocks of time for those interested in Participation.

The coaching this time around even more important recognizing that connecting volunteers with the project goals is a critical step to bringing sustained strategic advantage to Mozilla . We are asking our cohort to research and consider the following:

  1. What are my participation goals for 2016?
  2. What are the goals in 2016 of the product team I will be working with?
  3. How do these align with my own goals for 2016?  What adjustments do I need to make?  What questions do I need to ask?
  4. How can I share what I learn, and bring others in who want to contribute to the same area of the project?

CC by-nc-sa 2.0 by Christos Bacharakis

At the heart of everything of course is people, why we’re here, why we care,  where we envision we can go individually, and with each other.  I’m looking forward to all of it!

For those who think of Orlando as ‘Disney’ and for those who think of Orlando as ‘Space ‘ I give you an image for everyone. ‘Mickey Mouse on Mercury’ CC by 2.0 Nasa Goddard Space Flight Center

Feature Image Credit:  Nasa on The Commons


#MyMozfest 2015

The Mozilla Festival took place this last past weekend!   Mozfest is the first of three Global Leadership events we’re leveraging to empower a cohort of Participation Leaders in their goals for 2016.  This first group of 30  represents those whose goals strongly focused on developing and delivering programs that build skills (leadership and otherwise) of Mozillians.



Mozfest is the perfect place to meet kindred spirits, make new and valuable connections, and to experiment and get feedback  in real time.  Everything including sessions themselves, lend to hackability and spontaneous invention, the environment encourages a bravery to reach inside ourselves, and to recognize our potential to be the change we want to see in the world .


It was  very very exciting to be a part of designing an experience for this group that  included pre-event coaching, facilitator training, and leadership workshops led by George Roter.   We also hosted the first ever ‘Participation Space’ at Mozfest which was filled with sessions and activities the entire weekend. I wanted to share a few moments that stood out for me, with a sneak peek into what’s next.



  1. Adriano Capello’s Workshop “Leadership Games” , saw people sitting around a table with bags on their heads laughing and learning about leadership while making things.  This session would have continued long past the end-time if participants had their way.
  2. Gloria Dwomoh’s ‘Getting Started with Open Source‘ session.  This was her first-ever facilitation session, she did a great job.  The smile on her face made my day  – a facilitator was born :)
  3. Watching Christos mentor Gloria in a session on Scaling the Learning and Leading program at Mozilla.  Helping her find that thing she was good at, and could teach.  Huge talent.
  4. Saran Mansouri – Hacking Flexigons, took place in the Youth Zone, and by all accounts her session engaged a tricky group of learners in a big way.
  5. Tools for Growing an Inclusive Diverse Community by Larissa Shaprio was one of our best attended sessions in the Participation Space – thrilled to see this topic as part of our leadership focus.
  6. George Roter’s Leadership Kickoff story about Farmers and Farming, ask him to tell it to you in the context of community leadership.  Super inspiring.
  7. ‘The Internet Box’ a quick design by one of our cohort during the kickoff that showed the Internet as a box, with two doors. One door is Mozilla, one was through proprietary, privacy threatening orgs. Same technology, same box two doors, which would you choose?  Brilliant.
  8. Firefox OS App Building session by Errietta Kostala , saw engagement of new developers wanting to contribute to FFOS, and for the win – they were connected with project leads for Firefox OS Smart TVs.
  9. Ioana, Michael and Henrik who joined us on their own time  – ran sessions or otherwise made the space much more amazing because they were there.  Special thanks to Ioana, and Flore for help with space setup.  Also cheese and chocolate from Flore ;)
  10. The Participation Museum!  A collection of items
  11. The leadership wrap up!  By far my favorite moment as everyone sharpened their goals for 2016 and wore the Participation ‘cape’ to share their first milestone.


As the ‘space wrangler’ for Participation, I didn’t get out much :) but still managed these inspiring moments.  Looking forward to reading the blog posts of our entire cohort on their Mozfest moments.  Here are more photos of our caped cohort!

Next up, we’ll be holding our first call for those who attend Mozfest, and launching connective efforts to bring in  those who have yet to attend an event, or who sadly missed this one because of Visa issues.  Lots of goodness ahead!








Mozilla at Grace Hopper Open Source Day

This past October, thanks to Larissa Shapiro, I had the incredible opportunity of teaching Open Source Participation at Grace Hopper Open Source Day.

In recent years, I would say the primary focus of my contribution to Mozilla has been an effort to create educational offerings and experiences with real world value, through open source participation.  And this event proved  that –  not only do people really want learning opportunities like this, but we can make the world a better place, and tech a more diverse environment in the process.

Some highlights in our success on this day:


We had a group of incredible mentors – I would have been lost without them.  Special mention to Paula (post main photo) who created virtual machine solution for those who struggled too long with their environments.  Mentorship is absolutely key to an event like this, and the talented people that turned up has me dreaming of a mentorship team for all technical projects..


I chose the website as a contribution project.  Primarily because I had experience with the environment and codebase,  and support from project team members:  Mavis and Hannah who were kind enough to tag specific issues with ‘Grace Hopper’.

I also chose this project because I knew the technology was both easy to pickup, and had real world value in the job market.   Finally, I knew  the ‘Ready, Write, Participate’ message would resonate with a group of learners..learning to Participate :)




Our group was brilliant. I worried that some issues with environment  (and we had quite a few) would dampen spirits, or result in people leaving.  The opposite happened.  Our group emerged in the very best way – a community and a team.  When one woman overcame an issue with a node version, she rose to help others reach their own success as well.  Experts in environments and issues emerged to mentor others, and by afternoon I had run out of ‘Grace Hopper’ tasks.

I had to remind at least one person to eat, and another woman in the last 15 minutes of the event, was on her feet trying to fix one last issue before submitting her pull request.  I was proud, and honoured to be part of a group so diverse (including a male mentor), that there was really no majority in the room.  That is an amazing feeling.




Our group demoed their work, and it was an zen moment, to see this group describe not only their work overcoming obstacles,  but what they accomplished and why the project mattered.  Hope to be back again next year!






Let’s End the Community Council Entrenchment

2842789Let’s bring some change to the Community Council. A few of those running for Community Council have been on the council for years and not given up their seat to allow new ideas and fresh leadership to come to the council.
I think this is bad not only in governance of open source projects, but in leadership of any body whether it be a nonprofit board, a city council, a parliament, or congress.

At least two of the most senior people, in terms of how long they have been on community council, are in my opinion also the most disconnected and least communicative with the community, with one of them not having contributed to Ubuntu outside of their council role in years.

I think it is time to shake things up and that is why I am prioritizing my vote for the following four people as top picks and I’d encourage you to use your vote however you want but please consider shaking it up and bringing in some new faces.

TL;DR We know entrenchment in community leadership, nonprofit boards and politics is generally bad so lets shake it up!

My pick list:
Scarlett Clark
Svetlana Belkin
Phillip Ballew
Walter Lapchynski
Marco Ceppi
C de-Avillez
Jose Antonio Rey

Update: Charles Profitt a member of the Ubuntu CC who is departing emailed me this blog post he did last month which aligns with my opinion on entrenchment and dynamic not static leadership.

Starting a dev blog

I haven’t really written anything here in, well, over a year. I’ve thought a lot about how I really need to start writing again, and what kind of stuff I’d like to write about. Over the last few weeks, I’ve realized that I’m much more enthusiastic about the stuff that I’m working on when I spend a little time writing or tweeting about it. That said, I think I’m going to move updates about the FOSS projects I’m working on from Twitter to my dev blog.

Every day that I work on something, I’ll post a bite-sized update on my dev blog. If I come across something interesting to write about outside of just posting commits, then I’ll circle back here and write a bit about it in detail. I’d like to keep this low-volume and long-form (except for this post, obviously), if possible.

I’m going to try this out for at least the next few days, since I have a lot of FOSS work in my pipeline.

Microsoft… and Hard… and a little bit Open

Skimming Microsoft’s most recent annual report provides some interesting insights. Among them: While many people are inclined to view Microsoft as a mature (and perhaps not that relevant?) company, the financial results continue to be quite impressive. In rounded billions, Microsoft has grown from total revenue of $70 billion to $94 billion over the last […]

Teaching and Technology Related Handouts & Posts from the Last Year

Here are some various educational handouts and blog posts elsewhere I’ve created over the past year, in case you find any of them useful:

Handouts / Google Docs:

Blog posts:


I’ve also been posting on some Google+ groups, collections, and Twitter accounts:

Filed under: children, edtech, education, embodiment, games, learning sciences, opensource, simulations, software, teaching, technology

A slide presentation on Instructional Design

An interesting slide presentation on Instructional Design by Damian Gordon, lecturer in the Dublin Institute of Technology

The transcript of the presentation is also given in the website.

Cara Download Video di Facebook tanpa Software Apapun

Cara Download Video di Facebook - Dalam perjalanan waktu facebook mengalami berbagai perubahan bagaimana orang-orang mengirim status di dinding mereka. Dulunya masih jarang mereka mengirim status berupa video namun seiring dengan berjalannnya waktu sekarang ini sudah banyak sekali pengguna facebook yang mengshare video yang menarik di dinding mereka apalagi sekarang sedang demam dubsmash

The Journey Begins! Participation @ #Mozfest 2015

“Participation doesn’t just happen, it’s built through great design & great leadership”

In three short weeks, the first of our Global Leadership Events: Mozfest 2015 will be upon us and with it increasing buzz of activity will be emerging as our cohort prepares for and travels to London.  Mozfest is an opportunity unlike any other to learn, teach, practice and collaborate.  We’ll use this journey to bring everyone closer to their personal goals for success at the event itself and as empowerment for our collective vision for Mozilla leadership in 2016.

This year’s Mozfest is a thoughtfully designed, energized mega-opportunity for learning to lead by – leading.  New to Mozfest this year is the addition of Pathways, best explained as a connection of sessions under one or more themes.  The most exciting part is not only that we’ve curated three pathways for Participation, but that in many cases they intersect other spaces at the festival for magnified opportunity and outreach.  Our three pathways are:

 Scaling participatory learning experiences This pathway is for participants with enthusiasm for teaching and facilitating, who want to take that passion to create resources and programs that teach others through participation.

Leading and building community through participation This pathway is for participants who want to deepen their practice on leading or building community, or who want to help people who are doing that.

New technologies for participation — challenge  This pathway is for people who want to take a technology lens through MozFest and build new participatory experiences with these technologies.

But wait, that’s not all!

We’re also excited to running many of these sessions, workshops, training and pop-up activities in our very own Participation Space.  Think  “learning, leading, making, and building” Participation all weekend – together in atmosphere intersecting  every other space in the building through pathways.

And best of all  –  all of this is a backdrop for some pretty amazing personal goals we’ll be working with each of our cohort leaders to design through 1:1 coaching.  The pathways are only the starting point in designing a Mozfest experience that brings our cohort closer to their vision for success at this event and for 2016,  personal goals they’ll be sharing out in Discourse leading up to the event in November.  Phew!

You can follow activities for this and other Global events on Discourse.  And using hashtag #Mozfest #ParticipationSpace


Image Credit:  Paul Clarke




How to Write a Good ‘Open’ Task

The act of creating tasks in an open repository is not itself an invitation to get involved. Lets be honest about the ‘types of tasks’ we’re creating, and then just design properly for those we intend for participation.

In Whistler earlier this year, we gathered together a group of code contributors to better understand what barriers, frustrations, ambitions and successes they experienced contributing code to Mozilla projects. Above all other topics, the ‘task description’ was surfaced as the biggest reason for abandoning projects.  This, the doorway for participation is given the least attention of all.

As a result, I’ve paid close attention recently to how projects use tasks to invite participation, and experimented a bit in our own Participation Github repository.  Probably the best opportunity to understand what makes a task truly ‘open’ is to  to witness in ‘real time’,  how contributors navigate issue queues.   I had such an opportunity this week at the ‘Codeathon for Humanity’ at Grace Hopper Open Source Day, and previously leading an Open Hatch Comes to Campus Day at the University of Victoria.

A quick overview of tasks I’ve noticed:

Meta Task: Meta, Parent or or ‘Feature Tasks’ are a great way to track  the overall progress of an initiative or project goals. Unless identified as being this type of task though it can lead to a frustrating journey for someone interested in participation.

Project (Team Member) Tasks:  Tasks that require whole or partial involvement of a team member (staff or core contributor) to be completed.  There’s nothing wrong with this type of task, but calling them out as  being dependent on specific individuals  – saves time. Examples: ‘root access’ server tasks, or project management tasks.

The Garbage TasksA garbage task is one that appears to have no obvious purpose,  deadline or clear outcome. A mystery to the rest of us, these tasks appear to be connected to the single moments in time for the author.  These exist everywhere – and I witness the havoc they play on contributors.  Often created in a rush or with only the author’s intentions in mind, many of these tasks linger in ‘open’ states.  It takes a contributor a long time to discover the irrelevance of tasks like these.

Storytelling Task:  Different than a meta-task,  and not quite a project task, I’ve encountered quite a few ‘issues’ with a primary goal of storytelling or conversation with an extended opportunity to provide feedback through comments.  These are great for transparency and inviting interest, but if there is no clear call to action, it’s probably better as a blog post.

Open or Contributor/Volunteer Task:  Is a clear ‘ask’, with action items suitable for completion by an individual.   Components of a good open task are:

Appropriate Tag(s)

Helping people filter to Open Issues is a huge win for project and contributor.  We’ve been using a  tag called ‘volunteer task’ for this purpose, although we may change the name based on feedback.  It’s our most viewed tag.

Clear Title

Don’t use abbreviations in titles, and have a clear action reflected.

Referenced Meta/Parent Task

Creating and referencing a Meta Task Is a great way to connect open tasks to the impact of the work being done. They also help generate a sense of collaboration and community that makes work feel meaningful.


I use this in anticipation of questions, and often include reading documentation.  Prerequisites are also a way to help people quickly  identify which tasks are best suited to their personal goals and curiosity.  I include basic skill levels needed as well – with room for learning.

Short Description

Challenge yourself to bring the key points into the short description.  Use Bullet points to break down points vrs writing long paragraphs of text.  Link to longer documentation  (and make sure your permissions allow anonymous view).

Participation Steps

I’ve written a lot about designing participation in steps, and believe that breaking things down this way benefits contributor and project.  I know this probably feels tedious especially for smaller bugs, but minimally this means linking to a template explaining ‘how to get started’. Example steps might be:

Value to Contributor

I sometimes include this, and my opinion is this is where ‘mentored bugs’ could plug in vrs a bug being only about mentoring.  In the virtuous circle for participation, I think this reminds us to consider this perspective of contributors in all we design.

Although some of this might feel like a lot of work, it actually filters out a large number of questions, helps contributors connect more quickly to opportunity and helps build trust in the process.

Here’s one I used last heartbeat
I also consider Participation Personas when I design in case they help you as well.

Image Credit: Welcome by Stav



Download Aplikasi Facebook untuk Android Terbaru

Download Aplikasi Facebook untuk Android - Sudah punya akun facebook khan.. Aplikasi keren ini tentu akan melengkapi fungsi dari android yaitu sobat bisa selalu terhubung dengan teman-teman di facebook. Aplikasi ini biasanya sudah ada di android namun untuk mendapatkan yang versi terbaru sobat kudu mengupdate aplikasi ini dengan yang versi terbaru. Pada versi terbaru ini sobat akan semakin di

The 10 different types of online learners

There is an interesting infographic on the 10 different types of online learners:

10 Types of Online Training Learners Infographic
Find more education infographics on e-Learning Infographics

These are the 10 different types of online learners:

1. Confident Learners
2. Overachievers
3. Emotional Learners
4. Integrated Learners
5. Unmotivated Learners
6. Risk Takers
7. Surprised Learners
8. Motivated/Engaged Learners
9. Dependent Learners
10. Experiential Learners


The Learning Paradigm in Online Courses

Previously, it has always been that a school is a place where instructions are dished out to students. The teacher is always seen as the "sage on stage".

However, things have changed.

Nowadays, schools, colleges and universities focus very much on learning as opposed to dishing out instructions to students. This aligns very much with constructivism.

The Learning Paradigm (as opposed to the Instruction Paradigm), emphasizes the students’ active role in learning and the purpose of that learning, which can be strong motivators for students.

The challenge for instructors is to cede some control of learning to the students.

For more information on this, please refer to the following article:

The Learning Paradigm in Online Courses
By: Rob Kelly

Reliance on e-search is 'eroding memory'

Reliance on e-search is 'eroding memory':

Cara Mengganti Tampilan Facebook Jadi lebih Keren dan Ekspresif

Cara Mengganti tema facebook - Situs jejaring sosial facebook ternyata masih menjadi daya tarik yang kuat untuk menarik siapa saja yang suka mencari kenalan baru di internet. Dari segi tampilan sampai fitur yang sangat membantu para pengguanya untuk selalu terhubung dengan teman atau keluarga. Nah untuk menambah sedikit wawasan tentang tema facebook sobat mungkin bisa mencoba berekplorasi mencari

11 Situs Jejaring Sosial Terbaru Terpopuler Selain Facebook

Situs Jejaring sosial seperti sebuah lingkaran besar dimana didalamnya terdapat ratusan juta manusia yang saling terhubung satu sama lain. di dalam lingkaran tersebut juga terdapat kelompok kelompok kecil yang biasa disebut dengan pertemanan / friends. sobat bisa membayangkan sebuah kekuatan yang ada di dalamnya bagaimana informasi bisa diketahui di seluruh dunia dalam hitungan detik. di dalam

Google launches online IT courses in India

Search engine giant Google and online education company Udacity on Monday launched IT courses in India.

Google is branching outside the US to tap India’s millions of software developers who are scrambling for jobs.

Google and Udacity teamed with Indian conglomerate Tata to offer online technical training courses. They are focusing on teaching software developers to build apps for Android.

Android is the Google-backed mobile operating system.

Costing 9,800 rupees a month, the degrees will take between six and nine months to complete, with lessons from Google instructors based in the United States.

Students will get 50 per cent of tuition costs back on graduation.

For further information, please go to:

Panduan Lengkap Cara Daftar Dan Membuat Facebook Dengan HP/Email

Cara Daftar dan Membuat Facebook -  Sungguh tak dinyana awal mula berkembangnya facebook yang di awali dengan "ketidaksengjaan" itu sekarang mampu menjaring lebih dari 1 Milyar orang pengguna dan indonesia merupakan salah satu negara yang paling banyak mengakses facebook dalam setiap harinya. Sekarang ini aplikasi facebook seolah menjadi aplikasi yang "seolah" wajib di instal di berbagai merek

12 Aplikasi Edit Foto Android terbaik dan Terbaru Gratis

12 Aplikasi Edit Foto android - Berbicara tentang aplikasi edit Foto android sama halnya berbicara tentang seni. Saat ini sudah masuk di jaman dimana banyak unsur seni yang di padukan dengan alat-alat modern. Salah satunya adalah mengedit foto dengan hanphone android. Aplikasi Edit foto seperti Sebuah perpaduan antara gaya dan imajenasi. dengan di iringi suara kamera akan membuat gaya yang biasa

Is anyone learning here?

Here is an interesting article on "Is anyone learning here?":

Some research findings:

"Researchers tracked 3,000-plus students at different schools for four years. Students took the College Learning Assessment before their freshman year started, at the end of their sophomore year, and after their fourth year of school. The key results:

45% showed no significant improvement in critical thinking, complex reasoning and writing by the end of their sophomore years, and 36% showed little or no improvement in those areas from freshman year to senior year."

The study also found that:

"Only 50% of the students took a single course that required 20 pages of writing in a typical semester, and
Just a third took a single course that required 40 pages of reading in the previous semester."

Chris Tyler (ctyler)

Running LEAP: Portable 64-Bit ARM Computing

I really want a 64-bit ARM laptop, but no one is shipping them yet -- not even Vero Apparatus.

So, I've put together the next-best-thing: a portable, wireless system assembled from off-the-shelf components. The resulting system weights ~1.8 kg (4 lb), has a 5-6 hour battery life, and fits in my laptop bag. It has microSD for storage, an 8-core Cortex-A53 processor, wifi, ethernet, and bluetooth, an external HDMI output for presentations, and 1GB of RAM. The components are held between two sheets of acrylic by 3M Dual Lock fasteners so the configuration can be easily switched up.

This system runs a version of LEAP, our experimental enterprise Linux distribution for AArch64 systems loosely based on the CentOS 7 x86_64 sources, on a 96Boards HiKey. The HiKey isn't officially supported by LEAP (yet), but we expect to support it later this year. I look forward to swapping the HiKey for a 96boards Enterprise Edition board later this year.

If you're at Linaro Connect next week, I'd be glad to give you a peek sometime during the week or on Demo Friday, and I'll blog about how the system was assembled a few weeks down the road.

13 Aplikasi Edit Video Android Gratis Terbaik Dan Keren

13 aplikasi Edit video Android gratis - Saat kamera sudah menjadi barang yang bukan mewah lagi maka hampi setiap orang bisa mengabadikan moment-moment penting dan lucu mereka lewat kamera entah itu camera digital atau lewat ponsel bahkan tak sedikit dari mereka yang rela meluangkan waktu untuk mengedit video mereka. Nah.. berbicara tentang edit video itu bukan hanya sekedar hobby saja, ada juga

Review of Netgear Arlo

Netgear sent me their Netgear Arlo camera system making me one of their product ambassadors and wanted my honest feedback on the product, so I spent a few months now evaluating Netgear Arlo and here is my thoughts.


For me, technology needs to be simple to setup and configure and Netgear Arlo was rather simple to install. I simply drilled in some screws for the camera mounts and attached the cameras and then setup the base station and synced them. The whole setup process took me no longer than ten minutes. Although, fine tuning the position and sensitivity of the motion detection did take some time to get right.

Web Interface & Mobile App

Video Still from Arlo NetgearVideo Still from Arlo Netgear

So during my first few weeks of checking out Arlo, the Android Mobile application had some usability issues and crashed until Netgear released an update which did take another few weeks. This was sort of frustrating but these things do happen. Overall, my experience once the Android app bug was fixed was positive and the app worked well and was easy to use. The web interface worked well too. It seemed I would frequently get an error about the base station not being responsive via the web interface and this error never seemed reproducible in the Android app, so it felt anecdotally like this was an issue in the web app.


While I received the Netgear Arlo for free, I did check out the price of the Netgear Arlo and it seemed very reasonable priced and comparable if not lower priced than other competing systems.

Night Vision and Effectiveness

Surprisingly, while using the Netgear Arlo one night it detected someone on the property and I called the police and later found out the individual was casing homes and was arrested. If it were not for Arlo, I do not know how that would have played out and it makes me feel much more secure knowing I have push notifications whenever Arlo detects motion. The night vision built into the system lets me monitor night and day.

While there are still some optimizations I think Netgear can make to improve how long it takes for a recording to start once motion is sensed, I really found the Arlo to be a good product.


One disappointing aspect of Arlo is that while it’s an internet connected device (and maybe even a IoT device if you will), it so far has no third party integrations like IFTT, WeMo, Phillips Hue or others. This gap left me desiring more in this regard.


Netgear Arlo SystemNetgear Arlo System

For the price point and what you get in this system, Netgear Arlo is a useful tool to help improve security around your home or business. It has helped me in the situation I described above and I have been impressed enough that I have reccomended it to several colleagues who ended up getting the system themselves and also are benefiting from the product.

I think Netgear has a good product here and much potential to continue to improve and optimize it and make it best system out there.


Disclaimer: Netgear provided the product free in exchange for an honest review.

Cara Mencari dan Melihat Semua History Gambar Google Doodle

Gambar Google Doodle - Sebuah mesin pencari dimana milyaran manusia merasa sudah dekat dengan namanya. mesin itu di beri alamat "google" sebuah nama yang bisa memberi jawaban atas pertanyaan kita. ketika sebuah perangkat sudah terhubung dengan internet maka mesin pencari ini seakan sudah siap menunggu apa yang kita tanyakan. Google akan memberikan tak hanya satu jawaban saja Google akan

Computers in classroom have 'mixed' impact on learning

Computers in classroom have 'mixed' impact on learning: OECD report

OECD - Organization for Economic Co-operation and Development

"The key to any technology rollout in the classroom is clear goals and training for teachers, but ultimately it is about training good teachers."

My Volunteer Opportunities this Heartbeat

I am returning from a couple of weeks away: rested and super-energized about what’s coming next for the Participation Team and community leadership.

Based on research in the last two heartbeats we have now have an v.1 of Participation Leadership Framework, and we’re fired up and ready to go for the next three weeks developing and testing curriculum in line with that framework.

Volunteer sub-tasks volunteer for my heartbeat are: Curriculum QA  and ‘Workshop Co-pilot’. The first is really just about staying connected to the work, and providing feedback and suggestions through review.  The second is more of a role for this heartbeat, for someone interested in improving as a facilitator by co-piloting a couple of online workshops with me, and then running an offline version with local contributors in their region.  Please reach out in the task comments if you are excited about doing something like this!  As with previous volunteer tasks, there are more details in the issue.

Note: we also have ongoing development work on a fork of  in an effort to test the import and display external markdown files as content.  Thanks to @asdofindia for his great work and recent Pull Request to help this along.

For more on contributing with the Participation Team and the Heartbeat process check out our


That’s it!  Except as a final thing I thought I would share all the books that were recommended to me when I asked for suggestions for my time away. I highly recommend time away with books.







Help Us #SaveWiFi

fccMaybe you have not heard, but the Federal Communications Commission is currently considering a proposal which would allow the agency to regulate device manufacturers and make them lock down certain wireless devices such as routers.

This is not good news because if passed, this means OEM’s could prevent users from flashing free and open source firmwares like OpenWRT or other custom firmwares on to hardware they purchase. This is not very consumer friendly and not to mention router OEM’s like Cisco, Linksys, Belkin, Asus, Buffalo, and others are not that great about updating the internals of their firmware and sometimes leave users with firmware that exposes them to security vulnerabilities.

I wanted to write something short and encourage folks to please go and comment here. If this proposal passes, it could have an international impact unless OEM’s decided to ship a U.S. version and International version of their routers which is very unlikely.

Read more about this here, go and leave a comment here and tweet #SaveWiFi and spread the word across the web!

Update on Glucosio

Glucosio is an open source project I founded recently. I blogged about the kick off here. I wanted to give an update as the project is moving forward better than I had imagined.


We are currently aiming for our Glucosio for Android Alpha release this month with a tentative release date on September 20th, 2015. This being our Alpha and our first public release will be the base of the app. It will have basic functions but the more advance features on our roadmap will be distributed across subsequent releases and I’m sure we will keep coming up with innovative ideas as we research the needs of people with diabetes. Hat tip to Paolo, Ahmar, Satyajit and Elio who have been working tirelessly on this release.



I’m happy to report that Glucosio is already translated into 13 languages. More specifically: Albanian, Arabic, Bengali, Bengali (India), Breton, Bulgarian, Chinese Simplified, German, Italian, Spanish, Spanish (Venezuela), and Spanish (Mexico). We plan to have Greek, Japanese, Vietnamese, Malay, Portuguese, Russian, Hindi before launch. (Want to translate these for us? Check here.) Translations are really important to this project because every language we can offer is a population of people we can reach with our app seeing as diabetes is a global problem. The more people we reach worldwide, the more we can offer great tools to and the more opt-ins to share anonymous trends and demographic data with diabetes researchers we can get. Hat tip to Arturo who is leading our l10n efforts!



We are still actively looking for a lead iOS Developer or even two people contributing part-time on our Glucosio for iOS product. If you know someone, tell them to ping me!

HTML5 App (Firefox OS, Ubuntu Phone and Tizen)

This is sitting in our backburner but it is definitely within the scope of our vision and will help us reach platforms like Firefox OS, Ubuntu Phone and Tizen. We initially looked at doing cross-platform development but realized we could give a better experience if we built individual apps for Android and iOS.



Currently, this project has been very low cost thanks to some great supporters. Other than that, I have bootstrapped any costs, which again have been very small. We have decided from the start of this project that we do not want to monetize our apps because we feel it will dilute our vision and goals for the project. That being said, maybe the team will look into donations, crowdfunding or other options in the future if it becomes necessary. We are also looking into becoming a SPI (Software in the Public Interest) associated project so we will have a financial home and some resources available to us.


What’s next?

We are just going to be focusing for the next few weeks on getting this Alpha out the door. That includes wrapping up translations, doing some internal testing, and making sure we get out a crisp Alpha (that happens right?). Then we will sit down and discuss next things we want to prioritize and have a release post-mortem to improve our next cycle.


How you can help?

We have a really great team of people and would love to have more help. It has so far helped for us to have lots of hands in the pot and allowed us to scale as a project and get a lot of work done in a very short amount of time. If you are interested in contributing, hit us up at hello [AT] or ping us on Twitter at @GlucosioApp. We have contribution areas to include Development (iOS/Android/HTML5), l10n, Marketing, QA, and more. Hopefully by our Beta release, we will have some crisp documentation on our wiki on how to get started on all of these pathways!



Mozilla Thimble – Test Drive of Happiness

In the last few years I’ve learned a ton about what helps people learn, where they get stuck and how to customize learning for various ages, interests and attention-spans. When ‘teaching the web’ for kids as young as eight all the way up to university students there’s always some level of trouble-shooting and  tinkering to do with tools I’ve tried so far (both on and offline). Mozilla’s Thimble had been one of those tools, but usually for the very early steps in learning.  For more advanced lessons,  I’ve tried a number of different solutions, all with some level of challenge.  For example I turned more to to show the separation of CSS/HTML & JS which was fun but only for super-short snippet-type learning.  I also ventured offline with simple editors like Notepad ++ only to run into knowledge-blockers with students – around file-systems or computer permissions for installing new software.

And so, I was super-excited to see the latest version of Thimble released this week – especially after I did some testing. Here’s why I’m  to go back to teaching with the (new) Thimble :

Customizable UI

The new Thimble allows you to expand your code view, or your preview as you need. Seems small, but huge change from the previous version.  With this, the brightness toggle, and text-size customization people will be able settle in to what works best for their learning.  And thank you, thank you – the preview screen stays at the exact-scroll position for refreshes.

Mobile View

Many kids  ask to make ‘apps’ in my classes,  when often what they really mean is “something  I can make and share on my phone”.  So while the mobile view is obviously great from the perspective of learning to design for mobile, it also helps students understand the web as a platform for their app ideas.  I imagine there’s more opportunity to extend that idea well beyond this as well with FFOS app preview perhaps.

File Management

A billion-times better.  Students can  now upload files they need vrs  ‘all code in one page’, or link to external files, which with  previous versions often resulted in mixed content errors.  Yes, so much awesome, including the ability to re-name files names AND upload entire directories, which makes it easy ( I think ) for people to fork and upload projects. I managed to exceed the maximum file-size for upload, but at 5MB seems pretty reasonable.  Having files lists also ‘bakes in’ an opportunity to teach file systems, best practices, naming conventions etc   – which in the past was offline only.  The only thing I couldn’t figure out, was how to download my project. Also next-wish : version control integration.

You can also take and upload ‘selfie’ images from your computer, which will be super-popular, especially for ‘photo booth’ type projects. Youth will love it, providing it passes the privacy agreements of students and schools – but then there’s a lesson to be made with this as well.

Suggested Attributes & Files

One of the biggest challenges and frustrations  of getting things working –  especially with younger kids is spelling mistakes of file names, attribute names – open tags, poorly nested tags… And so I’m thrilled to see suggestions & auto-complete as part of the new Thimble. Also showing which line has errors (without overwhelming popups) will be a huge help. I think there is also a way to use a color-wheel to add in hex colors (also helpful for younger learners), but I didn’t have a chance to test that.


Adding a tutorial.html file adds a ‘Tutorial’ view pane. I usually write my lessons in Google Docs, print and then give to students who are still learning to type, and so spend a lot of time looking from one to the other.   Huge win that instructors can write tutorials as part of the lesson, and that students can keep their eyes on the screen instead of bothering with a second set of instructions.  The only improvement I could ask for, would be the ability to assign specific tutorials, to files to create true lesson plans vrs one long file (also more value for sharing).

I’m sure there are a bunch of things I missed, but these are the wins for my classes.

Congratulations, and thank you to the Webmaker team, this is going to make things so so so much easier, and more rewarding for students and teachers.

On a separate note – I can’t help but think this would also help some of the curriculum development I’m working on – asking teams to develop content in Markdown.  I see there is a Markdown extension for Brackets, and wonder if Thimble can take on a new file type ‘markdown’ to help educators submit curriculum without coding knowledge.  Perhaps this is what that’s the potential for the tutorial file (and collaboration between educators and technologists)



Participation Leadership Framework 0.1

In the last heartbeat, as part of our Q3 goals for leadership development,  I interviewed a diverse set of people across Mozilla, asking what they think the skills, knowledge and attitudes of effective Participation Leadership at Mozilla are.  Two things really stood out during this process.  The first was how many people (staff, contributors and alumni) are truly, truly dedicated to the success of each other and Mozilla’s mission, which was really inspiring and helped inform the quality of this Framework. The second was how many opportunities and resources already exist (or are being created) for leadership development, that if bundled together,  with more specifically targeted curriculum and focused outcomes will provide powerful learning by Participating experiences.

This Heartbeat iterated on themes that emerged during those interviews.  I thank those who provided feedback on Discourse, and in Github, all  of which brought us to this  first  0.1 version.


Foundations of Participation Leadership are the  core skills, knowledge and attitudes that lend to success on both personal goals, and goals for Participation at Mozilla.

Building Blocks of Participation Leadership are units of learning, that together provide a whole vision for leadership, but individually build skills, attitude and knowledge that inform specific learning outcomes as needed.

Examples of skills, leadership and knowledge for each:

Personal Leadership

Essential Mozilla

Building for Action and Impact

Empowering Teams and People

Working Open

Developing Specialization

We would love your comments, suggestions and ideas on where we are so far. In the next heartbeat we’ll begin building and running workshops with these as guide, and further iterating towards 1.0.


Image Credit: Lead Type by jm3


FOSS Field Trip

This post is related to my participation in the POSSE 2015 Stage 1 Part B activity “FOSS Field Trip”. I chose to explore open source projects related to healthcare. 2490 projects on Sourceforge matched the search with keyword “healthcare”. These projects used 15 programming languages were used; Java, PHP, C++, and JavaScript were the most used. I compared two projects OpenMRS, whose status is Production/Stable, and Digit Span Tester, whose status is Inactive. As expected, there was much higher activity and a larger code base associated with OpenMRS.

I into YAWL in a bit more detail. YAWL provides support for modeling and managing workflows. Two major audiences of YAWL are most likely people who deal with business processes and people who deal with healthcare processes. YAWL is primarily written in Java and the last changes seem to have been made this week. The project seems pretty active based on the recency and the frequency of commits.

In another activity part of the “FOSS Field Trip” I evaluated the OpenMRS project for  suitability to use as a class project. Here is the rubric with “Mission Critical Criteria” filled out:

Evaluation of OpenMRS

OpenMRS is a potential candidate project for a course on software engineering in healthcare that I am developing. It is related to a class module on electronic health records. Furthermore, the primary programming language used is Java, which is the main language in our curriculum. OpenMRS scored high on my evaluation using the rubric above.

Changes and Tendencies of Today's Training

The changes and tendencies of today's training can be due to the following factors:

1. Use of mobile technology,

2. Adoption of social learning tools,

3. Alignment with corporate objectives,

4. Use of adaptive learning principles, and the

5. Ability to measure effectiveness (both informal & formal learning)

For more information on the above factors, please visit:

FOSS2Serve – Blog Activity

This is the required report from POSEE 2015 Blog Activity detailing my experience/answers from the FOSS Field Trip.

Part B, Part 1 Activities 3-9: FOSS Field Trip – SourceForge

(3)-(5). I searched for “sports” and it returned 96 programs for “windows” and “recently updated”; 671 removing the “recently updated” filter. The projects represent 15 different programming languages (predominately Java / C++; then C# and JavaScript).

(6) SourceForge’s project statuses are as follows:

(7) I compared the Kendo Tournament Viewer software, currently with a “planning” status to the Tux Football software, currently with a “beta” status. Both projects actually seem to be in the same phase of development. They have both been updated in the last 6 months, can be downloaded, installed and run and have gone through at least two minor versions. Sourceforge notes that as of 5/28/2015 neither project is being actively developed and neither project has any clear plan of future features to be implemented. My guess is that the Kendo Tournament Viewer software simply never updated its project status from planning.

(8) You can tell which projects are most used by the number of downloads (both in the last week and other time ranges). Although, downloads don’t necessarily imply usage.

(9) The Kendo Tournament Viewer project is a fun arcade-style 2D football game for Windows and Linux, very reminiscent of Sensible Soccer and Kick Off. It was written in C++. This project appears to be a fun/class project and is intended to be play by young adults / those interested in playing soccer games. The project has a single developer/committer, was most recently updated on 11/14/14, and does not appear to be currently active. I would not likely use this software because computer games are not of interest to me.

Part B, Part 2 Activities 4-13: FOSS Field Trip – OpenHub

(4) The main programming language of OpenMRS appears to be Java and JavaScript.

(5) There are 3.8 million lines of code (6.1 million total lines, including comments) in the OpenMRS Core project.

(6) The contributors (i.e., developers) appear to be from the US and South Africa

(7) The OpenMRS Core project is written in 15 different languages. See

(8) JavaScript is the secondmost used language in the OpenMRS Core project. See

(9) Java is the language in the OpenMRS Core project with the highest comment ratio (35%)

(11) The average number of contributors in the last 12 months is gateway timeout.

(12) The top three contributors have been involved in the project for gateway timeout.

(13) The average number of commits over the past 12 months, as computed using the information on the project summary page is gateway timeout.

Part B, Part 3 Activity 1: Project Evaluation Criteria

Mission Critical Criteria – Suitability

My evaluation rubric for OpenMRS is as follows:


Personally, I thought that this activity was informative but, at times, repetitive and tedious. I can see how the OpenMRS project could immediately be incorporated to the software testing / software quality assurance classes I teach each spring semester.

FOSS Field Trip

For the FOSS field trip assignment, we were asked to visit SourceForge and choose a category. Although SourceForge has changed from what it once used to be (the repository of open source goodness) to more of one place among many (e.g., GitHub), it’s still a good place to find free and open source software. For the second half, we were to evaluate OpenMRS at Open Hub.


I immediately went to one of my favorite areas–Security and Utilities–and looked within the Cryptography Software sub-category. After all who doesn’t want to obfuscate data and store information from prying eyes?

Even though the overall number of projects in this area is smaller than most of the other main categories (e.g., Games) it still offers 220 projects in various status categories. Moreover, the top languages tend to represent those with more maturity: Java, C, C++, and Python. This benefits the applications themselves as well as the potential for possible contributors.

Surprisingly, many of the offerings were in beta or above status markings. This should reflect a set of robust applications. However, one should not rely completely on the project status. Let’s look at two offerings: Password Safe (Production/Stable) and RetroShare (Beta).

Password Safe has 3,319 weekly downloads at the time of this writing. Moreover, it has a fully functional and developed external Website with endorsements as well as a donate link. It has developed support (738 posts) and development discussion (943 posts) lists, an active feature and support ticket list. Password Safe is rated at 4.8 stars with 227 reviews.

Although RetroShare is in beta status it still has 928 weekly downloads. Unlike Password Safe, it does not have an external Website nor are there discussion lists. It does have a more active bug tracking list with 241 closed tickets and 149 open tickets. There are four active developers as opposed to Password Safe’s one maintainer suggesting that there are more bugs and features are still being added.

Even though Password Safe is listed as stable and RetroShare as beta, both have wiki announcements dating back to 2007. This suggests that more than status listings need to be considered when attempting to determine any application’s robustness and overall development complexity.

Finally, Password Safe’s code base is predominantly for Windows OS only. Windows users who want an open source password management program that has been vetted by experts might consider this application. Password Safe was started by Bruce Schneier and is endorsed (and sold) by Yubico and endorsed by the Open Source Initiative. Security professionals will be well aware of Schneier’s good reputation and Yubico’s track record. The project has a Linux beta client, so those who use the Linux OS need to be cautious when entrusting their information to this application.

Open Hub

OpenMRS has its own very developed website, but also can be found at Open Hub. One general comment about Open Hub: this site provides more granular data in a much easier to use interface than SourceForge. It is quite simple for users to learn more about the developers and robustness of a project on Open Hub.

The Project Summary page is an excellent snapshot of the project in terms of a description, code base, and detailed commit information. I plan on using this site as an introduction in classes as it enables students to see a quick snapshot as well as drill down into more detailed information such as how much each contributor has participated in the project.


Overall the field trip was a useful experience and one that I plan on using with my classes as well. The Open Hub site will make it easier to students to compare and contrast various projects. Adding the SourceForge project status definitions will add another layer of richness to their FOSS research.

Our blogs