Subscribe to Updates

Click here to subscribe to new posts by email. We use Google FeedBurner to send these notifications.

Archive for the ‘BookBuilder’ Category

NEW! Export, Share and Publish your PocketBible Notes, Bookmarks and Highlights

Posted on: October 16th, 2012 by Michelle Stramel 26 Comments

Are you a prolific note-taker, highlighter or bookmarker in PocketBible? We have wonderful news for you! We have a new option on our website that lets you instantly pull your personal data (notes, highlights and bookmarks) out of PocketBible for the purpose of sharing, re-purposing or turning into your own PocketBible book (with BookBuilder). Whichever you want to do!

Possibilities abound

Over the years, PocketBible users have asked for the ability to export their valuable personal data out of the program. Yes, you can now do this but we’ve taken it a step further. You choose whether you want to export your notes, highlights or bookmarks. With any of those three options, we provide you with an html file that you can:

  • Use as-is
  • Bring into a text editor and reformat and publish in a format for sharing (i.e. PDF, .doc, .txt, etc.)
  • Publish as a PocketBible book using Laridian BookBuilder program (sold separately)

What kind of book could you publish for PocketBible?

  • A dictionary of your Bible bookmarks, where each dictionary entry is a bookmark category.
  • A commentary based on your verse notes.
  • A dictionary of your Bible highlights, where each dictionary entry is a highlight color.

To encourage your self-publishing efforts, we’ve lowered the prices of both versions of BookBuilder:

There’s never been a better time to consider publishing a PocketBible book!

Getting Started

The first step is to synchronize your PocketBible data with the Laridian Server. A synchronization option is available in every version of PocketBible (except Android OS – still to come!) The second step is to login to your account on the Laridian website and choose the new My Data link. You’ll find complete information on what you can do with your data and how to do it.

Let us know what you think

We hope you like this new flexibility in using your personal PocketBible data. Is this something you will use? Let us know how you will share your writings in the comments below.

The Story Behind the PocketBible NET Bible

Posted on: January 11th, 2010 by Craig Rairdin 11 Comments

We’ve known about the NET Bible since its beginnings, and several years ago we licensed the NET Bible for use in our products. We knew the Bible had extensive notes but didn’t think that would be a problem for PocketBible.

We put one of our employees to work on it and after several months it became clear that the challenges it presented were going to be greater than the potential revenue we could gain from it would justify. The problems were related to converting the original language references in the notes from a variety of proprietary fonts into the standard Unicode notation we use in PocketBible. I don’t recall all the details but do recall a meeting in which we decided to just drop the project.

A year or so later we heard from a programmer who had extensive experience with the NET Bible and wondered why we hadn’t yet made it available. I explained the issues and he said he’d be happy to tackle it. I sent him everything he needed to tag the NET Bible and notes for PocketBible. He asked a couple questions over the next week or two, but then disappeared. The NET Bible had taken another victim.

Then last November I heard from David Richards. David is a long-time Laridian customer and a fan of the NET Bible. He had been experimenting with our BookBuilder program, which allows anyone to create reference materials that are compatible with PocketBible, and wondered if we had plans to publish the NET Bible. I told him the story and warned him of the bodies it had left in its path. He seemed undeterred, so we came to terms on a price for his work and he set out to work on it. I figured that would be the last we’d hear from him, and went about my business.

Surprisingly, when I heard from David it wasn’t to ask questions. It was to give me samples from what he had gotten done. Before long he had made it through all 60,000 notes. We ran a brief test with a group of testers left over from PocketBible for iPhone and after just one update the NET Bible was ready to ship.

I wanted to tell you David’s story for a couple reasons. First is that we’re pretty excited about finally having the NET Bible and know what an accomplishment it was for him. He deserves a little recognition for his efforts.

Second is that David’s is a story we’ve seen play out a couple of times in the past and we’d like to see it happen more often. We’ll be releasing a collection of reference books in the next couple of weeks that were tagged by another customer who got interested in BookBuilder a year or two ago and has since tagged a couple of projects for us after doing some of his own. Our A.W. Pink, F.B. Meyer, and Andrew Murray collections were tagged by a customer, as was the Dake Study Bible Notes.

Of course tagging books isn’t for everyone. It usually requires extensive use of what’s called “pattern matching”, “regular expression”, or “grep” search-and-replace operations to convert a book from whatever format it might be to begin with into our HTML-based format for BookBuilder. You need to have a head for details and it doesn’t hurt to have a little programming background.

David and each of these other taggers are being compensated in some way for their work. We’d love to add you to our list of available taggers for new projects. You can get the standard BookBuilder program for $29.99 and see if it’s something you want to try. We have an inexhaustible list of books that need to be tagged. Maybe you have a favorite commentary series or reference title you’d like to see in PocketBible. Rather than wait for us to get around to it, why not volunteer to do it yourself?

Feel free to contact me directly if you’re interested: craigr@laridian.com.

Quick and Easy Custom “Books” for PocketBible Using BookBuilder

Posted on: April 28th, 2008 by Craig Rairdin 5 Comments

I get the best ideas from customers. I’m corresponding with one now who is lamenting how hard it is to use BookBuilder to bring a text file into PocketBible. That gave me an idea to just tell you how to do it. It’s pretty easy.

Let’s just take the text of my blog posting from April 21 and turn it into a Laridian book. Laridian books are HTML files with some added tags. They all look like this:

<html><head>
<!– meta tags go here –>
</head><body>
<!– your book goes here–>
</body></html>

The meta tag section comes right out of the documentation. Here are the meta tags for a dictionary, which we’ll modify to make our book:

<html><head>
<meta name=”pb_title” content=”Tyndale Bible Dictionary”>
<meta name=”pb_abbrev” content=”TBD”>
<meta name=”pb_copyright” content=”Copyright &copy; 2001 by Tyndale House Publishers, Inc. All rights reserved.”>
<meta name=”pb_publisher” content=”Laridian Electronic Publishing”>
<meta name=”pb_city” content=”Cedar Rapids, IA”>
<meta name=”pb_date” content=”2004″>
<meta name=”pb_pubid” content=”101″>
<meta name=”pb_bookid” content=”35″>
<meta name=”pb_editionid” content=”1″>
<meta name=”pb_revisionid” content=”1″>
<meta name=”pb_synctype” content=”word”>
</head><body>
<!– your book goes here–>
</body></html>

We’ll change a bit of the text in the meta tags to make it make sense for our blog article. We end up with this:

<html><head>
<meta name=”pb_title” content=”April 21 Blog Article”>
<meta name=”pb_abbrev” content=”BLOG”>
<meta name=”pb_copyright” content=”Copyright &copy; 2008 by Craig Rairdin. All rights reserved.”>
<meta name=”pb_publisher” content=”Laridian Electronic Publishing”>
<meta name=”pb_city” content=”Cedar Rapids, IA”>
<meta name=”pb_date” content=”2008″>
<meta name=”pb_pubid” content=”9999″>
<meta name=”pb_bookid” content=”1″>
<meta name=”pb_editionid” content=”1″>
<meta name=”pb_revisionid” content=”1″>
</head><body>
<!– your book goes here–>
</body></html>

In addition to changing the text of the copyright message etc. I also changed the Publisher ID (pb_pubid) just because it doesn’t matter and I didn’t want it the same as the Tyndale Dictionary from which the example was lifted. I set the pb_bookid meta tag to 1, and I would change that for every book I create. And I removed the final pb_synctype tag, because that’s what tells PocketBible this is a dictionary, but my file isn’t a dictionary.

I have to add at least one heading so I have something in the table of contents for the book. So I put that on the top of the text of the blog article. I paste in the text of the blog article and add <p> tags at the start of each line to indicate new paragraphs.

Text in bold is text I modified in some way just so you can see how little I changed from either the sample meta tags or the text of my article.

<html><head>
<meta name=”pb_title” content=”April 21 Blog Article“>
<meta name=”pb_abbrev” content=”BLOG“>
<meta name=”pb_copyright” content=”Copyright &copy; 2008 by Craig Rairdin. All rights reserved.”>
<meta name=”pb_publisher” content=”Laridian Electronic Publishing”>
<meta name=”pb_city” content=”Cedar Rapids, IA”>
<meta name=”pb_date” content=”2008“>
<meta name=”pb_pubid” content=”9999“>
<meta name=”pb_bookid” content=”1“>
<meta name=”pb_editionid” content=”1″>
<meta name=”pb_revisionid” content=”1″>
</head><body>
<h1 pb_toc=visible>On the Problems of Designing User-Friendly Software for PDAs and Smart Phones</h1>
<p>A comment from one of our PocketBible 4 beta testers got me thinking about the nature of what we do and what users complain about. I’ve expressed this with respect to the iPhone but I haven’t put it into a larger context that might help people understand what software designers are up against when we implement a solution, regardless of the platform. These issues are especially true of the mobile device market but the same ideas apply to the desktop and other general-purpose computing platforms.
<p>If you start from the beginning, you find a user with a problem. It might be: “How do I take my contact database with me?” or “How can I work on my spreadsheets on the train?” or “How can I browse the Web when I’m away from my computer?”. Hardware companies like Sony, Apple, HP, and HTC get together with software companies like Microsoft and whatever Palm is calling itself today and come up with a device and operating system software that address those problems. In the course of doing so, they create a way for third parties (that’s us) to create software for their new device/OS platform.
<p>By the time we consumer software companies (independent software vendors or ISVs) get our hands on these products, we’re no longer solving the original customer problem. Instead, we’re programming for a device, and the device is solving the problem. When we program for a device we have certain limitations imposed by the hardware and software. The screen is only so big. There may or may not be a keyboard. There may or may not be much memory. There may or may not be good internet connectivity. The tools provided by the OS software developer may not be very powerful. There are a host of these limitations, and we have no control over them. It is the sandbox in which we have to play if we’re going to play at all.
<p>etc…..
</body></html>

That’s all there is to it. If you can master cut and paste and typing <p> you can create books out of text files. If you know a little HTML you can add bold, italics, underlines, and even tables and lists.

Regular Expressions 101 (Part 1)

Posted on: April 6th, 2007 by Craig Rairdin 1 Comment

Note: This corrects some missing pieces of information from the newsletter version of this article.

As users of PocketBible and MyBible you are aware that Laridian licenses books from Christian publishers and publishes them electronically. These include Bibles, commentaries, Bible dictionaries, devotionals and other Bible reference works that aren’t covered by those four general categories.

Since you’re getting this newsletter you are also familiar with our BookBuilder program which allows you to take original content (or content for private use) and turn it into a Laridian electronic book (.lbk). What you may or may not realize is that BookBuilder is the same program that we use internally to develop content for PocketBible and MyBible.

When we license content from Bible publishing houses we take what they give us as “electronic” files and turn it into what you purchase and install on your device. We get lots of different file formats from publishers: text files, pdf files, Quark files, Word documents, etc.

Since we get so many different file types there isn’t a specific program or procedure that we can use to automatically turn them into an .lbk. (Wouldn’t that be nice!?) The process is similar for each title, but not standardized.

What we work towards is to get every title into an html format and then we use TextPad to edit the html file. (An evaluation copy of TextPad is included with the BookBuilder product and also available at http://www.textpad.com/.)

One of the reasons we use TextPad is that it supports Search and Replacing using “Regular Expressions.” Regular Expressions (regexp or regexes) are a (very powerful) way of finding text using pattern matching. So, for instance, I can use regexps to find Bible references in a book file and insert tags around the references in a global manner.

Here’s an example:

To find Gen 2:7 or Romans 3:23 I would use the following regexp:

([A-Za-z]*)([0-9]*):([0-9]*)

The [A-Za-z] tells TextPad (or any other program that support regexp) to look for any letter, capital or lower case. The () around the [A-Za-z] is regexp way of telling the program to hold on to that character. The * tells the program that I’m looking for one or more character that matches and allows the program to keep it as a string. In our Bible reference example this would be Gen or Romans.

The next thing that you see in the regexp is a space. (Represented by ␢.) This is important as it helps to establish the pattern for which we are looking.

Understanding what the [A-Za-z] is doing makes it fairly straightforward to see what the next group is doing. [0-9] is looking for any number zero through nine. Again the () and * tell the program that we want to hang on to the string and it may be one or more character. In our Bible reference example this is the 2 or 3 indicating the chapter number.

The semicolon next again helps to establish the pattern. And the repeated ([0-9]*) is asking for the verse numbers. In our example the 7 and 23.

So, now what?

Now that you have the pattern established you can put this into the “Find what” field in TextPad. Making sure that the “Regular Expression” box is checked when you click “Find Next” you will step through your document finding each occurrence of a basic Bible reference.

The next step is to write your “Replace with” expression.

In the Laridian book we show that a Bible reference is a Bible reference using the following tag:

<pb_link format=”bcv | bc | cv | c | v”>…</pb_link>

So we would want the following tags for our examples:

<pb_link format=”bcv”>Gen 2:7</pb_link>

and

<pb_link format=”bcv”>Romans 3:23</pb_link>

Creating our “Replace with” expression is simple:

<pb_link format=”bcv”>1␢2:3</pb_link>

The only part of this expression that is regexp syntax are the 1 2 and 3. These indicate the three strings of () that we had collected in our “Find what” expression and indicate to the program where to place each string.

and. These indicate the three strings of that we had collected in our “Find what” expression and indicate to the program where to place each string.Two things to note:

1.) What I’ve just demonstrated here is done automatically in the VerseLinker program so it is rare that you would use this exact regexp in a Search and Replace. However, once you understand this you can use it to insert tags in commentaries that indicate where to place index and sync tags. (Your “Replace with” will be a different tag.) It also lays the ground work for some other powerful regexp that we’ll talk about in a later newsletter.

2.) This example will only find simple straightforward Bible references. You will need to restructure your “Find what” expression to find the following different kinds of Bible references: 1 Samuel 3:7-12; v. 1-3; Num 4; 3 John 8; Jude 3; etc. All of these can be handled with regexp, you just need to figure out how to structure your expressions.

This is a very simple example of what is a very powerful and potentially complex tool that we use to tag our books. Over the next few newsletters I’ll talk about more of the basics of regexp and maybe tackle some higher level expressions. In the course of tagging numerous books there really are only a handful of basic regexp components that are used regularly. I’ll try to cover these to give you what you need to tag just about anything.

Let me know if you have any specific questions or would like clarification on any of this.

New BookBuilder Update Released

Posted on: April 6th, 2007 by Craig Rairdin 2 Comments

BookBuilder has been updated to add a couple of small error-detection enhancements. The new version numbers are:

  • BookBuilder for MyBible 4.x: 1.4
  • BookBuilder for PocketBible 3.x: 1.2
  • BookBuilder Professional: 1.6
  • BookBuilder for the older PocketBible 2.x for Pocket PC is unchanged.

We have improved detection of misspelled or completely unrecognized tags, especially when they occur at a location which could logically be the end of a paragraph. Prior versions would treat an unknown tag at the end of a paragraph as the end of the paragraph, then skip everything from that position to the beginning of the next paragraph.

Prior versions of BookBuilder treat this as an error (because there is no such thing as a <multicolored> tag):

<p>This text is <b>bold, now add <multicolored>some color </multicolored> and end bold.</b></p>

But they would not see this as an error (even though there’s no such thing as <smallcaps>):

<p>This paragraph contained <smallcaps>text in small caps</smallcaps></p>
<p>This paragraph is OK.</p>

The paragraphs above would be rendered as follows, and no error message would be generated:

This paragraph contained
This paragraph is OK.

The new version will correctly identify both the <multicolored> and <smallcaps> tags as unrecognized.

We have also improved the determination of the error context when describing the location of a missing or unrecognized tag. The code to determine the starting position of the bad tag was simply incorrect and usually resulted in error messages that weren’t very helpful. The new code should more correctly identify the starting position of the context of a bad tag. Some minor message format changes were also made to make these error messages easier to read.

It’s possible that books that built correctly with an old version of BookBuilder contained errors that this new version will find. It would be a good idea to run old books through this new version to verify there aren’t any undetected bad tags.

As usual, there is no charge for this update. Just log into your download account and re-download and re-install BookBuilder.

Common BookBuilder Tagging Errors (Part III)

Posted on: April 6th, 2007 by Craig Rairdin 2 Comments

This is the third in what’s turning out to be a series of articles on proper HTML syntax in BookBuilder and some common tagging problems we see in user-created books. I didn’t think this was going to be a trilogy when I started, but there seems to be no shortage of tagging issues we can discuss. Here are a few more.

(more…)

BookBuilder Updated – Version 1.5

Posted on: December 17th, 2006 by Craig Rairdin 5 Comments

BookBuilder is a constantly evolving program. As we release new content for PocketBible and MyBible, we encounter new challenges in dealing with the text we receive from publishers. As a result we’re often making small tweaks to BookBuilder, VerseLinker, and the other tools that make up the BookBuilder family of products.
(more…)

BookBuilder Tech Tips: More Common Tagging Errors

Posted on: December 17th, 2006 by Craig Rairdin No Comments

The HTML parsing engine we use in BookBuilder is more sensitive to HTML syntax errors than your typical Web browser. We continue our article from a couple months ago regarding some common tagging habits that may cause errors when you try to build your book.
(more…)

BookBuilder Tech Tips: Proper HTML Syntax

Posted on: September 27th, 2006 by Craig Rairdin 1 Comment

The HTML parsing engine we use in BookBuilder is more sensitive to HTML syntax errors than your typical Web browser. Some commonly held bad habits will cause errors when you try to build your book. Here are some specific examples.

Improper use of <p> tag

There are two common but incorrect ways to use the <p> tag. Most people understand that the closing </p> tag is optional, but some have a habit of not using the opening <p> tag and instead using only </p>. This works in many browsers but not in BookBuilder. Others put <p> at the end of their paragraphs. This is actually interpreted by the browser or BookBuilder as a <p> at the beginning of the next paragraph. This may not cause problems but it leaves the first paragraph without a <p> tag and it adds an extra <p> tag at the end.

We’ve also seen people not use the <p> tag at all. Some use line breaks (<br> tags) at the end of paragraphs. The problem with this is that our readers load and display whole paragraphs at a time. If you write a long section of text with no <p> tags (using <br> tags to break lines at the end of your “paragraphs”), the program will have to load the entire section into memory before any of it can be displayed. This will cause noticeable delays in displaying your text.

Improper construction of lists

The <ul> and <ol> tags demarcate unordered (bulleted) and ordered (numbered) lists. Between <ul> and </ul> (or <ol> and </ol>) you are allowed only list items (<li> tags). You cannot intermix paragraphs (<p> tags) and list items.

Some browsers allow you to create a bulleted list by using <li> tags with no enclosing <ul> or <ol> tag. This is not proper HTML and will cause errors in BookBuilder.

The rule that disallows anything but list items within a list can also be inadvertently violated when embedding a list in another list. When creating an outline using list tags, make sure the sublists are enclosed inside the list item above them, as in the following example:

<ol type=I>
  <li>Main Point I
    <ol type=A>
      <li>Point A under I</li>
      <li>Point B</li>
    </ol></li>
  <li>Main Point II
    <ol type=A>
      <li>Point A under II
        <ol type=1>
          <li>Point 1 under A</li>
          <li>Point 2</li>
        </ol></li>
      <li>Point B under II</li>
    </ol></li>
</ol>

Note that all sublists are inside the <li>…</li> tags of the point directly above them.

As an efficiency consideration, remember that our readers load the entire outer list in memory at one time. If your outlines are long, they can take a long time to load and display. To avoid this problem, break your outermost list into pieces corresponding to list items. The list above would be rewritten as follows:

<ol type=I>
  <li>Main Point I
    <ol type=A>
      <li>Point A under I</li>
      <li>Point B</li>
    </ol></li>
</ol>
<ol type=I>
  <li value=2>Main Point II
    <ol type=A>
      <li>Point A under II
        <ol type=1>
          <li>Point 1 under A</li>
          <li>Point 2</li>
        </ol></li>
      <li>Point B under II</li>
    </ol></li>
</ol>

Note that it’s important to set the value parameter on list items after the first one so that the reader program knows this is a continuation of the previous list.

Improper use of tables

Tables, like lists, can be misued by including tags other than those allowed inside the <table>…</table> tags. You can not intermix paragraphs and table rows. The following might display correctly in your browser, but it will cause errors in BookBuilder:

<table>
  <tr><td>First row, first column</td><td>second column</td></tr>
  <p>This is a paragraph of text.</p>
  <tr><td>Second row, first column</td><td>second column</td></tr>
  Text without any tags
</table>

Both of the bold rows will cause errors.

Surrounding paragraphs with inline tags

Many browsers will allow you to create several bold paragraphs using syntax like this:

<b>
<p>This is the first bold paragraph…</p>
<p>This is the second…</p>
<p>And this is the third…</p>
</b>

This is illegal HTML. BookBuilder requires you to put inline tags like <b>, <i>, and <font> inside your paragraphs to comply with proper HTML syntax:

<p><b>This is the first bold paragraph…</b></p>
<p><b>This is the second…</b></p>
<p><b>And this is the third…</b></p>

Not reading the documentation

Finally, our best advice is to read and understand the BookBuilder documentation! It’s surprising how many questions we get are answered in the documentation. Spending a few minutes there will help you save hours of frustration later.

Using BookBuilder for Sunday School

Posted on: September 27th, 2006 by Craig Rairdin 3 Comments

As Publisher for Laridian I use BookBuilder Professional almost every working day. As a personal user I use it most work days and often both weekend days as well. Between the two, hardly a day goes by that I’m not working on BookBuilder source code or using the BookBuilder program. 

During the week I’m often working on the next PocketBible or MyBible book that we are releasing. I often spend several weeks to several months on one book. We do have other people who help us tag books, but even after they’re done with them it’s my responsibility to make sure the book works the way we expect it to. 

So you might think that when Friday comes the last thing I want to do is work on yet another book. You’d be wrong. 

My alter ego is a teacher for the college and career Sunday school class at our church. Right now we’re going through the book of Revelation. In June we finished going through the book of Genesis. 

Having access to the tools that I use for work allows me to use those same technologies for the Sunday school class. All of my notes, discussion questions and handouts are converted from Word to PDF. The PDF files are posted on the class web site so that if one of the members of our class misses a week they can easily download the notes and stay caught up. Since a number of the class members carry PDAs and use Laridian software I also convert the notes into PocketBible and MyBible reference titles. Those files are also posted on the class web site for download. 

Here’s how I go about preparing my lessons. (I know that most of you probably already do similar things when preparing a lesson, so I’m not going to focus so much on the mechanics of actually preparing a lesson as much as on how I use technology to bring it all together.) 

I read through the passage for the next class several times in different translations. Having PocketBible on my HP hx2750 makes this easy to do wherever I am…my son’s soccer game, my daughter’s volleyball game, in the line at Subway, in the car line at the kids’ school, in bed when I can’t sleep at 4:00 am, you get the picture. With PocketBible 3 having the ability to highlight and add notes is a huge benefit. My copy of Revelation on my PocketPC is already hugely marked up (and we’re still only on the first chapter). 

After having gone through the passage in the Bible I start reading through some commentaries. Some of them are in print and some are on my PocketPC. I like being able to use my PocketPC for the commentaries because I can highlight in the commentaries as well. I use one of those old fashioned stylus type things (it’s really just a piece of wood with lead in one end and a piece of rubber on the other) to mark up the commentaries that I’m using in print. 

After I go through the text and the commentaries I put all of my notes and the passages that I’ve marked in the commentaries into one MS Word document (usually denoted by the verse the commentaries are referencing). This document becomes the note file from which I build my lesson. With these notes compiled I begin the process of building the discussion questions for the class. Again, I initially use Word to create this file. As I write the questions for discussion I include the key points from my notes that will help me guide the discussion. (I use a different color to distinguish these “answers” from the questions.) Once that file is created I convert it to PDF. The PDF is then emailed to several in the class who are co-leaders (and in one case to a girl in the class who has hearing loss to help her better follow the discussion). This PDF is also uploaded to the class web site so that if someone misses a week they can stay caught up. The next thing I do is strip out everything that is part of the “answer” in the Word file. This document is also converted to PDF and becomes my handout. 

Finally it’s time to take the text to PocketBible and MyBible. I have an html file that is a cumulative study guide to the book we’re studying. The conversion from Word to html is a simple one. Word can save a file as html or some light hand editing works as well. Hand editing is required when there are specific PocketBible tags that are needed. I use TextPad to do any necessary search and replacing. TextPad makes use of “Regular Expressions” that allow me to do some complicated search and replaces easily. 

Going through Revelation I’ve found some times when I want to have the actual Greek displayed. BookBuilder allows me to do this using Unicode characters. The Unicode tables for Greek and Hebrew as well as transliteration are available as part of the documentation that is part of BookBuilder. 

Once the html file is ready I run it through VerseLinker to make sure the references are linked and then I run it through BookBuilder. I make sure the “Also create .pdb (MyBible)” box is checked and then I click “Go!” and in less than a minute I have my .lbk for PocketBible and .pdb for MyBible. These are also uploaded to the class web site. 

Since I use PocketBible during class it is very easy to hand out a list of references and ask the class members to read the verses and keep up with them. I simply tap the reference in my notes files and I’m there. Honestly though, I still tend to teach from a print copy of my notes. It’s easier for my eyes to jump around a full page than to try to scroll to the right section if we get ahead or need to go back during the discussion. 

Some of the class members have caught on that I upload the questions with answers the day before the class. It’s fun to see them sitting there with their PDA following along. 

Feel free to let me know if you have questions about how any of this works. If you want to see it in action feel free to visit our class web site at http://www.faith-focus.org/ignite.html. The PDFs, .lbks and .pdbs for Genesis and Revelation are all up there. You’re welcome to download them. But if you do…you have to let me know what you think. :) 

©2014 Laridian