Transportation Request Form Template: Fill & Download for Free

My very first job surprised me. When first out of boot camp, and finishing IRT, I was told I had been assigned an MOS of 0141 - clerk typist. I thought this must be a mistake, even though I “could” type, it was about 20 wpm …. if you didn’t count off for mistakes. Seems that I had had a couple of years of college so I was educated and could type, ergo clerk typist. In college, I started as an architecture major then switched to stage design. I was a draftsman, a skilled carpenter, a welder. I could string and wire lighting equipment. I was skilled in pneumatics and hydraulics. Didn't matter, I was on my way to clerical school.Got to my first duty station and after a couple of days of KP and janitor duties while they got all us new arrivals assigned, found myself assigned to the Wing Engineer/Motor Transport Office. I showed up and was immediately sent to supply to obtain a drafting table and whatever drafting equipment I could lay my hands on.My first job was to draft a STOL landing field assembly for combat engineers. It turns out that the wing engineers office needed a draftsman but wasn't allowed one while they were located on an air base, the air base was supposed to provide all drafting capability. The base was cronicly short of draftsmen and always put the Wing drawing assignments on the bottom of the list. The Wing Engineer/Motor Transport office was allocated a clerk typist. Colonel Olsen, the Wing Engineer, going through the list of new arrivals, noticed my architecture and theatre design background and requested me, specifically for the clerical slot.I wound up only typing about 3 days a month, when the monthly wing vehicle and heavy equipment status report/inventory had to be put out.That was the job with the biggest surprise, I didn't have to peck away at a keyboard all day, thank God! I wound up deadheading equipment around, learned to drive every piece of equipment the Corps owned, drafting three weeks out of every four. When it came time to move on to my next assignment, I dutifully packed up the drafting board, T-square, triangles templates etc etc and headed to supply to turn it in. When I got there I was told I couldn't turn it in. My office and therefore me, wasn't allocated a draftsman, therefore I didn't have the equipment. If I did have the equipment that meant someone there had made a serious punishable offense. As no one there had made such a mistake, I obviously did not have the equipment and could not turn it in. I was also told if I abandoned whatever garbage I had in my boxes, in their lobby, they would have to destroy the items and charge me with littering and dumping household waste. After arguing for some time I gave up and left with the equipment.I used that equipment for many years and finally retired the last of it when I switched completely over to CAD.

Saw your post, wrote some notes & meant to respond. Wrote down now (Sunday night) but didn't finish w/ thoughts (late) but thought this might help for some input -- again, not complete but I saw that no one else responded so ... maybe this can spark some discussion and reasonable critiques.Assume:data coming from different sources in many different ways; relationships among data;backend that can be accessed by browser (web page) and other systems to access services that retrieve data (and potentially have to work on that data -- business logic)frontend web page that allows users to search for the databackend search allows searching for data using search-engine-like ways (e.g. search for phrases, search for wildcards, search based on words close to each other, sort the results based on relevance, provide faceted searching) and provides the ability to get deep relationships between the data (e.g. if one source of data has names of people & another source has publications by people's names & another source has companies people worked for, then we can return all that data related by person's name -- we can also determine if people potentially worked with that person e.g. like linked in does)More info on data coming from different sources (I'm puting in examples of data to explain what I mean by relationships. etc. - I know this isn't your actual data, of course):data will have different content (e.g. see above - 'list of people's names and companies', 'list of names and publications', etc.data from different sources will be received in different ways - restful web service to them, soap-based web service call to them, they call a web service on us, they drop a file onto our file system, etc.data format will be different - XML, JSON, CSV, etc.In most cases, we will know the structure - meaning, we know which fields are in the data (e.g. <name>tom thumb</name>). In cases where we don't, we'll treat it as a text file that can at least be searched.Based on the known structure of different inputs, we'll have to transform the data to a common representation in different cases for relationships (maybe) -- e.g. one source can have <name>tom thumb</name>, another can have lname=thumb, fname=tom. We want to transform them so that we can relate them on name (forget about the non-uniqueness of name for now -- it's just an example for discussion)we assume lots of data can be coming in -- so we need to make both the searching and the processing of the data fast and scalable (scalable meaning that we architect it in a way where we can break up the searching and processing -- e.g. adding data to the indexes -- to do it in parallel by adding more computers)we have a performance requirement where any query needs to have x seconds response timewe have a performance requirement where any new data coming in has to be available for searching w/in x secondsHow users and systems will use/access your data:We will know most of the 'relationship' queries (queries on words and phrases will be standard) - e.g. 1) users will want to see a person & which company they work for + what other companies they've worked for +, like linkedin, they'd like to see other people that person may know b/c they worked at the same company; 2) users will want to see a person and books or publications they've authoredfor now, we'll keep unanticipated relationship queries on hold :) - just make sure our architecture supports ituser is given a web page, selects query type (e.g. search for a term or phrase, get names of people and those whom they might have worked with), user enters search data (e.g. 'tom smith'), clicks on search button, and a request is made to get the data (and potentially apply some business logic to it) and presented to the userWe need to also provide non-user, electronic access to our application from other systems (e.g. we need to provide web services for them to access our data and business logic)Front-end architecture:we won't get into this here b/c you're asking about backend; we'll use angularJS b/c it provides a nice way to layer your front-end like we've always done in the backend. Again, won't get into here. We just mention that we'll have controllers, views, and services -- and the services will send restful web service requests to invoke services / get data from the backend,Backend Architecture - layers without frameworks - (without many of the helpful frameworks for now - discuss layers and what we need to do here):http layer to handle incoming http requests w/ two request types: a. mainly restful web service requests (b/c we're deciding to build a SPA app w/ angularJS where processing user actions, rendering the web page, etc. are done on the browser instead of on the server) - handles both requests from browser and requests from external systems and b. handling requests for the main / shell web page (angular) and when angular requests template web fragments;business logic layer (if processing of retrieved data is needed, it's in this layer -- e.g. as a java object);'data layer' - responsible for getting data from the relational db layer and/or the 'search/nosql' layer & combining them if necessary -- e.g. if data coming in fits a document structure (e.g. a file with xml that represents a document that needs to be searched) and it has a relationship w/ 2 other data sources of documents -- e.g. person's name i one document corresponds to name in another document that contains the list of books a person wrote then ... representing these relationships in nosql db lots of times requires copying the data (e.g. the list of books the person wrote) into the other data source (e.g. the data source with people's names and companies they work for). Reason is that a logical 'join' in nosql is not well-supported so ... copying data like this to make it available on a search may be needed. And ... when this gets to be a lot of relationships (including relationships w/ data that's coming from sources that aren't document-like -- e.g. just a couple pieces of data about the person's address) then we may want to put the relationships in a relational db. We then would have some reference in the relational db to the doc in the nosql db. Code would be needed to get the data from the relational db & then nosql db, combine it, and return it to the caller. Putting this into a 'data' layer insulates this from the business logic layer and allows us to do this cleanlyrelational layer (to access the relational database;search layer (this is a bit of a bad term - to access the nosql db if we use one);a layer that's responsible for accessing data from external systems. This 'comms' layer is responsible for getting data from external systems (all of the things we mentioned in the requirements -- calling web services of external systems, etc.). Processing files that are plopped into our file system will probably be done by a CRON job that runs a Java program that periodically checks for new files and then invokes a web service on our application to process it.Backend arch notes:when we use layers, the common vocabulary between layers is a domain model -- a set of java objects that represent the data in our application and its relationships. In pre-nosql days, most of these objects would also be persisted in the db. Also - important - given that the data can be document-oriented (meaning, it's an XML or JSON like structure), keeping the data in that representation betweeen the layers in some field of a domain model object is appropriate.IMPORTANT: may not need domain model objects for many cases -- can be just a JSON or XML string passed around between layers; need to see case-by-case; we can still have it as a domain model object & keep a field pointing to its XML or JSON representation; domain model object is nice to encapsulate the logical data & provide methods to access it and do some basic manipulation (lower-level than the business logic methods)IMPORTANT: you may not need all the layers; it may be just a simple call from the front-end to do a search and nothing else -- but since you still want to maybe filter the results of the results from the db or the nosql db, it's nice to have the logical layers, in my opinion. Some think it's too layer-oriented -- e.g. in many of my apps, I always had the http layer on the server side calling business logic java objects even when they did absolutely nothing but make a call to java objects at the "DAO" or relational layer - just to keep the paradigm.IMPORTANT: there's a hierarchy to the layers -- e.g. the business logic layer is usually accessed by the http layer; it calls the data layer (which calls the relational and search layers) and the comms layer (to get data from external systems)FLOW:The user request flow is: gui sends restful web service request --> server processes web service request and transforms the request into the domain model object parameters of the business logic method and calls that method --> business logic method calls the 'data' layer java object method to get data --> the 'data' layer java object method gets data from the relational db and/or the nosql db and puts it into the domain model object returned by the method to the business logic method --> business logic method may then need to make a call to another system to get or do something --> business logic code may need to do some processing on the data and it returns it to the http layer --> http layer puts it into a format (e.g. JSON) if it's not already in the form needed for the callerthe flow for the data coming in from various systems is: (just taking the example of calling an external system's web service to get the affiliate data) write code to call the external web service, transform it into the internal representation needed, determine relationships that need to be associated with existing data, add it to the appropriate db (nosql, db, etc.)Tools and frameworks that can help for the backend:HTTP LAYER: spring rest provides an easy way to implement restful web services - it also automatically handles translation (transformation) to JSON (based on annotations); we'll use that. Note: if you have time, do one web service call without the framework, translating the results to JSON. Then get an appreciation for what spring rest is doing for you.CODE TO INTERFACES AND BE ABLE TO REPLACE WITH DIFFERENT IMPLEMENTATIONS: b/c we want to be able to easily replace specific implementations of our code, we will always define our code using interfaces or base classes. We will use Spring's dependency injection to allow us to switch implementations easilySEARCH LAYER - SCALABLE SEARCH-LIKE CAPABILITIES IN DOCUMENT-LIKE DATA: analyzing our data sees that we're going to be handling large amounts of searches for documents and the users want a real search engine that provides relevance ranking of their searches and other cool search-engine results. We also need the search to be scalable where the documents are separated into batches and simultaneously searched. We'll also be searching large text areas in our documents. Given this, we'll use a document-model nosql search product - e.g. solr, marklogic, mongodb. IMPORTANT: Make sure that you create a base class or an interface that captures a common search API so that you can switch out marklogic, solr, etc (switch it out using spring dependency injection)RELATIONAL LAYER - RELATIONSHIPS BETWEEN DOCUMENT-LIKE DATA AND DATA THAT's MORE RECORD-ORIENTED: in addition, we see that we have lots of relationships between the different data sources. For some of this, we can use nosql to represent the relationships by favoring just copying the same data (e.g. if one source has documents of data w/ list of persons and their companies & another source has documents of data with persons and their publications, we can copy the data from the publications source to each document in the source that contains the person and their companies -- not great but may be ok if we're not talking about lots of relationships between data). For other data, however, copying all this data to make nosql 'join' all these docs together isn't good; we'll represent those relationships in a relational db (note that this means that when we do certain queries, etc., the data could be coming from the relational db and the nosql db & we'll need a java object that calls each and combines it - this is our 'data' layer). We'll use an ORM framework like JPA (hibernate) along with spring. We'll also use spring transactions (AOP)DATA LAYER - I need to think about a framework here - for now, it will be a set of java objects that do it (coded as all layers are coded -- interfaces w/ concrete implementations injected via spring dependency injections; method parameters and return values are domain model objects)SECURITY - need to add - authentication and authorization - the former isCOMMS LAYER - we need to do transformations here and call different 'transports' (web services, etc.). This is where we can use Spring Integration or Apache Camel. I've never used these -- we used a full ESB w/ an IBM product that had this functionality (I don't think a full ESB is needed -- but you might want to look into Mule -- our IBM product was - I think - a bit of overkill). For now, I'd have a set of java objects that manually did the call to the external systems and translated the domain model objects to the data needed for the calls -- then move into Spring Integration or Apache Camel after I got a feel for what they were saving me.TRANSACTIONS - use Spring AOP for this. Nice to be able to specify transactions without having to do it manually.PARALLEL AND DISTRIBUTED PROCESSING: This is where your selection of Akka comes in. I've never used it -- saw it once in a Scala program. People say it's nicer than doing it yourself with Java threads. Note: for getting the data from external systems, the things u need to parallelize would be calling external systems -- and that's not a lot of complexity. Systems that call our web services to send us data would get a new thread at http layer.Scalability:Search layer - using marklogic, for example, you can have it automatically break up your set of documents & use multiple computers in a cluster to search simultaneously. Indexing -- have to think about -- same thing?Relational layer - need to addComms layer - need to add* In all cases, use a load balancer for a clustered set of servers that provide the services -- e.g. a hardware one (e.g. F5) or s/w (e.g HAProxy) -- make sure you load balance calls to relational db, search, and http (http will handle all web service calls).NOTES:I'll have to think about the reactive frameworkskey for me - if i have time - i always want to work out at least conceptually what i'd have to do w/o the frameworks first

NOTE: the most up-to-date version of this answer is on my website at Meteor.js vs. the MEAN stack. See also Why Meteor.Meteor gives you a lot more out of the box. It's a mature full-stack framework where the client and the server communicate data updates seamlessly and automatically, without you having to write any boilerplate data sync code.The MEAN stack is just MongoDB, Express, Angular and Node.js bundled together, but there's nothing seamless about it. You have to do all the wiring-up yourself between MongoDB and Node.js, between Express and Angular, create REST endpoints and consume them etc. - all this just to get a basic web app going, without any features that Meteor gives you for free: hot code reload, mobile development (web, Android and iOS apps from the same code base), reactive templates that update automatically when data on the server changes (try to write code for that manually and make it run correctly over intermittent network connections, and make sure it's secure), session management, packages that can install components both on the server and on the client (e.g. server-side autocomplete - you won't find this anywhere else; Twitter's Typeahead and the like are client-only solutions).With the MEAN stack, when you make a REST request for a table/collection, you're essentially saying "Send me the results of this query". With Meteor, you subscribe to the results of that query, and any newly created or modified documents that matched will be automatically sent to the client over a fast WebSocket connection.Thanks to its isomorphic APIs (the same methods work on the client and the server, e.g. HTTP.get), Meteor makes it easier for one developer to build an entire full-stack app, or for a team to have a better understanding of the code base across the project. The MEAN stack adds to the separation between the server and the client due to different APIs being used.Guillermo Rauch, the well-known creator of Socket.IO, has written an excellent article call "7 Principles of Rich Web Applications". He's also delivered a talk at BrazilJS about the principles:Server rendered pages are not optionalAct immediately on user inputReact to data changesControl the data exchange with the serverDon’t break history, enhance itPush code updatesPredict behaviorMeteor focuses specifically on implementing #2, #3, #4 and #6 for the developer. #1 (server-rendered pages) and #5 (enhance history) are handled by ecosystem packages (Spiderable, Server-Side Rendering, and Iron Router). (#7 as described by Rauch, isn't really in the purview of full-stack frameworks.). By comparison, the MEAN stack needs to be coupled with Socket.IO to even have the pieces to implement these principles - Meteor already has them all glued together.Meteor also has the entire toolchain built-in, from compiling Coffeescript automatically to minifying and concatenating CSS and JS. Within seconds from saving a file, all client web browsers will automatically reload and re-render the app thanks to hot code push (#6 above). The UI state (form inputs, scroll position, selection) is preserved (another fun thing to try to get right with the MEAN stack).Meteor = MEAN stack + Socket.IO + grunt/gulp + Cordova + hot code reload + a lot more. Such as extremely convenient packages - one of the "Eureka" moments with Meteor is when authentication with user/password, Google, Facebook and Twitter is added just by including a package for each OAuth provider and one line of template code to indicate where to place the login widget:meteor add accounts-facebook // then add {{> loginButtons}} in your template to show the login UI Meteor has over 4,3000 packages. MEAN.JS has only one module so far, for SEO. Meteor lets you deploy with one command to free hosting at yourapp.meteor.com. The MEAN stack doesn't support deploying yet.But isn't that a lot to take in all at once? Actually, not. Thanks to Meteor's focus on simplicity (one of its Seven core principles), Meteor in its entirety is far easier to learn than Angular alone. (Many have found Angular to be a pain to learn and ended up frustrated - see An Unconventional Review of AngularJS). You can get the basics on Meteor in just one hour - head over to http://meteor.com/try. Meteor's documentation is also very well-written. By comparison, the documentation for the MEAN.io stack (the original before the MEAN.JS fork) is in such a terrible shape that today I went through the Packages section and found an embarrassing number of typos in just a few minutes, all within two pages of the documentation. Packages seem to have no documentation, either. And not to discredit the authors, but you can't easily find who the core team is - the link in Credits is broken. The documentation for the fork, MEAN.JS, starts with,After downloading the source code go over the official documentation of MongoDB, ExpressJS, AngularJS, and Node.js, then continue with the MEAN.JS Documentation.Given that it really takes only one hour to make something useful with Meteor, from scratch, it's worth simply giving it a try first, to have a reference before starting to learn MEAN.io or MEAN.JS.Meteor also saves you from having to research what libraries to use for the various layers of the application (transport, data synchronization, API, security, CRUD operations, templating etc.). All the pieces that make up Meteor function together very well.By contrast, when considering the MEAN stack, you start with the choice between MEAN.io and MEAN.JS. The short story is that the main MEAN.io contributor, Amos Haviv, Forked out of an open-source conflict in January 2014. You can read more about the story and differences on StackOverflow. This has split the community into ~6k GitHub stars for .io and ~2k for .js. Meteor by comparison has 23,000 GitHub stars.I've found that Meteor saved me from a lot of analysis paralysis, besides making me a ton more productive than if I had to put together the pieces in the MEAN stack. My suggestion is to read a bit on Why Meteor could be a good choice or not, give it a try first for one hour (meteor.com/try), then look at the MEAN stacks, and see which would work best for your project.PS: skip to 44:30 in Guillermo's talk above. Someone asks him about Meteor. A month later: https://twitter.com/rauchg/status/522228968074661889.