Tuesday, November 27, 2012

Douglas A. Bauman - Resume


Douglas A. Bauman





QUALIFICATIONS
Worked as a project team member, mentor and team lead/designer on a wide variety of projects including e-business/enterprise applications, Swing based applications, high-level artificial intelligence (AI) applications and distributed multiprocessor applications. Currently I’m working in a production group as development point contact responsible for maintaining a large suite of successful Enterprise applications as well as for the design and development of new features for the ever growing product line. Other qualifications include work as a lead Java developer at a company which provides ‘Heatmaps’, a web and desktop software analysis tool for the trading desk visualization market (stock market). Another development effort concerned the use of JavaBeans as an interface to Active-X clients as it is applied to business process automation. Also designed and worked with a team to develop a real-time blackboard architecture with advanced control of knowledge sources and their application to total plant diagnostics, incremental rule base development and deployment, inter-process and socket communications, and portable graphical user interfaces. My most recent interests are with respect to Java/SQL for business analysis, visualization and communication, in e-business, enterprise, client server, or desktop application environments.

I have experience in the following programming languages, environments and hardware:

Lang. Java PL/SQL C# C++ C VB Lisp OPS5 Pascal PL/M
Years 17 10 2 16 22 7 6 4 5 5
Tech. UML/
Rose
Design Patterns J2EE EJB JNDI JMS/
Java-mail
JDBC-
SQL
JSP Custom Tags Struts
Years 3 12 10 10 3 2 14 4 3 2
Tech. Swing Java Beans XML RMI JNI HTML/ Javascript Threads VAJ/
WSAD
Motif X-Wind
Years 15 10 4 3 4 12 4 3 8 10
Oper.
System
UNIX Oracle Solaris Win
95/98/ME
NT/2000
/XP
OS/2 DOS VMS Micro-
Proc.
Network/
Sockets
Years 15 6 6 8 8 2 10 8 5 10


WORK HISTORY

  • May, 2003-Present, Management Science Associates (M.S.A)
    • Senior engineer and team lead designing, developing and maintaining the Deal Management, Commercial Instructions and whole suite of Gabriel media applications; developed in Java, PL/SQL(Oracle) and other languages like Visual Basic, C++ and C#.
      • Functional specifications and design/architecture for the applications
      • J2EE development using Weblogic and WebSphere connected with an Oracle backend
      • Code testing using JUnit Suites for unit and integration testing.
      • Integration testing with the functional team including QA and Docs
      • Oracle 10 DB development of PL/SQL and performance tuning of  SQL.
      • Mentor junior programmers in all aspects of software development process
    • Architect/engineer designing, developing and maintaining an automation testing framework using the Rational testing suite (developed with Java).
    • Aug, 2001-April, 2003 Ciber, Inc (consultant for Transtar, Inc), Technical lead designing and developing web-based applications in the Java language using a number of the technologies specified in the Java 2 Enterprise Edition. Advanced e-business enterprise system for car and train control, car order, revenue, scheduling, inventory, security, personnel, customers and all aspects for Transtar Inc. Responsibilities include:
      • Lead developer and mentor for core team of developers.
      • Design and development of J2EE MVC2 infrastructure/architecture including EJB design patterns.
      • Development of functional requirements/specification documentation.
      • Designing business related enterprise applications.
      • Developing using Java in IBM's WebSphere Studio (WSAD), and deployed to WebSphere.
      • Analysis and design reviews for fulfillment of requirements, techniques, patterns, algorithms and correctness.
      • Pier code reviews for other developers, including aspects of style, correctness and documentation.
      • Business logic developed using session and entity EJBs, and data access objects using JDBC and SQL for DB2 and Oracle.
      • Code testing using JUnit Suites for unit and integration testing.
      • Worked with the Q/A personnel to bring product life cycle requirements to fulfillment; use of Webrunner and Rational test tools.
      • Presentation tier developed using JSP and Custom Tags using MVC2 servlet/processor view/controller architecture designed and developed at the start of the project.
    • Feb, 2000-Jul, 2001 NeoVision Hypersystems, Involved with the design and development of Java-Swing based Visualization and analytic tool for the trading desk visualization market. The Heatmap tool is designed to cut through the information using simple and effective financial visualization technology. The graphical interfaces give traders, analysts, money managers and risk managers the ability to act on key financial information quickly and effectively. The tool is almost entirely implemented in the latest Java platform, and can be deployed either to the desktop, an enterprise or as a web application. It communicates via the Internet to multiple existing financial data sources for the real-time market information as well as Oracle and other databases.
    • Jan, 1998- Feb, 2000 Signature Solutions (now called Alventive, Inc.), working on advanced business information technology solutions for manufacturing visualization, business process automation, and configuration of product lines. Worked on the development of a Power Switching Center knowledge base and object oriented framework. This Sales Force Automation product configuration module is used by the Siemens Energy and Automation division Sales Force to configure a Power Switching Center either standalone or as part of a Unit Substation in conjunction with a Switchboard configuration development and verification effort. Began work on the application of EJB as the middleware for a Sales Force Automation initiative over the internet and the use of Java Swing components on the client using the web

    • 1980-Jan, 1998 Senior Engineer, Westinghouse Science and Technology Center. Designed and led a team of developers including myself with the software architecture for the Temelin Monitoring and Diagnostic System. This multiple processor real time system provides plant maintenance, engineering and operations personnel with expert information on plant equipment and systems and guidance with respect to phenomenon such as stress, chemistry and vibration analysis. It is based on a centralized blackboard architecture supported by knowledge sources and a control mechanism. I also led a team of engineers with the development of the expert system rule bases and scheduling criteria built on this extensible architecture.

    • Spent several months investigating the Java Development Kit in order to determine its feasibility with respect to extending and porting the above architecture. Actually implemented a distributed client server version of the Diagnostic and Monitoring System based on Java RMI/Sockets.
    • Developed several Visual C++ GUI programs for Windows NT/95, also ported part of the UNIX based blackboard architecture to NT to facilitate its distributed and extensible nature.
    • Developed a portable object oriented Motif based graphical user interface library for UNIX workstations and applied it to several user interface requirements for a Mitsubishi steel plant expert system application. The library was used by other members of the development team.
    • Worked on two diagnostics and monitoring systems including a neutron noise vibration monitoring system for nuclear cores employing digital signal processing (DSP) techniques.
    • Developed an intelligent PC-based training program for power system harmonics.
    • Developed a generic interactive menu graphical user interface based on script files.
    • Worked on a switchboard/panelboard automatic configuration program using OPS-5 and C. This project evolved into additional customer order engineering applications.
    • Developed an expert system shell called MAESTRO and have worked extensively on various expert systems, including a Transportation people-mover rule base, a metal-impact detection system for a nuclear application, and a Gen-Aid, Turbine-Aid expert system for the Power Generation Division.
    • Developed a microprocessor based elevator simulator used to verify elevator controllers.
    • Worked on a microprocessor controlled voice synthesis and voice recognition system for use with elevator and robotics applications

    EDUCATION
    B. S., Electrical Engineering and Mathematics, Carnegie Mellon University, 1980
    M. S., Electronic and Computer Engineering, Carnegie Mellon University, 1984
    Three month AI Internship, Carnegie Mellon University Robotics Institute and Intelligent Systems Laboratory, 1984



    AWARDS RECEIVED
    · Westinghouse Signature Award of Excellence, 1996
    · Westinghouse Inventor Recognition Award, 1995



    PATENTS AWARDED
    · Artificial intelligence software shell for plant operation simulation, 1995, #5412756
    · Case-based knowledge source for artificial intelligence software shell, 1995, #5402524
    · Interruptibility / priority control scheme for artificial intelligence, 1995, #5402526
    · Control process for artificial intelligence software shell, 1995, #5398304
    · Plant maintenance with predictive diagnostics, 1993, #5311562
    · Method and apparatus for auto-calibration of signal conditioning electronics, #4642636
    · Method and apparatus for preventing inadvertent criticality in a nuclear fueled electric powering generating unit #4582672
    · Elevator system with speech synthesizer for audible information, #4400786


    EXTERNAL PUBLICATIONS
    · "Integrating Equipment Condition Monitoring and Diagnostics Systems with Advanced Plant Information Systems," 1995 IEEE Nuclear Science Symposium and Medical Imaging Conference.
    · "Advanced Plant Information Systems using Intelligent Monitoring and Diagnostics and the ALLY Plant Monitoring and Diagnostics System," 1993 SMirt Conference, Konstanz, Germany.

    Tuesday, February 14, 2012

    Binary Tree Iterator


    import java.util.*;

    /** Binary Tree (not balanced) by Douglas A. Bauman
    ** also includes Iterator operation on the tree (inorder)
    **/
    public class NodeT<T> implements Iterable<T>
    {
    Integer data;
    NodeT left;
    NodeT right;
    NodeT parent;
    /* iterator and iterable contracts */
    public Iterator<T> iterator() {
    NodeTIterator result = new NodeTIterator(this);
    return result;
    }
    private class NodeTIterator implements Iterator<T> {
    NodeT cur;
    public NodeTIterator(NodeT n) {
    this.cur = n.getLeftMost();
    }
    /* Returns true if the iteration has more elements. */
    public boolean hasNext() {
    return cur != null;
    }
    /* Returns the next element in the iteration.*/
    public T next() {
    T r = null;
    if (cur != null) {
    r = (T)cur;
    cur = ((NodeT)cur).getNext();
    }
    return r;
    }
    /* Removes from the underlying collection the last element returned by the iterator (optional operation). */
    public void remove() {throw new UnsupportedOperationException("remove not implemented for NodeTIterator");}
    }
    /* constructor */
    public NodeT(Integer data, NodeT parent) {
    this.data = data;
    this.parent = parent;
    }
    public NodeT getLeftMost() {
    NodeT n = this;
    while (n.left != null) {
    n = n.left;
    }
    return n;
    }
    public NodeT getNext() {
    if (right != null) {
    return right.getLeftMost();
    } else {
    NodeT n = this;
    while (n.parent != null && n == n.parent.right) {
    n = n.parent;
    }
    return n.parent;
    }
    }
    /* recursively insert the data as a new node at the appropriate place using inorder placement */
    public NodeT insert(NodeT n, Integer data, int level, NodeT parent) {
    if (n == null) {
    // create new node
    n = (NodeT) new NodeT(data, parent);
    } else if (((Integer)data).intValue() > ((Integer)n.data).intValue()) {
    n.right = insert(n.right, data, level+1, n);
    } else {
    n.left = insert(n.left, data, level+1, n);
    }
    return n;
    }

    /** inorder find data in the tree by iterating, will be O(N) because iteration is in sort order, so not a good algorithm */
    public NodeT find(Integer data) {
    NodeT cur = getLeftMost();
    while (cur != null) {
    System.out.println("searching :"+cur.data);
    if (cur.data.intValue() == data.intValue()) return cur;
    cur = cur.getNext();
    }
    return null;
    }

    /* recursively find the data: should be O(logN) if this were a balanced tree (but it's not), but if it were, then this would be the better search */
    public NodeT findrec(Integer data, int level) {
    System.out.println("finding...:"+data+", this.data:"+this.data+" level:"+level);
    if (right!=null && data.intValue() > this.data.intValue()) {
    System.out.println("searching right:"+right.data);
    return right.findrec(data, level+1);
    } else if (data.intValue() == this.data.intValue()) {
    System.out.println("eq");
    return this;
    } else if (left!=null && data.intValue() < this.data.intValue()) {
    System.out.println("searching left:"+left.data);
    return left.findrec(data, level+1);
    }
    return null;
    }

    public void dumpnode(String tag, int level) {
    System.out.println("data: "+data+
    " "+tag+", parent: "+(parent==null?"null":""+parent.data)+
    ", left: "+(left==null?"null":""+left.data)+
    ", right: "+(right==null?"null":""+right.data)
    //", level:" +level
    );
    }

    /** inorder dump of the tree, so the values come out sorted **/
    public void dumptree(String tag, int level) {
    NodeT cur = getLeftMost();
    while (cur != null) {
    System.out.print(" " + cur.data);
    cur = cur.getNext();
    }
    System.out.println("");
    }

    /** inorder recursive dump of the tree, so the values come out sorted **/
    public void dumptreerec(String tag, int level) {
    if (left != null) left.dumptreerec("left", level+1);
    dumpnode(tag, level);
    if (right != null) right.dumptreerec("right", level+1);
    }

    public void dump(String tag) {
    System.out.println("In-Order Dump ("+tag+")");
    dumptree("root", 1);
    }

    public static void main(String[] args) {
    int array[] = { 3, 9, 1, 4, 8, 2, 5, 7, 0, 6 };
    // this array will generate: __3__
    //data: 0 (left) / \
    //data: 1 (left) 1 9
    //data: 2 (right) /\ /
    //data: 3 (root) 0 2 4
    //data: 4 (left) \
    //data: 5 (left) 8
    //data: 6 (left) /
    //data: 7 (right) 5
    //data: 8 (right) \
    //data: 9 (right) 7
    // /
    // 6
    int i;

    NodeT base = new NodeT(array[0], null);
    String buffer = "after added node " + array[0];
    base.dump(buffer);
    for (i = 1; i < array.length; i++) {
    buffer = "after added node " + array[i];
    base = base.insert(base, array[i], 1, null);
    base.dump(buffer);
    }

    System.out.println("\nrecursive dump:");
    base.dumptreerec("root", 1);

    System.out.println("\nrecursively find 9:");
    NodeT n = base.findrec(9, 1);
    if (n==null) System.out.println("...can't find 9");
    else n.dumpnode("found", 1);

    System.out.println("\n iteratively find 9:");
    n = base.find(9);
    if (n==null) System.out.println("...can't find 9");
    else n.dumpnode("found", 1);

    System.out.println("\niterate.....");
    for(Object k : base) {
    System.out.println("next k:"+((NodeT)k).data);
    }
    }

    //output will look like this:
    // In-Order Dump (after added node 3)
    // 3
    // In-Order Dump (after added node 9)
    // 3 9
    // In-Order Dump (after added node 1)
    // 1 3 9
    // In-Order Dump (after added node 4)
    // 1 3 4 9
    // In-Order Dump (after added node 8)
    // 1 3 4 8 9
    // In-Order Dump (after added node 2)
    // 1 2 3 4 8 9
    // In-Order Dump (after added node 5)
    // 1 2 3 4 5 8 9
    // In-Order Dump (after added node 7)
    // 1 2 3 4 5 7 8 9
    // In-Order Dump (after added node 0)
    // 0 1 2 3 4 5 7 8 9
    // In-Order Dump (after added node 6)
    // 0 1 2 3 4 5 6 7 8 9
    //
    // recursive dump:
    // data: 0 left, parent: 1, left: null, right: null
    // data: 1 left, parent: 3, left: 0, right: 2
    // data: 2 right, parent: 1, left: null, right: null
    // data: 3 root, parent: null, left: 1, right: 9
    // data: 4 left, parent: 9, left: null, right: 8
    // data: 5 left, parent: 8, left: null, right: 7
    // data: 6 left, parent: 7, left: null, right: null
    // data: 7 right, parent: 5, left: 6, right: null
    // data: 8 right, parent: 4, left: 5, right: null
    // data: 9 right, parent: 3, left: 4, right: null
    //
    // recursively find 9:
    // finding...:9, this.data:3 level:1
    // searching right:9
    // finding...:9, this.data:9 level:2
    // eq
    // data: 9 found, parent: 3, left: 4, right: null
    //
    // iteratively find 9:
    // searching :0
    // searching :1
    // searching :2
    // searching :3
    // searching :4
    // searching :5
    // searching :6
    // searching :7
    // searching :8
    // searching :9
    // data: 9 found, parent: 3, left: 4, right: null
    //
    // iterate.....
    // next k:0
    // next k:1
    // next k:2
    // next k:3
    // next k:4
    // next k:5
    // next k:6
    // next k:7
    // next k:8
    // next k:9
    }