The Origin of the Churches of Christ

I tried to write about the origins of the Churches of Christ, I really did; but it ended up feeling like writing a school report that no one, not even the teacher, wanted to hear. There just isn’t anything new there unless you are already predisposed to want the new paradigm that the Church of Christ founders were selling. So, cutting to the heart of the matter, here is a quick overview of what happened.

Barton W. Stone, like a plethora of religious men before (and after!) him were sure that the church they belonged to had interpreted God and Jesus wrong. It was, after all, right there in black and white. There was no possible way that anyone could interpret the bible different than they did. Barton’s only difference was that he pointed his founding myth [note 1] at the first Pentecost instead of somewhere else in his holy book.

At around the same time, Thomas and Alexander Campbell were doing something similar in a different part of the United States. While they might not have pointed their founding myth at Pentecost, they were sure that if people just read their holy book close enough that they would find what Jesus and his death really meant. Needless to say, he had also been booted from his church of origin as well.

Long story short, these men got together and other people followed their lead. They wanted to paper over all the differences in their belief, so they decided to just call themselves “Christians” and their church the “Christian Church”, “Churches of Christ”, “Disciples of Christ”, or something else that they could find in the translation of the Bible that they were using.

The differences weren’t as easy to paper over as the founders had hoped. It didn’t take long before the divisions grew in the fledgling church. The divisions grew into rifts and finally chasms. No one wanted to worship with unreformed heretics. Human nature asserted itself and the church disintegrated.

As the church split, each took a different name that was in use within the church. One branch took the name “Churches of Christ” while others split off into other divisions.

Notes, References, and Links

[1] Origin Myth: Founding Myth – Wikipedia

The Origin of the Churches of Christ – Barton W. Stone

The Origin of the Churches of Christ — Barton W. Stone

Note: This entry is an elaboration of history. While the events may be true, the motivations are fiction. This is a mixture of storytelling with Wikipedia and Wikisource entries. Each sentence or sentence fragment quoted from Wikipedia and Wikisource are not necessarily individually sourced, but all source material is included in the References section.

Our story begins toward the end of the 18th century. Barton W. Stone[1] was born to an upper-middle class family with connections into the upper class planters. After his father died and his mother moved,

Barton entered the Guilford Academy in North Carolina in 1790. While there, Stone heard James McGready (an evangelical Presbyterian minister) speak. A few years later, he was ordained as a Presbyterian minister.

Barton was coming of age at an opportune time for a minister. The Second Great Awakening is sweeping across the United States landscape. It was a United States that few of us would recognize. The west coast of the United States wasn’t the West Coast; instead, it was almost to the Mississippi River[2].

Barton found himself in Kentucky — which was about as far west as you could go and still be in the United States at the time — attending to the crowds during the Cane Ridge Revival[3]. Here, he was in contact with 18 other Presbyterian ministers and several Baptist and Methodist preachers. It was also here, hearing the sermons preached by his own as well as other denominations, that he became more convinced that organized religions were on the wrong path, preaching and teaching things that weren’t biblical. Even as his convictions took root, they wouldn’t blossom for a few more years.

In 1803, the full force of Barton’s displeasure of the Presbyterian church was felt. The Presbyterian church insisted on censuring a minister for deviation from doctrine of the Westminster Confession of Faith. But Barton, with his connections to upper class Plantation owners as well as government, had no intention of letting any religion run roughshod over the teachings of Jesus Christ. Barton, along with four other ministers, formed the Springfield Presbytery.

Barton’s fiery run-in with the church proved to be both enlightening and disastrous. Within a year, several congregations became associated with the Springfield Presbytery showing that there was, indeed, a desire to break from the stiff traditions and unyielding dogma of the Presbyterian church. However, in light of the rapid growth of the Springfield Presbytery, Barton realized that they were just creating a different flavor of Presbyterian. Barton had no interest in the Springfield Presbytery becoming a sect of the Presbyterian church; instead, he wanted the Church to be completely reformed in the image the followers of Jesus Christ on the Pentecost as depicted in Acts 2.

Barton was perfectly capable of stamping out his own creation. If the Springfield Presbytery wasn’t taking the correct path, then it would have to be destroyed. One year after the formation of the Springfield Presbytery, Barton and the other founders dissolved it, writing its Last Will and Testament to spread the word of its destruction. However, the ideas contained in the Last Will and Testament of The Springfield Presbytery[4] gave rise to a loosely organized group calling itself the Christian Church. These ideas included:

Imprimis. We will, that this body die, be dissolved, and sink into union with the Body of Christ at large; for there is but one body, and one Spirit, even as we are called in one hope of our calling.

Item. We will, that our power of making laws for the government of the church, and executing them by delegated authority, forever cease; that the people may have free course to the Bible, and adopt the law of the Spirit of life in Christ Jesus.

Item. We will, that the church of Christ resume her native right of internal government,—try her candidates for the ministry, as to their soundness in the faith, acquaintance with experimental religion, gravity and aptness to teach; and admit no other proof of their authority but Christ speaking in them.

Item. We will, that the people henceforth take the Bible as the only sure guide to heaven; and as many as are offended with other books, which stand in competition with it, may cast them into the fire if they choose; for it is better to enter into life having one book, than having many to be cast into hell.

Barton had finally gotten the church on the right path. Revival was happening in the United States and the people were looking for something that he and his movement could now provide. But there was no time to rest. The real work was only beginning. Now it was time to expand the Restoration Movement and bring the only valid interpretation of the Church of Jesus Christ to all the people that needed saving.

References

[1] Barton W. Stone – Wikipedia
[2] Territorial Evolution of the United States – Wikipedia
[3] Cane Ridge Revival – Wikipedia
[4] Last Will and Testament of The Springfield Presbytery – Wikisource

Java Graphics Programming Study 1: Simple Swing Graphics

I have been playing with Java Swing graphics programming. As it turns out, it is fairly easy and yet extremely powerful. Points, lines, colors, curves, and shapes are all created easily from existing classes. All I have to do is learn how to use them.

I would love to take full credit for this code, but most of it was created by someone else. I have been using the “Custom Graphics Programming – Java Programming Tutorial” for the raw material for this study: specifically, example 3 was my starting point.

I reworked the code to make it more to update it, make it more to my liking, and understand it better. I also extensively commented it for a more clear understanding.

If you would like to download the code I wrote, it is available for download here. You can either pull the java files out of the zip file or import the project into the NetBeans IDE.

The code consists of two different java files. No other resources other than those included with the Java Development Kit (JDK) are needed.

File # 1

package GUI;

// imports are individually listed for clarity
import java.awt.BorderLayout;       // for JFrame use
import java.awt.Color;              // for use in drawing
import java.awt.Dimension;          // for specifying JPanel size
import java.awt.Graphics;           // variable type passed to methods
import java.awt.event.MouseAdapter;         // for mouse tracking
import java.awt.event.MouseEvent;           // for mouse tracking
import java.awt.event.MouseMotionAdapter;   // for mouse tracking
import java.util.ArrayList;         // multiuse storage class
import javax.swing.JFrame;          // for creating JFrames
import javax.swing.JPanel;          // for creating JPanels
import javax.swing.SwingUtilities;  // to access the Event Dispatch Thread

public class GraphicsStudy extends JFrame {
    // class variables
    ArrayList<MultipointLine> linesArray;   // stores completed lines
    JPanel graphicsPanel;                   // used for the drawing surface
    MultipointLine currentLine;             // an individual line in progress
    
    // constructor sets up the entire JFrame window
    public GraphicsStudy() {
        // initialize the new array that will store all the finished lines
        linesArray = new ArrayList();
        // GraphicsPanel is an inside class
        // it is a JPanel that will be used for drawing
        graphicsPanel = new GraphicsPanel(600, 400);
        
        // add a mouse click listener
        // every time the mouse is clicked, start a new line
        graphicsPanel.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent event) {
                currentLine = new MultipointLine(event.getX(), event.getY());
                linesArray.add(currentLine);
            }
        });
        
        // add a mouse motion listener
        // when the mouse is dragged (button down while moving),
        // add points to the line that was created when the button
        // was initially pressed
        // then call for a repaint of the graphics area
        graphicsPanel.addMouseMotionListener(new MouseMotionAdapter() {
            @Override
            public void mouseDragged(MouseEvent event) {
                currentLine.addPoint(event.getX(), event.getY());
                repaint();
            }
        });
        
        // create the window, give it a title,
        // add the JPanel to the JFrame to use for drawing,
        // pack the JFrame,
        // use platform specific placement of the window,
        // and finally, make the window visible
        this.setTitle("Graphics Study");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.getContentPane().add(graphicsPanel, BorderLayout.CENTER);
        this.pack();                            // pack or set size
        this.setLocationByPlatform(true);
        this.setVisible(true);
    }
    
    
    public static void main(String[] args) {
        // all the main class has to do is call the
        // constructor for the JPanel and put it on
        // the event dispatch thread
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new GraphicsStudy();
            }
        });
    }
    
    // this is an inner class. It creates the Jpanel that
    // will be used as a drawing surface.
    class GraphicsPanel extends JPanel {
        
        // this constructor isn't really needed, but I am using
        // it to set the dimensions for the JPanel
        public GraphicsPanel(int rows, int cols) {
            this.setPreferredSize(new Dimension(rows, cols));
        }
        
        // Override the paintComponent method and put the
        // graphics creating code inside it.
        // Since it is an inner class, it can access the stored
        // lines from its parent class (GraphicsStudy).
        @Override
        protected void paintComponent(Graphics graphics) {
            // call the super method to paint the background
            super.paintComponent(graphics);
            
            // set the drawing line color
            // what can I say, Magenta is my color
            graphics.setColor(Color.MAGENTA);
            
            // draw the saved lines
            // lines were stored in the GraphicsStudy class
            // but can be accessed by this inner class
            for(MultipointLine line : linesArray) {
                line.drawMultipointLine(graphics);
            }
        }
    }
    
}

File # 2:

package GUI;

// import
import java.awt.Graphics;       // for drawLine function
import java.util.ArrayList;     // to store the points in the line

public class MultipointLine {
    private ArrayList<Integer> xArray;
    private ArrayList<Integer> yArray;
    
    // constructor creates a new line and sets the first point.
    // The constructor is called when the mouse button is pressed.
    public MultipointLine(int x, int y) {
        xArray = new ArrayList();
        yArray = new ArrayList();
        addPoint(x, y);
    }
    
    // add a point to the end of the x and y arrays.
    // these points will be used to draw a bunch of tiny lines
    final public void addPoint(int x, int y) {
        xArray.add(x);
        yArray.add(y);
    }
    
    // draw out the crazy line from the storage arrays
    public void drawMultipointLine(Graphics graphics) {
        for(int x = 0; x < xArray.size() - 1; ++x) {
            graphics.drawLine(xArray.get(x), yArray.get(x),
                    xArray.get(x+1), yArray.get(x+1));
        }
    }
}

Custom Graphics Programming – Java Programming Tutorial

I have been planning to write up something about Java’s graphics abilities and how to use them. In the process of exploring Java graphics, I stumbled on this site. It is so detailed that I have to share it.

https://www3.ntu.edu.sg/home/ehchua/programming/java/J4b_CustomGraphics.html

Apache Commons CSV study: reading files using CSVReader and writing files using CSVPrinter

When I am working on varying projects, I have found that many use the CSV format. I used to write the code to handle the csv files from scratch (they are just specialized text files after all), but I have found that Apache Commons already has the libraries to handle the CSV format. It can be found at http://commons.apache.org/proper/commons-csv/. All we have to do is get it to work.

With that in mind, I have a study of the code necessary to work with the csv library. The code is very ugly and repeats itself several times showing slightly different ways to write the csv file; still, it does show step by step everything you need to do to use it on files.

The CSV file I used to perform this study is located at http://elections.huffingtonpost.com/pollster/2014-alaska-senate-sullivan-vs-begich.csv. I renamed the file “alaska.csv”.

Update 1: code didn’t quite display correctly below due. I recopied the code into the code block correcting the display issues.

Update 2: If you want to download the code, makefiles, and CSV files that I used to create this project, it is available here = FileStudy.zip. It was created in the NetBeans IDE.

Update 3: I updated the title to be a little more descriptive of what the code does. I also recopied the code. As near as I can tell, every time I make a change to the template, the code gets modified. If the code isn’t clean and clear, you might want to download the zip file from Update 2. The zip file contains the actual files I used to create this java study.

package filestudy;

// individual imports for clarity
// this is the CSV package from Apache Commons
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVParser;
import org.apache.commons.csv.CSVPrinter;
import org.apache.commons.csv.CSVRecord;

import java.nio.charset.Charset;    // for the csv package
import java.util.ArrayList;         // for storage

// older file access methods since CSV requires them
import java.io.File;                // for CSVParser
import java.io.FileWriter;          // for CSVPrinter
import java.io.IOException;

// I will be using these to check for the existence
// and access rights to the file I want to access.
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.Files;

// I want to explore different ways to access the file system.
public class FileStudy {

    // I won't be using command line arguments.
    // All file access will be hard coded for clarity.
    public static void main(String[] args) {
        boolean fileDoesExist, fileDoesNotExist;
        String fileString, outputFileString;
        String outputFileString2, outputFileString3;
        String workingDirectoryString;
        Path pathAndFilename;
        File csvFile = null;
        FileWriter csvFileWriter = null;
        FileWriter csvFileWriter2 = null;
        FileWriter csvFileWriter3 = null;
        
        // should be the path directory where the class was invoked
        workingDirectoryString = System.getProperty("user.dir");
        System.out.println("Class Accessed from: " + workingDirectoryString);
        
        // append a filename to the path
        fileString = "alaska.csv";
        outputFileString = "alaska2.csv";
        outputFileString2 = "alaska3.csv";
        outputFileString3 = "alaska4.csv";
        pathAndFilename = Paths.get(workingDirectoryString, fileString);
        System.out.println("Expected path to file = " + pathAndFilename.toString());
        
        // Check if the file exists
        fileDoesExist = Files.exists(pathAndFilename);
        fileDoesNotExist = Files.notExists(pathAndFilename);
        System.out.println("Exists: " + fileDoesExist);
        System.out.println("Doesn't Exist: " + fileDoesNotExist);
        
        boolean csvFileWasRead = false;
        ArrayList<String[]> arrayList = new ArrayList();
        
        // open the file using older access methods
        // and read its contents into memory
        if(fileDoesExist && !fileDoesNotExist) {
            System.out.println("Accessing file now");
            CSVParser csvFileInput = null;
            int csvRecordValuesCount;
            String[] csvValueStorage;
            try {
                csvFile = new File(pathAndFilename.toString());
                csvFileInput = CSVParser.parse(
                                            csvFile,
                                            Charset.defaultCharset(),
                                            CSVFormat.DEFAULT);
               for(CSVRecord csvRecord : csvFileInput) {
                   System.out.println("Loading record # "
                           + csvFileInput.getRecordNumber());
                   csvRecordValuesCount = csvRecord.size();
                   csvValueStorage = new String[csvRecordValuesCount];
                   for(int x = 0; x < csvRecordValuesCount; x++) {
                       csvValueStorage[x] = csvRecord.get(x);
                   }
                   arrayList.add(csvValueStorage);
               }
               csvFileWasRead = true;
            } catch(IOException ioException) {
                System.out.println("IOException: " + ioException.getMessage());
            } catch(NullPointerException nullException) {
                System.out.println("Null Pointer Exception: " + nullException.getMessage());
            } finally {
                if(csvFileInput != null && !csvFileInput.isClosed()) {
                    try {
                    System.out.println("Closing csvFileInput");
                    csvFileInput.close();
                    } catch(IOException io) {
                        System.out.println("Complete File Failure: " + io.getMessage());
                        System.exit(1);
                    }
                } else {
                    System.out.println("I found nothing to close");
                }
            }
        }
        
        // if the read was successful, make a copy one value at a time
        if(csvFileWasRead) {
            int arrayLength = arrayList.size();
            int recordLength;
            String[] stringArrayToWrite;
            CSVPrinter csvPrinter = null;
            pathAndFilename = Paths.get(workingDirectoryString, outputFileString);
            try {
                System.out.println("Creating FileWriter");
                csvFileWriter = new FileWriter(pathAndFilename.toString());
                System.out.println("Creating CSVPrinter");
                csvPrinter = new CSVPrinter(csvFileWriter, CSVFormat.DEFAULT);
                for(int x = 0; x < arrayLength; x++) {
                    stringArrayToWrite = arrayList.get(x);
                    recordLength = stringArrayToWrite.length;
                    for(int y = 0; y < recordLength; y++) {
                        csvPrinter.print(stringArrayToWrite[y]);
                    }
                    csvPrinter.println();
                    System.out.println("Finished printing record # " + (x+1) + " at location " + x);
                }
            } catch(IOException writingError) {
                System.out.println("Error in writing: " + writingError.getMessage());
            } finally {
                if(csvPrinter != null) {
                    try {
                        System.out.println("Closing csvPrinter");
                        csvPrinter.close();
                    } catch(IOException closingError) {
                        System.out.println("Unable to close csvFileWriter: "
                                + closingError.getMessage());
                    }
                }
            }
        }

        // if the read was successful, make a
        // second copy using a different techinque
        if(csvFileWasRead) {
            int arrayLength = arrayList.size();
            String[] stringArrayToWrite;
            CSVPrinter csvPrinter = null;
            pathAndFilename = Paths.get(workingDirectoryString, outputFileString2);
            try {
                System.out.println("Creating FileWriter2");
                csvFileWriter2 = new FileWriter(pathAndFilename.toString());
                System.out.println("Creating CSVPrinter");
                csvPrinter = new CSVPrinter(csvFileWriter2, CSVFormat.DEFAULT);
                for(int x = 0; x < arrayLength; x++) {
                    stringArrayToWrite = arrayList.get(x);
                    csvPrinter.printRecord((Object[])stringArrayToWrite);
                }
            } catch(IOException writingError) {
                System.out.println("Error in writing: " + writingError.getMessage());
            } finally {
                if(csvPrinter != null) {
                    try {
                        System.out.println("Closing csvPrinter");
                        csvPrinter.close();
                    } catch(IOException closingError) {
                        System.out.println("Unable to close csvFileWriter: "
                                + closingError.getMessage());
                    }
                }
            }
        }
        
        // if the read was successful, make a
        // third copy using a different techinque
        if(csvFileWasRead) {
            CSVPrinter csvPrinter = null;
            pathAndFilename = Paths.get(workingDirectoryString, outputFileString3);
            try {
                System.out.println("Creating FileWriter3");
                csvFileWriter3 = new FileWriter(pathAndFilename.toString());
                System.out.println("Creating CSVPrinter");
                csvPrinter = new CSVPrinter(csvFileWriter3, CSVFormat.DEFAULT);
                csvPrinter.printRecords(arrayList);
            } catch(IOException writingError) {
                System.out.println("Error in writing: " + writingError.getMessage());
            } finally {
                if(csvPrinter != null) {
                    try {
                        System.out.println("Closing csvPrinter");
                        csvPrinter.close();
                    } catch(IOException closingError) {
                        System.out.println("Unable to close csvFileWriter: "
                                + closingError.getMessage());
                    }
                }
            }
        }
    }
    
}

I’ll be here shortly.

Just in case you stumbled on this blog, there isn’t much to see here yet. I am still in the process of setting it up. I am coming back to WordPress because I have heard that they handle publishing code better than some of the other sites.

The idea behind this blog is to publish some of the code that I am experimenting with, but don’t get too excited; it is more introductory code and learning concepts instead of production code.

One reason for this is that I formerly coded in C, followed by C++. Now, in an attempt to make things easier to cross the platform barrier, I am starting to work with Java. As I work out the different concepts, I hope to post the results here.

Other things that will be on this blog include various pictures that I draw as well as links to anything that interests me in general.

And that brings me to one last warning. I am an atheist as well as a feminist. I like to discuss those topics from time to time as well. Expect to see those topics come up here from time to time.