Usability Issues With The University Of Ottawa's Blackboard Learn

By Borke Obada-Obieh

Blackboard is a company that develops learning management systems for institutions. They offer many software solutions and boasts of having a very large customer base. Based on their official website, 80% of the world’s academic institutions that were highly ranked by Times Higher Education, made use of their solutions as at 2014 [1]. They further explain that their solutions are being used in 1 of 3 US school districts and they currently have a subscriber base of 20 million students [1]. It is however unclear what exact solution is being utilized by such large amount of people. 

The University of Ottawa (uOttawa) makes use of a customized version of one of their software solutions, Blackboard Learn, for the school’s Student Portal. A user interface evaluation was carried out on uOttawa’s customised version of Blackboard Learn and a number of usability issues were discovered. However, it is unclear if these issues are peculiar to uOttawa’s Blackboard Learn or the generalised version. 

The participants involved in the evaluation were six students from another university who have previously never used Blackboard Learn. This blog post presents the major problems that were identified by participants in the user evaluation and also by the researcher. The problems identified have been grouped based on the usability principles described in Dr. Timothy C. Lethbridge class notes [2]. The post also illustrates instances of how these principles were violated, and possible solutions to the problems that were identified.

The Undo History of the Windows Notepad should not be Limited

By Segun Odunade

For users of the Windows operating system, the Windows notepad may be very useful such that users can easily create and edit unformatted text. I happen to use this utility a lot for my word document editing because it has an exceptional feature of removing all formatted text file pasted on it’s interface. For instance, say, you are working on word and you want to copy a specific amount of text from the internet to your document, copying the text directly to word will cause the format you are working on to change, the user is then left with either editing the changes or using the “paste special – unformatted option” on Microsoft word; both options don’t always yield optimum solution. The problem with the paste special – unformatted option on word in Windows is that it sometimes fails to remove all formatting, which can mess up the whole document. However, copying the text to notepad first will assure the user a clean unformatted text which when copied to word will adjust to what format the user was using. The notepad has its usefulness beyond text editing, however, this blog will focus on the undo functionality of the notepad.

While considering the above mentioned text editing benefits of the Windows notepad, I find it very frustrating that till this day, the notepad can only undo once. This extremely limited undo functionality can give users like me a lot of headache because often times users may want to return several steps back from the changes they have made while editing on notepad.

1. Requirement

The Windows notepad is included in all of Microsoft windows since Windows 1.0 in 1985 [2].

2. Snippet Illustration of the Windows Notepad Undo Problem

1. For instance, if the user type’s “My name is John and I am 50 years old” on the notepad interface as shown below in figure 1. This snippet was taken from the Windows 10 Operating System.

Fig 1: Snippet Illustration of the initial text typed by user

2. And the user decides to change “John to Adam” and “50 to 40”, we have:

 

                            Fig 2: Snippet Illustration showing text changes made by user

3. If the user decides to go back to the initial state i.e. going back two steps by pressing the undo key “control Z”. Windows notepad only goes one step back such that only the last change made is reverted.

 

     Fig 3: Snippet Illustration showing notepad not being able to go more than one step back

Assuming the user had forgotten what he or she typed initially or the user had made multiple changes, the information the user needed at that time would have been lost.

3. Likely Cause of the Windows Notepad Undo Problem

One of the likely causes could be that the first versions of the Windows notepad were made to perform only a step back ability of keeping track of user’s records [1]. Modifying the windows notepad now to accommodate unlimited undo functionality may affect many parts of it’s source code which would cost the Organization “Microsoft” more money to implement. Due to the reason mentioned above, the Windows notepad undo problem is a foundational problem.

4. Suggestion

Although, there are now alternatives to the Windows notepad such as notepad++, notepad2 and freeware which are designed and developed by third party organizations. Since this third party organizations have gotten it right, I suggest that Microsoft should adopt one of this text editing applications as a form of software update that overwrites the notepad because most users don’t even know this third party text editing applications exist and some of this applications may be difficult to install for non tech-savvy users.

5. Conclusion

The Windows notepad is an essential utility for text editing in the Windows operating system.  The extremely limited undo functionality of the notepad is a fundamental problem has discussed above and updating this utility to include unlimited undo functionality, syntax coloring, code folding, color schemes e.t.c. [2], with a similar and outstanding application will boost the usability of the Windows notepad as a whole.

References

[1]  Eelke Folmer, Jan Bosch “Architecting for usability: a survey” Science Direct Journal of Systems and Software, Volume 70, Issues 1-2, February 2004, Pages 61-78.

[2] “Notepad”, from Wikipedia, the free encyclopedia. Available Online: https://en.wikipedia.org/wiki/Notepad_(software).

JPA/Hibernate Usability Issues and Solution

By Neha Dhingra

It is not progressive to believe that Java Persistence API (JPA) is ineffective without JPA implementations, but I do consider that we need to determine the appropriate framework depending upon the usability of the API. Although every JPA implementation commercial or open source has some intricacies and defects to be accepted and amendments to be implemented.

JPA/Hibernate Usability Issue

There are moments that JPA can do further harm than good. Following you will comprehend the JPA/Hibernate usability defects and some clarifications to these problems:

Composite Key: These are the significant problem for a JPA developers. Mapping a  composite key is a  huge complexity to the project and the process needed to persist or locate an object in the database using Java classes adds further steps. When you apply a composite key in Hibernate several problems will happen one of them is implementation bugs and handle Java Hash codes for mapping. 

Legacy Database: A  developer often builds a project on a lot of business rules in the database with Hibernate's abstraction level this can be an intricacy while invoking a simple StoredProcedures or  a Functions.

Artifact size:  In Hibernate the artifact size increases a lot with dependencies, that further increases the size of the created jar/war/ear file in the project. For a developer increase in the size of artifacts is difficult to manage if the application is remotely accessed by several servers in low Internet band (or a slow upload). For example, If in an API it is mandatory to add and modify  10 customers servers across the continent. One of the notable problem with slow upload, loss of Internet  and corrupted file can happen to make the development team to lose time in handling discrepancies.

Complex Query: In projects that have high-level  complex queries with accessing database resources like   MIN, SUM, COUNT, HAVING, MAX, etc. If we consolidate those high-end complex queries through Hibernate JPA the task becomes complex using Java classes it's difficult for an unfamiliar developer to handle.

Object Oriented Programming (OOPs) complexity: Performing CRUD operations with Hibernate JPA is a very simple process, however, the  problems appear when we commence using entities relationships mapping through inheritance, caching, PersistenceUnit creations, PersistenceContext among several entities, etc. A team of developers without a with a good JPA experience will dissipate a lot of time  and effort to develop and understand  JPA ‘guidelines‘.


After examining all the obstacles above you might consider a question: “Is Hibernate JPA good?”. JPA has a lot of benefits but that is not to be considered in this post because that is not the theme of the post, JPA is a tool that is indicated for a lot of circumstances. Some of the Hibernate JPA advantages are portability among implementation, reducing development time, making database creation very easy,  2 level cache for optimization, and several tutorial and community support, etc.

In the next section, we will discuss some of the solutions for the problems mentioned above, the solutions could accommodate you to avoid a huge persistence framework problems.

Solutions to  JPA/Hibernate usability Issues

Composite Key

A possible good solution to the composite key would be functional support in JPA though methods and interfaces. Furthermore, If a developer wants to add the composite key in the projects; they can do so using @Embeddable classes. Although the process to create Embedded classes is complex but through these entities a developer can customize the application based on specific business rules. Fig. 1 shows a small example of Embedded classes between Employee and EmployeeID. In the example below EmployeeID is embedded to persist a composite key roleID and EmployeeID.

Fig. 1 Embedded Class

Legacy Databases

To develop an application, in Hibernate JPA, a developer often chooses version  an implementation based functionality support,  to ease the problem the best solution would be to use Eclipse IDE, which adds implicit upgrade support for developers. If a JPA version upgrade is not supported then I don't think JPA would perform optimally. Fig.2 display the easiest way to upgrade version in Eclipse IDE.

Fig .2 Upgrade JPA version In Eclipse IDE

Artifact Size

The easiest solution to artifact size problem would be to develop the JPA implementation using other implementations which suit best in the scenario such as EclipseLink, OpenJPA or Data Nucleus. Although refactoring is a  problem while using hibernate annotation/resources; the change would be advantageous before further load increases.

Generated SQL and Complexes Query

Hibernate solves the complex query problem through its native and JPA specific Query language. Through Hibernate, a developer can create customized named NativeQuery. With so many resources, a developer  could create a simplified query or optimized SQL complex Joins, but because of Hibernate's over ambitious nature a developer has to manage too  much caching while loading objects.

In a project with only one database vendor, the NativeQuery support will not be a difficulty.The advantage of this composite approach Java Persistence Query Language (JPQL) and Hibernate Query Language (HQL) NativeQuery would help the developer to create a complex Stored procedure and Join with such ease and possibly adds to JPA advantages.

OOPs complexity

A possible solution to the problem can be use optimized queries (with NativeQuery), query pagination and small transactions in Hibernate which are easy to implement by an unfamiliar developer.

By avoiding the use of  using EJB with PersistenceContext,  a developer can further extend and reduce memory consumption by increasing processing of the server.A possible solution would get an entity from the database in a read-only format. For example, an entity can be accessed only as a report. Following code below create a read-only entity:

String Qty = "select EDesignation from Employee E";

EntityManager entityManager = entityManagerFactory.createEntityManager();

TypedQuery<Employee> typedQuery = entityManager.createQuery(Qtyquery, Employee.class);

List<Employee> resultList = typedQuery.getResultList();

The code above has no open transaction, all the returned  values in the entities above would not be monitored by JPA. In the case of Enterprise Java Bean (EJB) container a developer has to mark the transaction with @Transactional(readOnly=true).

Usability Issues in Data Nucleus Plug-in configuration in Eclipse IDE

By Neha Dhingra


Plugin in an API is mainly configured to set up libraries and additional functionality in the application. In this post, I am trying to uncover the defects in an API plugin in Data Nucleus implemented though EclipseIDE.

Problems In the Plugin

Firstly plugins in any API are additions to whatever already exist in the API or in particularly a java based project. These are Jar files which are added to the classpath based on the developers configuration and compatibility. In Data Nucleus adding a plugin is an additional complexity because the process is explicitly defined by the developer; it's divided in two step the first is adding Data nucleus Enhancer and the second includes a Data Nucleus Schema tool Fig .4 and Fig .5 shows how to configure Data Nucleus in a JPA implementation.

After the plugin configuration, you can now add DataNucleus support on your projects. Simply right-click on your project in Package Explorer [1]and select DataNucleus->" Add DataNucleus Support"[1] from the context menu as depicted in Fig .1 and after adding the Support the user will have Data Nucleus support as shown in Fig 2. For an unfamiliar developer, the process of enhancement and schema configuration becomes so complex and lacks in properly documented help regarding the issues that arise in the metadata creation.

Fig. 1 Package Explorer>Data Nucleus>Add Data Nucleus Support

Fig . 2 Data Nucleus Support Added

This addition in EclipseIDE further adds the complexity by forcing the developer to enhance the Java classes manually or by using a command line before creating any schema to persist in the database. The implementations add more de-facto problems with compatibility issues between EclipseIDE and JPA implementation. Fig. 3 shows how to manually enhance the Data Nucleus Enhancer Tool and Chema Tool using File>Data Nculeus>Run Enhancer Tool. Data Nucleus increases the further complexity of performing this task every time a developer Runs the API. Even though the automatic enhancement has been chosen the developer still has to perform these steps for metadata creation.

Once you have defined your entities in JPA, the developer has to  enhance the classes in order to create metadata. Then,  the developer has to configure database creation through schema (assuming you will be adopting a new schema   disregard this step if you previously have your schema).  The process seems easy but it has several usability issues for an unfamiliar API developer.

Fig. 3Manually Enhancing in Data Nucleus Enhancer

1)The developer has to check whether metadata is created before using the schema tool. Metadata in Data Nucleus is created by Enhancer Fig. 4 shows the options to configure the enhancer using Data Nucleus through JPA/ JDO implementation.

Fig .4 Adding JPA Implementation in Data Nucleus Enhancer

2)The developer has to Click on the project under "Package Explorer" [1] and under "DataNucleus" there is an option "Run SchemaTool" [1] as executed in Fig. 4. This brings up a panel to define your database location (URL, login, password etc) shown in Fig.5.  Even through entering these details in the persistence file the developer has the hassle to enter the same information twice in the panel for schema generation. In Fig. 6  the schema is configured to configure the connection to the database. The process adds further complexity by requiring the developer to explicitly choose .class files.

Fig. 5  Data Nucleus Enhancer 

3)In the same panel even if the developer modifies the enhancer  as showing in Fig. 4 when a developer changes JDO implementation to JPA, the panel switched back to JDO by default. This is a huge trouble for an unfamiliar developer because of lack of experience in the application. Even its complicated for a developer to troubleshoot the problem arising from the switch.

Fig. 6  Data Nucleus Schema Tool

The second thing to note is that the DataNucleus plugin is for Eclipse only using "Java project". Although Data Nucleus is a Java persisting API  but this restriction affects the "API adoption" strategy.






The Solution

The Data Nucleus development team are currently busy on improving  the implementations by increasing the level of abstraction in the API,  improvement in efficiency  and so on.

However, it would be beneficial to providing an official guide to plugin UI and the best practice would be more advantageous in the long run than the sum of all the improvements that they are currently managing to achieve. Another alternative would be to reduce the number of  persistence steps to be performed manually.  To persist Java classes into the database the developer is dependent on plugins, and I consider that everyone who has  experienced disappointment as a result of poor plugin UI usability would agree.

Plugins play an integrate component of an API. They are an enormous part of the reason as to why JPA implementations are the most popular Java APIs. If Data Nucleus developer wants to truly increase the usage of the implementation, it to create a complete package – plugins and all.


Reference

1)Data Nucleus http://www.datanucleus.org/products/datanucleus/jdo/guides/eclipse.html

Usability Issues in Flat Design

By Mohammad Rehaan

Flat design is the latest trend in the field of website design and it is being widely used by freelance designers and big name companies like Microsoft. Flat design is a style in which a sense of three-dimensionality is absent. This enables the designers, including myself, to create beautiful UI designs which are minimalistic in nature. But the overuse of the flat design can cause serious usability issues and I am going to share my observations where I believe flat design, despite of having beautiful presentation, is actually abusing the user experience.

1.     Absence of familiar patterns (underlined text for links, borders for buttons etc.):

VWO is one of the websites which is heavily based on the flat design concept. Although they have tried to solve the usability issues to a great extent, there are few places where components totally fail to convey their actual meaning. One of the places is when we go to create a new AB test campaign. It provides a functionality of switching between two different modes of working i.e. ‘SIMPLE’ or ‘ADVANCED’. This feature was the first ever feature I developed when I used to work on this product at the company. Since then, I always wanted to change the way this button looked. There was only a text like button which actually does the job of switching modes and it is pretty hard to say by only looking at it that it’s actually a button.

Fig 1 : Create new campaign view with a button component with no important signifiers

Suggestions: Although it is clear that having a button with dark background above the search bar would hurt the aesthetics but having a thin border around the text or a line under the text would have successfully delivered the meaning of this button, thereby enhancing the user experience.

2.     Absence of important signifiers (gradients, shadows, highlights etc.):

Another instance where flat design came in the way of smooth user experience would be the home page itself. This is a special example where in spite of solving the problem of flat design, it still somehow failed to deliver the actual meaning of the components. The list item contains a lot of components including links, and buttons, which are consistent with other part of the website. The list item also has a thick border at the bottom giving it a three-dimensional feel. Still, it is not clear at the first glance that the complete list item is itself a clickable area and the whole list item has a uniform clickable area. Also, few components inside the list item individually represent clickable items if we assume them as consistent with other areas of the website, but they are also disabled which creates a huge sense of confusion at first.

Fig 2 : Home page with list item and possible sub components

Suggestions: Traditional methods (background highlight on hover) of delivering the actual meaning of actionable items would have easily saved the confusion of clickable list. Changing the styles of individual items inside the list can also help to reduce the initial traction.

3.     Absence of contextual Indications (CTA placement, actionable copy etc.):

The approach of minimalism might also affect negatively on the conversion rate of a website by hurting the positive impact of a button on a user who might be a potential customer. Flat design, if done wrong, could result in to designs which may look minimalistic and free from all the clutter, but they actually render the whole design as boring. One such example is shown below where conversion rate dropped by 12.29% [3], just by removing the green arrow icon on the button.

Fig 3: Results showing the considerable decrease in conversion rate [3]

One more example is the ignorance of CTA buttons that are supposed to be the first point of contact for the potential customers. While following minimalism, often times designers tend to ignore CTA buttons on a page. However, ignoring the power of CTA buttons should not be underestimated which is demonstrated by the following experiment. In this experiment, the button text changed having more words. Clearly, the attempt to make the button smaller and having less text was not proving as fruitful as it it was expected to be. It is necessary to convey more value and relevance via CTA buttons to achieve more conversion [4].

Fig 4: Results showing the increase in conversion rate with more meaningful text on the button [4]

4.     Conclusion:

Flat design has changed website design completely by implementing minimalistic design and beautiful user interfaces. Flat has enabled the developers to create more efficient pages (case study) with comparatively smaller loading times.  But the current flat design has some serious usability issues that needs to be addressed. One of the major drawback of flat design is the lack of the sense of three dimensional components which makes it hard to notice the actionable components. A possible solution could be to implement flat shadows that solves the problem of adding z-axis while maintaining the aesthetics of the flat design. One such example can be seen in the latest Flat 2.0 approach introduced by the Google material design.

Fig 5: An example of google material design [5]

5.     References:

[1] Design Trends: Flat Design 2.0, http://www.webdesignerdepot.com/2016/02/design-trends-flat-design-2-0, Accessed: 09/02/2016

[2] Flat Design: Its Origins, Its Problems, and Why Flat 2.0 Is Better for Users, https://www.nngroup.com/articles/flat-design/, Accessed: 05/02/2016

[3] How To Design Call to Action Buttons That Convert, http://unbounce.com/conversion-rate-optimization/design-call-to-action-buttons/, Accessed: 12/02/2016

[4] How To Write Call To Action That Converts With Case Studies, http://unbounce.com/conversion-rate-optimization/how-to-write-a-call-to-action-that-converts-with-case-sudies/, Accessed: 12/02/2016

[5] Material Design, https://en.wikipedia.org/wiki/Material_Design, Accessed: 14/02/2016