Technical FAQs

Before running this Docker image, you MUST configure Docker to use the following minimum hardware resources: 2 CPUs and 7.5 GB memory. If you try to run the image with fewer CPUs or less memory, it may not function correctly.

The ability to view PDF files has become an essential feature for web-based applications. While dedicated desktop readers are still common, the average user justifiably expects to be able to view documents without switching between applications. Thanks to browser-based PDF libraries like PDF.js, developers can both integrate the viewing features they need and build the next generation of PDF viewing integrations.

What Is PDF.js?

An open-source JavaScript PDF library, PDF.js was originally developed by the Mozilla Foundation in 2011 to serve as the built-in PDF viewer for the Firefox web browser. At the time, web browsers depended upon separate reader applications or browser plug-ins to view PDFs.

Unfortunately, this created several security risks. External plug-ins can contain malicious code or gather data that could endanger privacy. Downloading PDFs for local viewing is also potentially hazardous because it means the file must be removed from a secure application environment.

PDF.js uses Asynchronous JavaScript and XML (Ajax) to render PDFs as an HTML5 <canvas> element directly within a web application. Since it uses JavaScript for rendering, PDF.js is compatible with all modern browsers and doesn’t require any additional plug-ins.

In addition to being integrated into Firefox, the software was also made available as open-source code. This made it possible for independent developers to expand upon the core capabilities of PDF.js in the years since its release.

Should You Build or Buy a PDF.js Viewer?

The open-source availability of the PDF.js library makes it an attractive solution for software teams looking to add native viewing functionality to their applications. As with many open-source frameworks, however, developers may quickly run up against a few complications when building out a viewing solution from scratch.

Out-of-the-box, PDF.js consists of three basic layers:

• Core Layer: The heart of the JavaScript PDF library, this layer parses and interprets binary instructions from the file itself.
• Display Layer: This interface handles the actual rendering of the PDF into a <canvas> element.
• Viewer Layer: The primary viewing interface that allows users to view and interact with the document.
  

While the core and display layers can handle most documents, PDF.js doesn’t support the full PDF specification and sometimes struggles with rendering lengthy, complex, or image-heavy files. Overall performance is often on the slow side, and the way text is rendered makes text search somewhat unreliable.

More importantly, PDF.js lacks out-of-the-box mobile support. The included viewer doesn’t provide essential mobile UI features like pinch-to-zoom. It also doesn’t respond dynamically to mobile screens to ensure that menus and tools remain usable on all devices.

Any developer looking to add PDF viewing and editing capabilities to their web applications using PDF.js will need to solve these core issues. While features like responsive, mobile-friendly viewing may have been less important when PDF.js first released in 2011, they are considered essential by most users today. Unfortunately, building out these capabilities takes time and resources, which is something that few development teams have in abundance.

Integrating a ready-made viewer that combines the solid foundation of PDF.js with the innovative features users expect allows developers to quickly meet their project needs without pulling attention away from key aspects of their application.

Integrate PDF Solutions with Accusoft

While PDF.js has long served as an adequate open-source PDF viewing solution for web applications, today’s average user simply requires more functionality than PDF.js can provide on its own. For developers who lack the time, resources, or expertise necessary to build those additional features, Accusoft can help.

For over 30 years, Accusoft has helped organizations add essential features like viewing, file conversion, document assembly, and image compression to their applications through an innovative line of SDKs and APIs. 

Our document lifecycle technologies are backed by multiple patents and have been incorporated successfully into a wide range of applications. Accusoft’s dedicated engineers provide ongoing support and work closely with customers to implement their specific use cases, ensuring that their software platform is delivering the best possible experience.

To learn more about PDF viewing and editing solutions from Accusoft, talk to one of our technology experts today.

Anyone who has watched a thriller about government secrecy probably has an image in mind about what it means to redact a document. That picture usually involves piles of classified pages with entire paragraphs blotted out with black marker. At some point, a character holds a sheet up to a light and finds a spot where the redacted text is just barely visible enough to provide them with the next clue that moves the story forward. They may even use some special form of scanner that allows them to see the hidden material.

Such scenes reveal the fundamental problem with text redaction. As long as the content remains present, there might be some way of making it visible again, which presents serious problems in terms of privacy and security. The transition to purely digital documents should have made these concerns a thing of the past. Unfortunately, too many people fail to take advantage of PDF redaction tools and leave their confidential material dangerously exposed.

PDFs Are Not Like Physical Documents

In 2016, Democrats in the U.S. House of Representatives made the embarrassing mistake of releasing a cache of documents that contained improper redactions. Journalists easily found what was hidden beneath the black markings by copying the PDF text and pasting it into another document, which instantly revealed the redacted material.

This was not the first time government officials, or other organizations, released improperly redacted documents. Part of the reason why this mistake keeps happening is that people frequently apply the same practices used with physical documents to digital documents. It’s a simple matter to use shapes or drawing tools to obscure text in a PDF, but doing so only hides the content from view rather than removing it altogether.

As the “copy and paste” trick described above shows, it’s often trivially easy to bypass such “redactions.” That’s because a PDF document is not like a physical, printed document, even though it resembles one in a viewer. A PDF consists of multiple layers, as well as extensive metadata that isn’t visible. Adding a black box over text simply adds another layer to the document. Accessing the layer of text information underneath is quite simple, even with relatively basic software tools.

Redacting Content from Electronic Documents

The first step in true redaction involves the removal of selected content entirely. This ensures that even if someone is able to extract the text layer from the document, the redacted portions will not become visible when pasted elsewhere.

However, even removing the visible text itself may not be enough to protect confidential information. That’s because there may be some data remaining in the document that could contain information about how to render the redacted portions. While it would be possible to avoid this problem by converting a PDF to a bitmap image, removing the portions to be redacted, and then building an entirely new document using OCR, this process is time consuming and difficult to scale.

Using PDF Redaction Tools in PrizmDoc Viewer

A much more efficient approach would be to utilize dedicated PDF redaction tools like those built into PrizmDoc Viewer. Thanks to a sophisticated and intuitive API, PrizmDoc allows users to perform a number of redaction functions within its easy-to-use HTML5 viewer:

• Add individual redactions by selecting text, applying a redaction rectangle, or marking out the whole page.
• Perform a search for specific terms and apply redactions to each instance.
• Add redaction layers to a document that can be saved and edited during preparation.
• Apply redaction reasons to explain why certain content has been removed.

When integrating PrizmDoc Viewer into their applications, developers can also customize the HTML5 viewer to apply predefined redactions, preload entire redaction layers, or create unique redactions programmatically. This is especially useful for high-volume document workflows that need to identify and remove commonly used private data like Social Security numbers, contact information, and financial information.

PrizmDoc Viewer’s redaction API strips out all information associated with the redacted material from the document. That means any removed content isn’t just no longer visible; it also can’t be highlighted, copied, searched, or indexed because it’s no longer present in any way. Remaining text content, however, is still readily available. Even better, sharing documents through the HTML5 viewer also hides metadata that could contain sensitive information.

When redactions are made, PrizmDoc Viewer allows users to indicate the reasons for these removals. This is especially important for transparency purposes when working with government documents. The redaction API supports single and multiple redaction reasons for improved clarity.

Of course, most organizations still need to retain access to unredacted documents for internal use. That’s why PrizmDoc Viewer retains an unaltered version of the document safely uploaded to the server. The actual redacted document is a new file with all redacted content removed. Users can then use PrizmDoc Viewer’s sharing controls to further manage access to the file.

Redact Your Documents the Right Way

Today’s applications can’t afford to take redaction lightly. Whether they’re building the next generation of government technologies or LegalTech applications, developers need to provide their customers with the ability to easily screen documents to protect sensitive and private information from being exposed. By integrating viewing and document editing solutions with PDF redaction tools, they can help organizations take control over document security and avoid embarrassing redaction mistakes that could expose them to severe liability.

PrizmDoc Viewer’s versatile HTML5 viewing capabilities leverage powerful APIs to easily incorporate document redaction into application workflows. With just a simple API call, users can quickly locate and remove information from documents before sharing them with anyone outside the organization. To see PrizmDoc Viewer’s PDF redaction tools first hand, check out our interactive online demo today.

Barcodes remain the basis for product identification and tracking, improving both operational insight and the end-user experience. From common applications in grocery stores to more advanced deployments in warehouses, legal firms, and even post-secondary schools, barcodes are the ubiquitous bridge between digital and physical environments. 

As noted by Forbes, emerging pandemic pressures have precipitated the return of a familiar code framework, the QR code. Now used by retail stores and restaurants to enable touchless product identification and payment, this rapid code renaissance is a stark reminder that codes remain a key driver of long-term operational success. However, not all barcode reader tools are created equal. Some struggle to handle damaged or deformed barcodes, others limit the type and nature of the codes they scan, and many full-featured solutions come with significant complexity around installation, integration, and ease-of-use.

Barcode Xpress offers the best of both worlds. Here’s what developers need to know.

What is Barcode Xpress?

Accusoft’s Barcode Xpress makes it easy for users to read, write, and detect over 30 different barcodes with a single software development kit (SDK). Barcode Xpress supports:

• 1D Barcodes — Including Add-2, Add-5, Code 39, GS1 and UCC
• 2D Barcodes — Such as Aztec, Data Matrix, PDF417 and QR codes
• Postal Codes — From PLANET and PostNet to Royal Mail and the Australia Post 4-State Code
• Patch Codes — Including Patch 1, 2, 3, 4 (Toggle), 6 and Transfer

Barcode Xpress also reports confidence values for detected codes, reads supported barcodes in any orientation in milliseconds, and can intelligently handle poorly-printed, damaged, or badly-scanned barcode images. This SDK is also available in six development environments, including:

• .NET
• .NET Core
• ActiveX
• Java
• Linux
• Node.js

 Basic Barcode Requirements

Deployment environments for Barcode Xpress must leverage one of the following x64 Windows versions:

• Windows 8.1
• Windows 10 Version 1607 and later
• Windows Server 2008 R2 SP1 and later
• Windows Server 2012, 2016 or 2019

The SDK can also be deployed on x64 Linux operating systems including:

• Ubuntu 18.04 or 16.04
• CentOS 8 or 7
• Debian 9 or 10

When it comes to Barcode Xpress development environments, requirements include Microsoft .NET Core 2.1 or later along with Java Runtime Environment 1.8 or later for License Manager and Server Licensing Utilities, along with Visual Studio 2017 or later (optional).

Ease of Installation

To streamline installation, Barcode Xpress .NET Core can be deployed via NuGet package or using a zip file provided by Accusoft. In both cases, developers require a valid license to use the SDK. Explore the different license types here.

Evaluation licenses allow your team to explore Barcode Xpress features bounded by timeouts and watermarks. Toolkit licenses remove pop-ups, time outs, and watermarks to enable in-depth development, while Runtime licenses are required to distribute your application.

Navigating NuGet

The simplest way to deploy Barcode Xpress is using the NuGet package manager for Microsoft development platform in Visual Studio. All of Accusoft’s NuGet packages can be found at nuget.org. Find the NuGet Barcode Express .NET package here.

To install the NuGet package, follow these steps:

1. Open the NuGet Package Manager in Visual Studio.
2. In the newly-opened window, ensure the Package Source is set to nuget.org and select the Barcode Xpress package.
3. After selection and installation, look for the newly-added assemblies in your References folder.
4. Add using [namespace] to any CS/VB file you’d like to reference these NuGet libraries.

Need more help? Check out the official NuGet tutorials. 

 Creating a Command Line

Ready to tackle your first project in Barcode Xpress? Here’s a step-by-step guide to building a complete C# application that analyzes 1D barcodes using Visual Studio.

1.Create a new Console App project in .NET core:

2. Add the Barcode Xpress SDK:

3. Add any required Microsoft dlls for the project. In this case, look for System.Drawing.Common at nuget.org, or add them locally if they’re already present as references in your development environment.

4. Add using statements to your generated Program.cs:Program.cs

using System;
using System.Drawing;
using Accusoft.BarcodeXpressSdk;
namespace MyProject
{
...

5. Create any necessary instances of Accusoft.BarcodeXpressSDK.BarcodeXpress and System.Drawing.BitmapProgram.cs

using System;
using System.Drawing;
using Accusoft.BarcodeXpressSdk;
namespace MyProject
{
    class Program
    {
        static void Main(string[] args)
        {
            BarcodeXpress barcodeXpress = new BarcodeXpress();
            System.Drawing.Bitmap bitmap = new Bitmap("barcode.bmp");
        }
    }
}

6. Pass this bitmap to Barcode Xpress and access the returned resultsProgram.cs

…
namespace MyProject
{
     class Program
     {
         static void Main(string[] args)
         {
             BarcodeXpress barcodeXpress = new BarcodeXpress();

             System.Drawing.Bitmap bitmap = new Bitmap("barcode.bmp");
          
             Accusoft.BarcodeXpressSdk.Result[] results = barcodeXpress.reader.Analyze(bitmap);
          
             if (results.Length > 0)
             {
                 foreach (Accusoft.BarcodeXpressSdk.Result result in results)
                 {
                     Console.WriteLine("{0} : {1}", result.BarcodeType.ToString(), result.BarcodeValue);
                 }
             }
             else
             {
                 Console.WriteLine("No Barcodes Found.");
             }
         }
     }

7. Finally, clean up your code by using the Dispose() methodProgram.cs

…
namespace MyProject
{
    class Program
    {
         static void Main(string[] args)
         {
             BarcodeXpress barcodeXpress = new BarcodeXpress();

             System.Drawing.Bitmap bitmap = new Bitmap("barcode.bmp");
          
             Accusoft.BarcodeXpressSdk.Result[] results = barcodeXpress.reader.Analyze(bitmap);
          
             if (results.Length > 0)
             {
                 foreach (Accusoft.BarcodeXpressSdk.Result result in results)
                 {
                     Console.WriteLine("{0} : {1}", result.BarcodeType.ToString(), result.BarcodeValue);
                 }
             }
             else
             {
                 Console.WriteLine("No Barcodes Found.");
             }
             barcodeXpress.Dispose();
         }
     }

Ongoing Improvements

Barcode Xpress isn’t a new offering — it’s been part of the Accusoft SDK lineup for more than 15 years. However, John Reynolds, Principal Engineer for Barcode Xpress, recently took a look at the code to improve its functionality. In his whitepaper, Refactoring Legacy Code for Speed in Barcode Xpress, he found that when repeatedly scanning a barcode in a particular direction, the count length of black/white runs in the same direction. 

As a result, continually calculating the mask and data pointers for each coordinate is cumbersome, but also allows for potential shortcuts, such as keeping a running tally of the mask across the image. Applied in depth, this and other code legacy code changes have helped improve 1D barcode analysis times from 5% to 60%, depending on the image.

Barcode Xpress offers comprehensive code recognition that’s easy to implement and customize, while ongoing improvements help streamline SDK deployment, enhance operational speed, and empower software engineers in various markets. Discover the benefits of Barcode Xpress. Download a free trial or try an online demo today.

Offering product integrations can be one of the easiest ways to expand the feature set of a product without adding loads of time and cost on development resources. Docubee currently has external integrations with Salesforce, Sharepoint, and Brother scanners that we offer to our customers. Internally, we have an integration with Slack that allows our development team to be notified of different events that happen within Docubee. As a team of engineers, we are always looking for new ways that we could possibly use Docubee with other products, and luckily, we usually find some time to prototype out these integrations.

Being an Apple enthusiast myself, one of the first things I wanted to try to integrate Docubee with was Apple HomeKit so I could use Siri to launch workflows. I configured my Apple TV to work with the Home app and was all ready to go. Unfortunately, I quickly found out that HomeKit does not natively support customizations like this. Lucky for me, someone had already come up with a solution to this problem using Homebridge and a node module called homebridge-cmdswitch2.

According to their Github, Homebridge is “a lightweight NodeJS server you can run on your home network that emulates the iOS HomeKit API” and homebridge-cmdswitch2 “allows you to run Command Line Interface (CLI) commands via HomeKit”. After that, the setup was pretty simple to get everything working. I had to create a workflow in Docubee that I wanted to start, configure my Home app to work with Homebridge, and write this config file below. Before I knew it, Siri was launching workflows for me.

{
  "bridge": {
      "name": "Homebridge",
      "username": "CC:22:3D:E3:CE:30",
      "pin": "031-45-154"
  },
  
  "description": "Homebridge Docubee Config",

  "accessories": [],

  "platforms": [{
    "platform": "cmdSwitch2",
    "name": "CMD Switch",
    "switches": [{
      "name" : "Docubee Workflow",
      "on_cmd": "curl -d '{\"wfModelId\":\"ec6e7fc4-1c38-4ebf-8a32-a02ba6721ffe\", \"wfData\": {}}' -H \"Content-Type: application/json\" -X POST {LAUNCH_WORKFLOW_ENDPOINT}",
      "state_cmd": "exit 1",
      "off_cmd": "echo off"
    }]
 }]
}

One of the next integrations I wanted to try to play with was Slack. I mentioned that we already use it internally, but I wanted to see if there was a way that we could make a Slack integration that was useful for an end-user. After creating my own Slack app to play with, I wanted to be able to launch a workflow from Slack as well as send a message back to Slack notifying me that a workflow was launched. To do both of these things, I had to create a handler somewhere to take the callback IDs that Slack would send to our API and do something with them. The finished handler looked like this:

'use strict';
const qs = require('qs');
const request = require('request')

function handleInteractiveMessage(req, res) {
  const task = req.task;
  res.status(200);
  res.end();
  task.log.info({ source: 'slack-connector.handInteractiveMessage' }, qs.parse(req.body));
  const payload = JSON.parse(qs.parse(req.body).payload);
  const responseUrl = payload.response_url;
  const callbackId = payload.callback_id;
  task.log.info({ source: 'slack-connector.handleInteractiveMessage', responseUrl }, 'response url');
  task.log.info({ source: 'slack-connector.handleInteractiveMessage', callbackId }, 'callback id');
  if (payload.callback_id === 'docubee_workflow_start') {
    kickOffWorkflow(task);
  } else if (payload.callback_id === 'handle_workflow_actions' && payload.actions[0].value !== 'redirect') {
    confirmCancelWorkflow(task, responseUrl, payload.actions[0].value);
  } else if (payload.callback_id === 'confirm_cancel_workflow' && payload.actions[0].value !== 'No') {
    cancelWorkflow(task, payload.actions[0].value, responseUrl)
  }
}

function confirmCancelWorkflow(task, responseUrl, wfInstanceId) {
  return new Promise((resolve, reject) => {
    task.log.info({ source: 'slack-connector.confirmCancelWorkflow', wfInstanceId }, 'wf instance id');
    request({
      url: responseUrl,
      method: 'POST',
      json: true,
      body: {
        text: 'Are you sure you want to cancel this workflow?',
        attachments: [
          {
            fallback: 'See what\'s going on!',
            author_name: 'Owner: ntorretti',
            title: 'Confirm Cancel',
            text: 'Please confirm you want to cancel this workflow',
            callback_id: 'confirm_cancel_workflow',
            actions: [
              {
                name: 'action',
                type: 'button',
                text: 'Yes',
                style: '',
                value: wfInstanceId
              },
              {
                name: 'action',
                type: 'button',
                style: '',
                text: 'No',
                value: 'No'
              }
            ]
          }
        ]
      }
    }, (err, response) => {
      if (err) {
        task.log.error({ source: 'slack-connector.confirmCancelWorkflow', err }, 'whoops');
        reject(err);
      } else {
        task.log.info({ source: 'slack-connector.confirmCancelWorkflow', response }, 'response');
        resolve({ status: 'Request successfully sent to callback API endpoint.' });
      }
    });
  });
}

function sendCancelConfirmation(task, responseUrl) {
  return new Promise((resolve, reject) => {
    request({
      url: responseUrl,
      method: 'POST',
      json: true,
      body: {
        text: 'We have successfully cancelled your workflow.',
      }
    }, (err, response) => {
      if (err) {
        task.log.error({ source: 'slack-connector.sendCancelConfirmation', err }, 'whoops');
        reject(err);
      } else {
        task.log.info({ source: 'slack-connector.sendCancelConfirmation', response }, 'response');
        resolve({ status: 'Request successfully sent to callback API endpoint.' });
      }
    });
  });
}

function cancelWorkflow(task, wfInstanceId, responseUrl) {
  return new Promise((resolve, reject) => {
    request({
      headers: { 'content-type': 'application/json' },
      url: {CANCEL_WORKFLOW_ENDPOINT},
      method: 'POST'
    }, (err, response) => {
      if (err) {
        task.log.error({ source: 'slack-connector.cancelWorkflow', err }, 'whoops');
        reject(err);
      } else {
        task.log.info({ source: 'slack-connector.cancelWorkflow', response }, 'yay');
        sendCancelConfirmation(task, responseUrl);
        resolve(response);
      }
    });
  });
}

function kickOffWorkflow(task) {
  return new Promise((resolve, reject) => {
    request({
      headers: { 'content-type': 'application/json' },
      url: {LAUNCH_WORKFLOW_ENDPOINT},
      method: 'POST',
      body: JSON.stringify({
        wfModelId: 'd32aa8ba-f153-46b5-8c62-81d14327c924',
        wfInstanceName: 'Untitled',
        wfData: {
          Originator: 'Natalie Torretti',
          Originator_Email: 'ntorretti@accusoft.com',
          email: 'ntorretti@accusoft.com'
        }
      }),
    }, (err, response) => {
      if (err) {
        task.log.error({ source: 'slack-connector.handleInteractiveMessage', err }, 'whoops');
        reject(err);
      } else {
        task.log.info({ source: 'slack-connector.handleInteractiveMessage', response }, 'yay');
        resolve(response);
      }
    });
  });
}

module.exports.initialize = (params, imports, ready) => {
  const framework = imports['prv-common-service-base'];
  const task = framework.taskLogging.createTask();
  const server = imports.server;

  task.begin('Initializing Slack connector component');

  server.post('/interactiveMessage', handleInteractiveMessage);

  task.log.info({ source: 'slack-connector.initialize' }, 'Slack connector component initialized');
  task.end();
  ready();
};

Slack has some great documentation and really is built to handle these kind of integrations. It was not that much work to get everything configured after I had the connector in place. I still needed one more piece of code on the Docubee end to be able to actually send the message to Slack. That send message function ended up looking like this:

const sendSlackMessage = imports => (task, redirectUrl, workflowInstanceId, message) => {
  return new Promise((resolve, reject) => {
    task.log.info({ source: 'utils.sendSlackMessage' }, 'sending slack message');
    request({
      url: 'https://hooks.slack.com/services/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',
      method: 'POST',
      json: true,
      body: {
        text: JSON.stringify(message),
        attachments: [
          {
            fallback: 'See what\'s going on!',
            author_name: 'Owner: ntorretti',
            title: 'Workflow Actions',
            text: 'Here are some actions you can take!',
            callback_id: 'handle_workflow_actions',
            actions: [
              {
                name: 'action',
                type: 'button',
                text: 'View dashboard',
                style: '',
                value: 'redirect',
                url: {LINK_URL}
              },
              {
                name: 'action',
                type: 'button',
                text: 'Go to workflow',
                style: '',
                value: 'redirect',
                url: redirectUrl
              },
              {
                name: 'action',
                type: 'button',
                style: '',
                text: 'Cancel Workflow',
                value: workflowInstanceId
              }
            ]
          }
        ]
      }
    }, (err, response) => {
      if (err) {
        task.log.error({ source: 'utils.sendSlackMessage', err }, 'whoops');
        reject(err);
      } else {
        task.log.info({ source: 'utils.sendSlackMessage', response }, 'response');
        resolve({ status: 'Request successfully sent to callback API endpoint.' });
      }
    });
  });
}

We called this the send SlackMessage function after the “Start Demo Workflow” was started. This sends a message back to Slack that gives the user a couple different actions that they could take on that message. If a user clicked one of the buttons in the message, a request with a specific callback ID was sent to the slack handler and the appropriate action was taken. The first image below shows how I integrated starting a workflow in Slack and the second image shows the message we sent back to Slack after a workflow was started giving the user different actions they can take.

These are just a few ways that Accusoft’s Docubee can be integrated into your daily routines. Whether it’s starting a workflow with Siri or enabling automated Slack processes, Docubee is built to help you and your organization to find the best way to automate processes.

Natalie Torretti, Software Engineer III

Natalie joined Accusoft as a software engineer in 2016. She started on the eDocr team but has spent the last two and a half years on Docubee development team. Natalie has been a large contributor to the React front-end UI of Docubee and made several enhancements to the back-end microservices as well. She obtained her B.S. in Biobehavioral Health with a Psychology minor from Penn State as well as her A.S.T. in Information Technology from South Hills School of Business and Technology. When Natalie is not writing code she enjoys working out, spending time at the pool, and playing with her dogs.

TAMPA, Florida, February 9, 2022 — Accusoft announces the launch of the Women In Tech Scholarship for 2022. The new scholarship program is aimed at female students passionate about pursuing a career in the Science, Technology, Engineering, or Mathematics fields.

The scholarship is open to a female-identifying undergraduate student pursuing a two or four-year degree and studying STEM. Accusoft will award $3,000 in scholarship to the winner. Apply at https://bold.org/scholarships/women-in-tech-scholarship/

The tech field has been exploding recently and offers lucrative job opportunities. Unfortunately, women are still quite underrepresented in all STEM fields, including tech. Despite making up roughly half of the workforce, less than 27% of tech positions are held by women and only 22% of Fortune 500 tech companies have female leaders.

This scholarship aims to support women pursuing STEM so they can find successful careers and create a more diverse workforce.

“Accusoft is a software company with a mission to make the world in which we live and work a better place,” said Jack Berlin, CEO of Accusoft. “We do this by inventing new ways to help organizations become more efficient and innovative, promoting the continuous improvement of our community, and working to minimize our impact on natural resources. We hope that our new scholarship will not only encourage women to go into the tech field but also to give them the resources to complete their degree.”

To apply, students must write an essay detailing why they are interested in STEM and what their career goals are. Apply at https://bold.org/scholarships/women-in-tech-scholarship/

Applications are due May 29th, 2022. The winner will be announced on June 30, 2022.

About Accusoft

Founded in 1991, Accusoft is a software development company specializing in content processing, conversion, and automation solutions. From out-of-the-box and configurable applications to APIs built for developers, Accusoft software enables users to solve their most complex workflow challenges and gain insights from content in any format, on any device. Backed by 40 patents, the company’s flagship products, including OnTask, PrizmDoc™ Viewer, and ImageGear, are designed to improve productivity, provide actionable data, and deliver results that matter. The Accusoft team is dedicated to continuous innovation through customer-centric product development, new version release, and a passion for understanding industry trends that drive consumer demand. Visit us at www.accusoft.com.

On March 10, 2021, Accusoft announced the arrival of the free-to-use Accusoft PDF Viewer, the latest addition to its family of PDF solutions. An entirely client-side integration with no complicated server dependencies, this lightweight JavaScript PDF viewer also features a responsive UI for out-of-the-box mobile support.

“We’re excited to offer this free version of the Accusoft PDF Viewer to developers,” says Jack Berlin, CEO of Accusoft. “Our team worked hard to build a viewer that’s a step above what you can get from open source offerings. We think it’s going to solve a lot of the problems developers typically encounter with existing PDF libraries.”

Accusoft PDF Viewer integrates into an application quickly and easily with just a few snippets of code. It runs entirely within the browser to deliver an optimized viewing experience across all devices. The intuitive UI controls allow users to zoom, pan, jump to page, navigate thumbnails, and pinch-to-zoom on mobile screens with ease. And thanks to lightning fast full-text search, locating essential information is easier than ever.

“Accusoft PDF Viewer is great for developers because it allows them to maintain complete control over documents without having to set up any cumbersome server infrastructure,” says Mark Hansen, Product Manager. “Having a responsive UI that adapts to mobile displays will also increase their flexibility tremendously.”

The free version of Accusoft PDF Viewer allows developers to quickly add powerful viewing capabilities to their web applications. We’re currently working on additional features (such as annotation and eSignature) that will be included in an upgraded paid version.

To learn more about Accusoft PDF Viewer or download it for a first-hand look, please visit our website.

About Accusoft:
Founded in 1991, Accusoft is a software development company specializing in content processing, conversion, and automation solutions. From out-of-the-box and configurable applications to APIs built for developers, Accusoft software enables users to solve their most complex workflow challenges and gain insights from content in any format, on any device. Backed by 40 patents, the company’s flagship products, including OnTask, PrizmDoc™ Viewer, and ImageGear, are designed to improve productivity, provide actionable data, and deliver results that matter. The Accusoft team is dedicated to continuous innovation through customer-centric product development, new version release, and a passion for understanding industry trends that drive consumer demand. Visit us at www.accusoft.com.

TAMPA, FLA. (Dec. 1, 2021) Last night, the Tampa Bay Software CEOs (TBSC) met for their quarterly social meeting at the Current Hotel in the Rox Rooftop Bar. Hosted by Accusoft, this networking event provided a great venue for discussion about attracting top talent to the area’s innovative businesses, driving growth opportunities for the high tech industry in Tampa, and sharing mutual problems and uncovering solutions.

“Our tech community and the opportunity for further innovation in Tampa Bay is growing”,  said Jack Berlin, CEO at Accusoft. “With this great collaboration of software CEOs, we can bring the local tech community together, to attract top talent, effectively communicate to our leaders what our tech community needs, and learn from each other to drive further growth.”

The Software CEO Council comprises the area’s premier businesses, executives, and entrepreneurs of Tampa Bay’s technology community. Its mission is to create the largest communal ecosystem for tech startups in the state of Florida and put Tampa Bay on the map as a beacon for innovation and success, to foster talent and fuel growth. Council companies include A-LIGN, Accusoft, Applied Data Corporation, ComplianceQuest, CrossBorder Solutions, Digital Hands, Geographic Solutions, Haneke Design, MercuryWorks, Sourcetoad, Spirion, Transcendent and Vendita.

Pictured above left to right: Greg Ross-Munro, Prashanth Rajendran, Kevin Coppins, Dan Gaertner, Chris Karlo, Shamus Hines, Charlotte Baker, Jack Berlin, Jody Haneke.

For more information about TBSC, visit the group’s website at https://www.tampasoftwareceos.com/.

About Tampa Bay Tech

Tampa Bay Tech is a 501(c)6 non-profit technology council that has been engaging and uniting the local technology community for 20 years. With over 100 companies representing thousands of tech employees – as well as thousands of students within the area’s colleges and universities – Tampa Bay Tech provides programming and initiatives to support all those in the technology space. Through their membership and partnerships, their mission is to build a radically connected, flourishing tech hub where opportunity is abundant for all. Join the TBTech community at tampabay.tech and follow us on Facebook, Linkedin, Instagram, and Twitter.

About Accusoft

Founded in 1991, Accusoft is a software development company specializing in content processing, conversion, and automation solutions. From out-of-the-box and configurable applications to APIs built for developers, Accusoft software enables users to solve their most complex workflow challenges and gain insights from content in any format, on any device. Backed by 40 patents, the company’s flagship products, including OnTask, PrizmDoc™ Viewer, and ImageGear, are designed to improve productivity, provide actionable data, and deliver results that matter. The Accusoft team is dedicated to continuous innovation through customer-centric product development, new version release, and a passion for understanding industry trends that drive consumer demand. Visit us at www.accusoft.com.

FinTech applications have become indispensable to the financial services sector, enabling users to easily engage with financial offerings in a manner that suits them, while also boosting operational efficiency. The industry’s ongoing digital transformation continues to redefine FinTech functions, with developers tirelessly crafting new apps capable of handling tasks formerly dispersed across numerous systems and software.

Among the most crucial features of FinTech applications is the ability to view and share documents. Developers have a range of document lifecycle solutions at their disposal to circumvent the challenging process of building these features from the ground up. However, the financial sector presents distinct security and compatibility prerequisites when it comes to choosing partners for integration. To truly grasp these technical hurdles, it’s important to understand the significance of Java in the development of FinTech applications.

A (Brief) History of Java in the Financial Sector

Financial institutions pioneered the adoption of automated workflows. The advent of the first electronic communication network that facilitated the trading of financial products off the trading floor was seen as early as the 1960s. During the 1970s, computerized order flows saw greater acceptance, with most financial companies crafting their own proprietary systems. The digital revolution truly ignited in the 1980s and early 1990s with the launch of the Bloomberg terminal and the Financial Information eXhange (FIX) protocol. By the late 1990s, the Nasdaq enabled the execution of securities trades autonomously, without the need for manual interference, through the incorporation of Island ECN.

Java shook up the programming language world when it debuted in 1995, and its timing couldn’t have been better. The financial industry witnessed an extensive wave of mergers and acquisitions in the late 1990s and early 2000s, which resulted in several companies grappling with the integration of a multitude of applications and data. Java’s ability to support diverse platforms was an appealing solution to this challenge, and numerous financial applications were translated into Java. Sun Microsystems, which first introduced Java to the market, even adopted the slogan “Write once, run anywhere” to promote its flexibility. Java’s simplicity of use and significantly enhanced speed compared to legacy code on outdated platforms quickly made it the language of choice for developers.

In a few short years, Java ascended to become the leading programming language within the financial services industry. Its popularity surged again following the launch of OpenJDK, a free and open-source version of the language, in 2007. An Oracle report in 2011 estimated that over 80% of electronic trading applications and virtually all FIX engines were written in Java. Even close to three decades after its debut, Java continues to be the primary programming language employed by financial services, surpassing other open-source alternatives by a considerable margin.

Java’s Enduring Appeal for the Financial Industry

The enduring preference for Java among financial sector developers isn’t simply due to tradition or resistance to change. Java’s unique attributes are an exceptional fit for financial applications, spanning both long-established enterprise-level banking systems and pioneering FinTech solutions.

Security

In the realm of financial services, security is the highest priority for developers. Applications related to banking and trading must have robust security provisions to guard financial data and personally identifiable information against unauthorized access. Java simplifies data access restriction and provides an array of memory safety features to diminish potential vulnerabilities, particularly those stemming from prevalent programming mistakes. Oracle consistently rolls out regular updates to fix recognized vulnerabilities and tackle the most recent cybersecurity threats.

Portability

Java, being a platform-independent language, allows applications to operate on virtually any device. This has always been a substantial benefit in the financial sector, but it has proven even more crucial in the era of cloud computing and mobile applications. Developers can employ the same code to roll out software in a virtual environment and render it accessible to end-users via their smartphones, computers, or other devices. The ability of Java virtual machines to support additional programming languages only adds to the language’s versatility.

Reliability

Given the nearly three-decade-long consistent use and the backing of a robust development community, Java has established itself as one of the most dependable programming languages globally. Potential instabilities have long been addressed, and there is a wealth of developer tools and documentation at hand to ensure software is built on a solid foundation. This reliability is critically significant for banking and financial applications, which demand high performance levels coupled with fault tolerance.

The Value of Java-Based Document Viewing and Sharing

As FinTech developers continue to build novel applications aimed at simplifying life for clients and employees in the financial industry, they’re facing a growing expectation from users for superior document viewing and sharing capabilities. Users want to bypass the time-consuming and resource-heavy task of manually processing paper documents, and most organizations strive to eliminate the security hazards associated with using external applications for managing digital documents.

However, developers face significant challenges when attempting to build these complex document viewing capabilities from scratch. Although there are numerous integrations that can introduce document lifecycle features, most aren’t based in Java and need extra development work to embed them into existing FinTech solutions. Without the option to natively view, share, and edit documents within the Java application, users frequently resort to external programs, a practice that presents potential security issues and version discrepancy risks.

Facilitating Java-based Document Functionalities through PrizmDoc^® for Java

Accusoft’s PrizmDoc^® for Java, formerly VirtualViewer^®, is a robust, Java-based HTML5 document viewing tool designed to assure optimal compatibility with FinTech applications without compromising functionality and security. By supporting an array of document types, such as PDF, TIFF, JPEG, AFP, PCL, and Microsoft Office, PrizmDoc® for Java creates a streamlined viewing experience that eliminates the need for external viewing solutions.

As an integration built on Java, PrizmDoc^® for Java can operate on nearly any operating system and is simple to deploy. There’s no need to install software on the user’s desktop, enabling FinTech developers to deploy a scalable solution that fulfills their crucial security and business continuity needs within a single, high-velocity application. PrizmDoc^® for Java’s server component swiftly renders and dispatches individual document pages for local viewing as required, allowing users to access, view, annotate, redact, and manipulate financial documents instantaneously. Since documents are rendered within the web-based viewer, users never have to download or transfer files, which could put sensitive data at risk.

Experience PrizmDoc^® for Java’s features for yourself by signing up for a free trial!