{% include meta.html %}
{{ site.description }}
The COMPASS Workshops are a series of free, open-source statistical programming and data science workshops held weekly during the academic year at Princeton University. Supported by the Department of Sociology, Department of Politics, and the Office of the President, the workshops focus on using R with RStudio in a variety of real-world applications relevant to social scientists. Topics covered include data wrangling, data visualization, Monte Carlo simulations, linear regression, social network analysis, and text mining.
The COMPASS Workshops are held on Tuesdays from 7:30 to 9:00pm in Room 307 at the McGraw Teaching Center in the Frist Campus Center at Princeton University during the academic year. The workshops are open to all students, staff, and affiliates of Princeton as well as the larger research community. To fully participate in the workshops participants should bring a laptop, although a few laptops are available at the workshops.
To find out more about the workshops, join the COMPASS Workshops mailing list by sending an email to<EMAIL_ADDRESS>with "Subscribe COMPASSWORKSHOPS" in the body and all other lines blank including the subject.
| September 20 | Introduction to R and RStudio |
| September 27 | Data Wrangling in R |
| October 4 | Base R Graphics |
| October 11 | Data Visualization in R with ggplot2 |
| October 18 | Programming Loops in R |
| November 8 | Probability and Simulations in R |
| November 15 | Monte Carlo Simulations in R |
| November 29 | Text Analysis in R |
| December 6 | Hypothesis Testing in R |
| December 13 | Regression Analysis in R |
Teaching Staffs
The workshops are taught by Ethan Fosse (Research Associate, Department of Sociology) and Yunkyu Sohn
(Research Associate, Department of Politics).
Faculty Sponsors
The workshops are sponsored by Margaret Frye (Assistant Professor, Department of Sociology),
Kosuke Imai (Professor, Department of Politics), and Matthew Salganik (Professor, Department of Sociology).


BuildAMation is open source software, using the BSD 3-clause license, available from github. You are free to fork the code to modify and build it yourself, or download prebuilt releases. The binaries provided in the prebuilt releases should be compatible on all applicable platforms, satisfying the requirements below.
The latest stable release is v1.0.2, published on 18th May 2016.
The latest beta release is v1.0.3 beta 1, published on 9th June 2016.
Please join in the discussion and watch for announcements in the BuildAMation Google Group.
BuildAMation (Bam) is a build system and project generator written in C#, requiring at least .NET framework 4.0 (requires support for LINQ and lambda expressions). Some familiarity with the C# language is assumed in this documentation and for using Bam.
Bam can be used on Microsoft Windows, Apple OSX, and some Linux distributions. OSX and Linux support for C# is provided through Mono currently.
Bam consists of a core assembly (Bam.Core.dll) that implements data agnostic algorithms for dependency evaluation. The specifics of compiling and linking code for programming languages, such as C and C++, toolchains (VisualC, Clang, Gcc, etc) are provided in packages that build upon the core infrastructure using a domain specific syntax that is declarative in nature.
Bam packages contain declarative propositions called modules, in the form of C# classes. Evaluation of the modules is out of order, following dependencies set up between them; thus package scripts are not imperatively evaluated. Packages can either provide new abstract data structures and algorithms to extend Bam into new areas, or can implement concrete modules that, when evaluated, actually build code. Every package requires a definition file (in XML) which defines all of its dependencies. Collections of packages can be grouped together logically into repositories.
Examples of the data structures provided by packages are C.DynamicLibrary
and C.StaticLibrary
, which are the base classes used to build a dynamic or static library in the C programming language. The namespace of the classes defines the package in which they belong.
Examples of algorithms provided by packages are the build modes. The default package repository in Bam provides four modes: Native (command line), MakeFile, VSSolution, and Xcode.
Bam benefits from the strongly typed nature of C#. In a declarative scripting language, where concrete instances of modules do not exist in user space, a dependency on a module is made by the type of the module, as a generic type parameter. Many utility functions exist that accept a module type as a generic argument. Interfaces are used to abstract away build settings that would otherwise require the user to be fluent in how to invoke many different tools to achieve the same desired effect. For example, each compiler flag is abstracted in a suitably named C# property in an interface, and each compiler implementation (in different packages) understands how to translate the value of that property, either as a command line switch, or as some field in a project script.
A command line tool, bam.exe, is provided to execute packages (a shell script is provided to wrap this on OSX and Linux). To build a package, run bam in that package's directory. That package is known as the master package. bam also contains support to create a project for both VisualStudio or Xamarin Studio to edit scripts or debug package builds.
Bam can perform many tasks to build code, but does not do the following:
C.IAdditionalSettings
interface, which allows arbitrary switches to be passed to tools.The competitors to Bam that I know of are:
These are the systems that have been used during testing, with * indicating the current development configuration of the author.
Install VisualStudio 2015 Community, from Microsoft.
Install VisualStudio 2013 Express, Update 5, from Microsoft.
Install VisualStudio 2012 Express, from Microsoft.
Install VisualStudio 2010 Express, and service pack 1, from Microsoft.
Install Mono for OSX or Linux (Xamarin packages recommended).
Install Xamarin Studio from the MonoDevelop site. (MonoDevelop was the previous name for Xamarin Studio.)
To install GCC 4.8 on CentOS 6, search the web for testing-devtools-2-centos-6.
From a binary distribution, open a terminal to the extracted files, and on Linux or OSX (or Windows msys), run
source env.sh
or on a Windows cmd prompt, run
env.bat
This will install Bam onto your PATH, and will show the details of the version of Bam on the console, for example:
BuildAMation (Bam) v1.0.1 (c) Mark Final, 2010-2016. Licensed under BSD 3-clause. See License.md. Parts of this software are licensed under the Microsoft Limited Public License (MS-PL). See MS-PL.md. Using C# compiler v4.0 with assemblies in /Users/mark/Downloads/BuildAMation-1.0.1/bin/Release
From source, you can compile Bam using the provided solution file, and run the tool through the IDE. This is useful if the core assembly needs to be updated. However, the general approach to using Bam is identical to that in the binary distribution. Note if you have compiled a debug version of the Core, then pass 'Debug' as an argument to the shell scripts mentioned above - the default is to use a 'Release' configuration.
The quickest way to try out Bam is to build the test cases. There is a test harness provided that uses Python 2 (2.7 assumed). Change to the tests folder and type
python runtests.py -c debug
which will build all applicable tests on your platform using the Native build mode. Pass --help
to that Python script to see more options.
Alternatively, change to one of the individual test package directories, and type the full Bam command line
bam -b=Native
Some tests have particular requirements, but most will build out of the box.
Running tests will give you a high level overview of how Bam works, but to get to the interesting details, you need to have some hands on experience. Below, is a guided example to follow.
A package is a folder on disk, identified by a 'bam' subdirectory, an .xml
file under 'bam', and containing one or more .cs
files in a Script subfolder. A package can be thought of to define classes and functions which implement modules.
Bam defines a collection of packages to be a package repository. There is a default package repository provided with the Bam binary distribution, and also in the source on github. Any number of repositories can be downloaded and use together to concatenate the set of packages required to build your software. A package repository consists of a packages folder, and optionally a tests folder, each containing Bam packages.
A package definition file is an XML file, implementing the schema provided with Bam, defining
For example, suppose VisualC packages with versions 14.0 and 13.0 have been specified in package definition files. Without any default specification, Bam will issue an error that it cannot solve the package version ambiguity. With a default specification on the version of the VisualC package you wish to use, no error will be issued. If you want to override the default specification on the command line, pass --VisualC.version=13.0
, say, to use version 13.0. This works for all packages, with a command line syntax of --packagename.version=someversion
.
Modules are the first class citizens of what Bam uses to build software. They are classes (sealed to be buildable, abstract/unsealed to define functionality) defined in package scripts, but there is no explicit instantiation of these classes in those scripts. The Bam core assembly deals with instantiating and ordering modules. Modules have methods that evaluate whether the code they reference is out of date. Modules also define policies, dependent on the build mode, of how to execute when they do require building.
The C# scripts define classes within a namespace, and the namespace is the package name. Bam uses this convention to search for modules within a specific package.
Almost everything is a module in the Bam world. So almost everything is buildable.
Dependencies are stated at the module level in package scripts. The basic module class is only aware of two axiomatic principles:
CompileAndLinkAgainst
.
Tools are a type of module, but can be referenced in when executing build mode policies of other modules. This means that tools can be procedurally generated as part of a build. Equally, prebuilt tools, such as C/C++ compilers, appear in the same guise - Bam just requires them to exist on disk already.
There are three build configurations in the Bam core assembly:
To build in just debug, specify --config=debug
on the command line, or specify no configuration options.
To build in both debug and profile, specify --config=debug --config=profile
on the command line. In a project generation build mode, projects with multiple configurations will be generated where possible.
Settings are classes closely associated with tools, which implement one or more settings interface, which just define properties. Each tool is associated with a Settings class. Each Settings class concatenates interfaces (through inheritence) to create a unique collection of properties. Each module has an instance of the settings for its tool, so that the execution of the tool can be tailored for that module.
Settings have defaults, but each module can override any default by applying a patch. Additionally, the defaults can be modified prior to patching via a site policy, e.g. say your software must build against the C++11 standard, while the default Bam compilation mode is C++98, the site policy allows this to be changed for your software in one place.
A patch is implemented in terms of a lambda function. Bam defines two types of patches, public and private. Private, as the name suggests, is applied just to the build of the module. Public patches get applied both to the build of the module, and any module that has defined a dependency on it.
The Bam build mode is the name of the policy to execute packages against. The core infrastructure does not have any dependency on specific build modes. Instead, implementations are discovered dynamically through reflection in the packages that are included in a build. Those build modes available are:
Modules have a dictionary of named macros. The key to the dictionary is a string. The value associated with each key is a TokenizedString, described below.
Bam defines strings with markup as TokenizedStrings. These use specical syntax to identify tokens in the strings, so that parameterization is possible. The tokens are evaluated from macros from multiple sources:
A simple example of a TokenizedString is
$(buildroot)which will look for the macro named buildroot in its sources, and if found, replaces the token with its value.
Simple TokenizedStrings, with no markup, just literal text, are known as verbatim. Some TokenizedStrings can be inlined into others (useful for modules and tools that refer to each others macros).
After macro replacement is complete, simple functions can be applied, e.g. get the basename of a file. This allows for a more powerful construction syntax. For example:
@basename(~/mark/dev/foobar.txt)will return
foobar
, while
@dir(~/mark/dev/foobar.txt)will return
~/mark/dev
.
There is also support for functions to run prior to macro replacement. For example:
$(MajorVersion).$(MinorVersion)#valid(.$(PatchVersion))runs the
valid
function to determine if its expression is a valid TokenizedString; if not, the whole function call is removed; if it is, only the expression remains.
All TokenizedStrings are parsed just prior to the dependency graph execution. This allows dynamic strings to be constructed, but altered as package scripts are executed. The parameterized source is terse, and references to macros offer an additional level of semantics.
Note that any TokenizedStrings created during dependency graph execution, will need to be manually parsed, using the Parse()
method.
If you use git for Windows 2.x with a bash shell, it is advised to run the bam command through winpty
, in order for bam to use console features such as progress updates.
Change the current directory to the package to be built (the master package).
bam --createdebugproject
or
bam -p
bam -b=mode
where mode is Native, MakeFile, VSSolution or Xcode.
There is built-in help in the Core assembly, as well as in packages offering command line options. The following command can be run in a package directory (in which case the packages used are inspected for additional options), or from any other directory (in which case only the Core options are shown)
bam --help
or
bam -h
A package can be any folder on disk, but usually containing source code. Identifying a Bam package is through inspection of files in specific locations within that folder. This allows Bam to integrate into most existing projects. The visual steps to identify a Bam package are:
Package directory contains a subdirectory called 'bam'.
A single .xml file exists in the bam folder, and follows the Bam schema.
A Scripts folder exists in the bam folder, and contains one or more .cs files, containing module scripts.
Optional: Sibling folders to Scripts, named after the build modes supported.
See any of the packages in the Bam distribution as examples.
Let's consider an example package called TestPackage. Suppose we have a directory 'TestPackage' containing a single source file main.c to build. We will assume that main.c contains some sensible C code to make an executable program, e.g. at least a main function. Note that for the benefit of this example, it's important to be C code, not C++, for example:
#include <stdio.h>
int main()
{
printf("Hello world\n");
return 0;
}
Making a package is the first step to using Bam. Change into the TestPackage directory, and type
bam --makepackage --pkgname=TestPackage
This will create the bam folder, the package definition file, and a script file that just contains the TestPackage namespace.
We intend to build some C code, so we need to pull in package dependencies that provide this support. Still in the TestPackage directory, type
bam --adddependent --pkgname=C
bam --adddependent --pkgname=NativeBuilder
bam --adddependent --pkgname=VSSolutionBuilder
bam --adddependent --pkgname=MakeFileBuilder
bam --adddependent --pkgname=XcodeBuilder
bam --adddependent --pkgname=VisualC --pkgversion=12.0
bam --adddependent --pkgname=Gcc --pkgversion=4.8
bam --adddependent --pkgname=Clang --pkgversion=Xcode6
These commands have modified the package definition file. To view what it contains, run this command
bam --showdefinition
Here is what you should see from running this command:
Definition of package 'TestPackage' ----------------------------------- Description: A new package called TestPackage Supported on: Windows Linux OSX BuildAMation assemblies: Bam.Core (requires version 1.0.1) DotNet assemblies: System (version 4.0.30319) System.Xml (version 4.0.30319) System.Core (version 4.0.30319) #defines: D_PACKAGE_TESTPACKAGE Dependent packages (* = default version): Package Name From Repository C /Users/mark/Downloads/BuildAMation-1.0.1/packages CommandLineProcessor /Users/mark/Downloads/BuildAMation-1.0.1/packages Clang-Xcode6 /Users/mark/Downloads/BuildAMation-1.0.1/packages ClangCommon /Users/mark/Downloads/BuildAMation-1.0.1/packages XcodeBuilder /Users/mark/Downloads/BuildAMation-1.0.1/packages XcodeProjectProcessor /Users/mark/Downloads/BuildAMation-1.0.1/packages Gcc-4.8 /Users/mark/Downloads/BuildAMation-1.0.1/packages GccCommon /Users/mark/Downloads/BuildAMation-1.0.1/packages MakeFileBuilder /Users/mark/Downloads/BuildAMation-1.0.1/packages NativeBuilder /Users/mark/Downloads/BuildAMation-1.0.1/packages CommandLineProcessor /Users/mark/Downloads/BuildAMation-1.0.1/packages VisualC-12.0 /Users/mark/Downloads/BuildAMation-1.0.1/packages VisualCCommon /Users/mark/Downloads/BuildAMation-1.0.1/packages VisualStudioProcessor /Users/mark/Downloads/BuildAMation-1.0.1/packages WindowsSDK-8.1 /Users/mark/Downloads/BuildAMation-1.0.1/packages VSSolutionBuilder /Users/mark/Downloads/BuildAMation-1.0.1/packages VisualStudioProcessor /Users/mark/Downloads/BuildAMation-1.0.1/packages
Note that you may see other packages listed in the output that you didn't include. This is because package definitions are evaluated recursively, and depending on package A will bring in all of A's dependents. For example, the VisualC-12.0 package is dependent upon both VisualCCommon and the WindowsSDK-8.1, neither of which were specified on the command line while setting up the test package.
Now that all the dependencies are set up, you can create a debuggable project. Still in the TestPackage directory, type
bam -p
The output will be similar to
Successfully created debug project for package 'TestPackage' /private/tmp/TestPackage/PackageDebug/TestPackage-bam.csprojThe generated project can be opened in VisualStudio or Xamarin Studio.
open -a 'xamarin studio' <.csproj path>
to open the project in Xamarin Studio. (The quotes are important.)gnome-open <.csproj path>
to open the project in Xamarin Studio.Once opened, you can browse the dependent packages, and their respective sources, using the IDE. Debugging this project will also run Bam - the entry point is in the main.cs file in the project.
To continue this example, open up TestPackage.cs from within the TestPackage package in the solution explorer.
In the script file created, define a module called MyProgram, which is a C (not C++) console application, compiling main.c in the package directory. We will revisit a C++ source file later.
namespace TestPackage
{
sealed class MyProgram :
C.ConsoleApplication
{
protected override void
Init(
Bam.Core.Module parent)
{
base.Init(parent);
this.CreateCSourceContainer("$(packagedir)/main.c");
if (this.Linker is VisualCCommon.LinkerBase)
{
this.LinkAgainst<WindowsSDK.WindowsSDK>();
}
}
}
}
TestPackage
.MyProgram
, which is the name of the class. The executable generated will use the module name. This can be overridden.C.ConsoleApplication
. This is a class from the C package (using the convention of package name as namespace), which defines the necessary infrastructure for compiling and linking a C console application.Init
function is overridden from the base class. Init is used to define the properties of the module. This is used instead of the module constructor, as there are restrictions before an object is constructed in C#.CreateCSourceContainer
, is invoked, passing a string which is internally converted to a TokenizedString. This function's implementation expands the parameterized string into file paths, and creates additional source file modules for each, and configures dependencies. Wildcards can be used in the path to evaluate to more than one file. In this case, there is only one, the file main.c in the package directory.LinkAgainst
is a generic function on the C.ConsoleApplication class, and required for building on Windows using the VisualC toolchain, because the import libraries for system DLLs can only be found in the WindowsSDK. Without this, there is a linker error that kernel32.lib cannot be found. By calling this function, the Bam core requires that an instance of the module specified as the type argument exists, and is a non-build requirement of the program. The predicate does infer a compile time dependency on the VisualCCommon package, so this code is only required when your package needs to build on Windows. Note that there is no explicit dependency on the WindowsSDK package that we specified above. It comes implicitly from the VisualC package.
bam -b=Native
The result will be an executable in a subdirectory of the build directory of the package. The root directory where files are built is configurable with the -o
command line argument.
Private patches are applied solely to the build of the module they are applied to. In this example, a C preprocessor definition is added to the compilation of the source file.
namespace TestPackage
{
sealed class MyProgram :
C.ConsoleApplication
{
protected override void
Init(
Bam.Core.Module parent)
{
base.Init(parent);
var sources = this.CreateCSourceContainer("$(packagedir)/main.c");
sources.PrivatePatch(settings =>
{
var compiler = settings as C.ICommonCompilerSettings;
compiler.PreprocessorDefines.Add("CUSTOM_DEFINE");
});
if (this.Linker is VisualCCommon.LinkerBase)
{
this.LinkAgainst<WindowsSDK.WindowsSDK>();
}
}
}
}
null
.C.ICommonCompilerSettings
interface contains a property, PreprocessorDefines
, allowing the module writer to manage preprocessor definitions in the build.
bam -b=Native
At this point, no modules will be rebuilt. Bam does not inspect for changed build settings between invocations, so a clean build is required to take on the updated settings. This is somewhat over-the-top in many cases, as simply deleting the object file would suffice.
bam -b=Native -c
If you inspect the command line output, you will see that CUSTOM_DEFINE is now passed as a preprocessor definition.
Public patches are applied both to the build of the module they are applied to, and any dependents. A common case for this kind of patch is for a C library (static or dynamic) that has headers, and must expose an include search path to any other module that uses the library.
Here's an example of a static library, assuming library.c is present in the package directory and contains suitable code, and library.h is in an include folder in the package directory, e.g.
#ifndef LIBRARY_H
#define LIBRARY_H
extern void printme(const char *string);
#endif /* LIBRARY_H */
#include <stdio.h>
void printme(const char *string)
{
printf("%s", string);
}
Here is the modified package script to include the build of the library, but not yet make the program depend on it.
namespace TestPackage
{
sealed class MyProgram :
C.ConsoleApplication
{
...
}
sealed class MyStaticLibrary :
C.StaticLibrary
{
protected override void
Init(
Bam.Core.Module parent)
{
base.Init(parent);
this.CreateCSourceContainer("$(packagedir)/library.c");
this.PublicPatch((settings, appliedTo) =>
{
var compiler = settings as C.ICommonCompilerSettings;
if (null != compiler)
{
compiler.IncludePaths.AddUnique(this.CreateTokenizedString("$(packagedir)/include"));
}
});
}
}
}
MyStaticLibrary
. Similarly to the program above, the name of the library generated will use the module name.C.StaticLibrary
to indicate that the module will be a static library.PublicPatch
is the function called. But note that the function is now applied on this
(the module to be built), rather then sources. The reason for this is that any dependency is written in terms of the module MyStaticLibrary, rather than on any source contained within it. Although the public patch is applied to this
, because the C source container is encapsulated within MyStaticLibrary, the patch is applied to the source automatically.settings
as before, and now also appliedTo
. The latter is the module on which the patch is being applied to. For some public patches, it may be useful to know the module on which the patch is being applied. However, as in the example, this
is usually the more useful module reference, to get the package directory of the source package, as opposed to using appliedTo
which would get a different package directory.CreateTokenizedString
, creates a TokenizedString that is tied to that module's macros for expansion. In this case, the TokenizedString function $(packagedir)
will evaluate to the package directory of the module MyStaticLibrary.Building the package now, requires no clean step, as a new module has been introduced. The output is the compilation and subsequent archiving of library.c into the static library. The program will not have changed.
Now change the program, so that it makes use of the library, e.g. change main.c to
#include <stdio.h>
#include "library.h"
int main()
{
printme("Hello world\n");
return 0;
}
Building the package now will result in a compilation failure. This is because Bam detects that the timestamp on the source file is now newer than it's corresponding object file and rebuilds it. The failure will be similar to this:
/private/tmp/TestPackage/main.c:2:10: fatal error: 'library.h' file not found #include "library.h" ^ 1 error generated. ERROR: (Bam.Core.Exception) Error during non-threaded build ERROR: (Bam.Core.Exception) Command failed: xcrun --sdk macosx10.10 clang -mmacosx-version-min=10.10 -std=c89 -arch x86_64 -g -fno-omit-frame-pointer -O0 -DD_BAM_CONFIGURATION_DEBUG -DD_BAM_PLATFORM_OSX -DD_BAM_PLATFORM_BITS=32 -DD_BAM_PLATFORM_LITTLEENDIAN -D_CONSOLE -DCUSTOM_DEFINE -x c -Werror -c -o /private/tmp/TestPackage/build/TestPackage/MyProgram/Debug/main.o -fvisibility=hidden /private/tmp/TestPackage/main.c Command exit code: 1
These changes require the program to depend on the static library for both compilation (#include'ing the header) and for link (linking the function code). The C.ConsoleApplication
module has a useful function to indicate how to do this.
namespace TestPackage
{
sealed class MyProgram :
C.ConsoleApplication
{
protected override void
Init(
Bam.Core.Module parent)
{
base.Init(parent);
var sources = this.CreateCSourceContainer("$(packagedir)/main.c");
sources.PrivatePatch(settings =>
{
var compiler = settings as C.ICommonCompilerSettings;
compiler.PreprocessorDefines.Add("CUSTOM_DEFINE");
});
if (this.Linker is VisualCCommon.LinkerBase)
{
this.LinkAgainst<WindowsSDK.WindowsSDK>();
}
this.CompileAndLinkAgainst<MyStaticLibrary>(sources);
}
}
sealed class MyStaticLibrary :
C.StaticLibrary
{
...
}
}
CompileAndLinkAgainst
is a generic function, that takes the dependent module type as the type argument, which Bam Core uses to set up module dependencies.this
, and this
is a program, a link dependency is set up. Bam Core is not aware of the mean of a link dependency, but it does know that the program depends on the static library to be up to date before the program can be up to date. However the C package does know that a link dependency means the static library needs to be passed as an argument to the linker for the program, once it is up-to-date.LinkAgainst
seen earlier, or compilation only (for header only libraries).Build the package once again, and you should see in the compiler console output that include paths are now included on both the program source and the library source, and the program links and will run.
Run a clean build to satisfy yourself that the static library is compiled and archived first.
In the examples above, we have used the Native build mode to run command line builds of the package. Bam supports other types of build modes, some of which are specific to certain platforms. All the generated files are put into the build root, but each build mode will write to the console where the files can be found.
Generate a VisualStudio solution by running
bam -b=VSSolution
Generate a MakeFile by running
bam -b=MakeFile
The Makefile generated uses GNU make syntax, and not NMake that VisualStudio supports.
Generate an Xcode workspace by running
bam -b=Xcode
The examples above all build C code. However, the C package understands more derivatives of the C language than just this. It understands C++, ObjectiveC and ObjectiveC++. Bam uses the type of the module to determine which language it is using, and thus apply different tools and settings. For example, as shown above, a C program uses the base type
C.ConsoleApplication
For a program that links C++ code, and thus requires the C++ linker, this would be
C.Cxx.ConsoleApplication
Similarly, for source code, instead of
this.CreateCSourceContainer(paths)
use
this.CreateCxxSourceContainer(paths)
in order to use the C++ compiler for the toolchain.
It is also possible, and sometimes required, to create multiple source containers, from different languages. There is no restriction on how many times you call one of the create container functions. Ensure that you always link with the correct module type in order to use the right linker for your code.
As much as building software is important, it is perhaps moreso to be able to distribute this to users in a binary form. This has a number of caveats, for example:
Bam tries to resolve much of this for you by way of the Publisher and Installer packages, in the default repository.
The Publisher package has three main components:
product.app/Contents/MacOSX
. All subsequent files collated are then written relative to that main binary, by options to each file. There is no fixed structure imposed by Bam. This allows for files to be placed next to the main binary, or in subdirectories next to it, or even back up and into other folders, such as collating frameworks for OSX application bundles.
An example of a full set of collation, debug symbols and stripped binaries can be seen below, taken from the bam-qt repository tests, where Qt5Application
is the main program (and thus main binary for collation). On OSX, this creates an application bundle. On Windows, in non-debug configurations, the runtime libraries are included.
sealed class Qt5Test1Runtime :
Publisher.Collation
{
protected override void
Init(
Bam.Core.Module parent)
{
base.Init(parent);
var app = this.Include(C.ConsoleApplication.Key, EPublishingType.WindowedApplication);
if (this.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.OSX))
{
var qtPackage = Bam.Core.Graph.Instance.Packages.Where(item => item.Name == "Qt").First();
var qtVersionSplit = qtPackage.Version.Split('.');
var updateInstallName = (System.Convert.ToInt32(qtVersionSplit[1]) < 5); // < Qt5.5 requires install name updates
this.IncludeFramework("../Frameworks", app, updateInstallName: updateInstallName);
this.IncludeFramework("../Frameworks", app, updateInstallName: updateInstallName);
this.IncludeFramework("../Frameworks", app, updateInstallName: updateInstallName);
// required by the platform plugin
this.IncludeFramework("../Frameworks", app, updateInstallName: updateInstallName);
#if D_PACKAGE_QT_5_5_1 || D_PACKAGE_QT_5_6_0
this.IncludeFramework("../Frameworks", app, updateInstallName: updateInstallName);
#endif
this.Include(C.Plugin.Key, "../Plugins/qtplugins/platforms", app);
this.IncludeFile(this.CreateTokenizedString("$(packagedir)/resources/osx/qt.conf"), "../Resources", app);
}
else
{
this.Include(C.DynamicLibrary.Key, ".", app);
this.Include(C.DynamicLibrary.Key, ".", app);
this.Include(C.DynamicLibrary.Key, ".", app);
this.Include(C.DynamicLibrary.Key, ".", app);
this.Include(C.DynamicLibrary.Key, ".", app);
this.Include(C.DynamicLibrary.Key, ".", app);
this.IncludeFile(this.CreateTokenizedString("$(packagedir)/resources/qt.conf"), ".", app);
var platformPlugin = this.Include(C.Plugin.Key, "qtplugins/platforms", app);
if (this.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.Linux))
{
this.ChangeRPath(platformPlugin, "$ORIGIN/../..");
this.Include(C.DynamicLibrary.Key, ".", app); // for qxcb plugin
#if D_PACKAGE_QT_5_5_1 || D_PACKAGE_QT_5_6_0
this.Include(C.DynamicLibrary.Key, ".", app);
#endif
}
if (this.BuildEnvironment.Platform.Includes(Bam.Core.EPlatform.Windows) &&
this.BuildEnvironment.Configuration != EConfiguration.Debug &&
(app.SourceModule as Qt5Application).Linker is VisualCCommon.LinkerBase)
{
var visualCRuntimeLibrary = Bam.Core.Graph.Instance.PackageMetaData("VisualC");
foreach (var libpath in visualCRuntimeLibrary.CRuntimePaths((app.SourceModule as C.CModule).BitDepth))
{
this.IncludeFile(libpath, ".", app);
}
foreach (var libpath in visualCRuntimeLibrary.CxxRuntimePaths((app.SourceModule as C.CModule).BitDepth))
{
this.IncludeFile(libpath, ".", app);
}
}
}
}
}
[Bam.Core.ConfigurationFilter(Bam.Core.EConfiguration.NotDebug)]
sealed class Qt5Test1DebugSymbols :
Publisher.DebugSymbolCollation
{
protected override void
Init(
Bam.Core.Module parent)
{
base.Init(parent);
this.CreateSymbolsFrom();
}
}
[Bam.Core.ConfigurationFilter(Bam.Core.EConfiguration.NotDebug)]
sealed class Qt5Test1Stripped :
Publisher.StrippedBinaryCollation
{
protected override void
Init(
Bam.Core.Module parent)
{
base.Init(parent);
this.StripBinariesFrom();
}
}
The result of executing these modules is three directories, with almost identical contents, representing a debuggable standalone distribution, all the debug symbols from the binaries, and a stripped standable distribution.
If a stripped distribution needs to be debugging, the contents of the debug symbol directory can just be copied on top of it, and the stripped binaries will then work in a debugging (assuming source is available on disk).
Generating an installer from your standalone distributable is one of the last steps in software development. Bam provides a number of mechanisms on each platform to create an installer. Note that installer generation is only available in Native build mode at this time. It is possible to create an installer from any of the Publishing steps, although most likely you will be interested in the stripped collation primarily, and the debug symbols will be useful to be archived.
Installers supported:
All methods take all the files from the collated module (whichever one you chose) and place the contents into the respective installer. A tar ball from the example above, using the stripped binary collation as the source for the installer, would be
sealed class TarBallInstaller :
Installer.TarBall
{
protected override void
Init(
Bam.Core.Module parent)
{
base.Init(parent);
this.SourceFolder<Qt5Test1Stripped>(Publisher.StrippedBinaryCollation.Key);
}
}
Existing functionality provides the minimum requirement for generating usable installers. Future versions of Bam will include more configurability.
Although Bam has a default package repository with functionality to get you started, there are other software packages and tools that exist that would benefit from being included as a Bam package. Some additional package repositories exist, that offer the Bam build scripts for you to include in your own software builds.
It is encouraged that anyone can provide and publish a package repository for anyone to use.
Please join in the discussion at the BuildAMation Google Group.
If you would prefer to contact me directly about BuildAMation, please email me on the address below. I am happy to provide advice to developers using Bam to build open source or personal projects, where my time allows.
You are free to use Bam for any commercial projects. For support/consultancy enquiries, please contact me to discuss.
Contact details:


RATS Speech Activity Detection, Linguistic Data Consortium (LDC) Catalog Number LDC2015S02 and ISBN 1-58563-706-8, was developed by LDC and is comprised of approximately 3,000 hours of Levantine Arabic, English, Farsi, Pashto, and Urdu conversational telephone speech with automatic and manual annotation of speech segments. The corpus was created to provide training, development and initial test sets for the Speech Activity Detection (SAD) task in the DARPA RATS (Robust Automatic Transcription of Speech) program.
The goal of the RATS program was to develop human language technology systems capable of performing speech detection, language identification, speaker identification and keyword spotting on the severely degraded audio signals that are typical of various radio communication channels, especially those employing various types of handheld portable transceiver systems. To support that goal, LDC assembled a system for the transmission, reception and digital capture of audio data that allowed a single source audio signal to be distributed and recorded over eight distinct transceiver configurations simultaneously. Those configurations included three frequencies -- high, very high and ultra high -- variously combined with amplitude modulation, frequency hopping spread spectrum, narrow-band frequency modulation, single-side-band or wide-band frequency modulation. Annotations on the clear source audio signal, e.g., time boundaries for the duration of speech activity, were projected onto the corresponding eight channels recorded from the radio receivers.
The source audio consists of conversational telephone speech recordings collected by LDC: (1) data collected for the RATS program from Levantine Arabic, Farsi, Pashto and Urdu speakers; and (2) material from the Fisher English (LDC2004S13, LDC2005S13), and Fisher Levantine Arabic telephone studies (LDC2007S02), as well as from CALLFRIEND Farsi (LDC2014S01).
Annotation was performed in three steps. LDC's automatic speech activity detector was run against the audio data to produce a speech segmentation for each file. Manual first pass annotation was then performed as a quick correction of the automatic speech activity detection output. Finally, in a manual second pass annotation step, annotators reviewed first pass output and made adjustments to segments as needed.
All audio files are presented as single-channel, 16-bit PCM, 16000 samples per second; lossless FLAC compression is used on all files; when uncompressed, the files have typical "MS-WAV" (RIFF) file headers.
Please see file.tbl for a complete file list as well as checksums for this publication.
Additional information, updates, bug fixes may be available in the LDC catalog entry for this corpus at LDC2015S02.
This material is based upon work supported by the Defense Advanced Research Projects Agency (DARPA) under Contract No. D10PC20016. The content does not necessarily reflect the position or the policy of the Government, and no official endorsement should be inferred.
Portions © 2015 Trustees of the University of Pennsylvania


Shigandang of Mount Tai is the succession and development of Sigandang. The consuetude of Shigandang of Mount Tai is the national non-material cultural heritage. It is also a natural folk- custom of China. It dates back to the ancient worship of celestial stone. Although the consuetude of Shigandang of Mount Tai is changing with the time, it has great influence on the Chinese people’s spirit.
In ancient times, there are a lot of worship, one of which is “ Shigandang of Mount Tai”: Stones carved with characters of Shigandang of Mount Tai [泰山石敢当], which are three feet and three inches tall, standing at bridges, communications centres, or being built in the walls of a house, can suppress all evils, which is very popular among the people.
In June 2006, it was included in the first batch of national non-material cultural heritage list.
There is a beautiful legend in it:
Once there lived a young man whose name was Shigandang in a village at the foot of Mount Tai. He was very brave, and showed sympathy for the poor, always taking up the cudgels for the injured party.
A daughter of a family in the south of Tai’an City, who was haunted by a monstert, became sallow and emaciated, so her parent sent for Shigandang.
Shigandang used a spell to drive the monster away, but the monster went to other places to do evil.
Shigandang thought out a way: he asked the mason to carve on the stone his home and name– Shigandang of Mount Tai [泰山石敢当].The evil-haunted family would put this stone outside of their door, so the monster dared not go in.
Since then, the story of getting rid of the evil spirit by Shigandang of Mount Tai has spread far and wide. Therefore, people all carve the five Chinese characters of Shigandang of Mount Tai [泰山石敢当] in stones, and put them at the foot of a wall, in the street, road hub and bridge end to keep their village and home safe.
Brief Biography of @bring— Old Wu, or 老吴 in Chinese: Old Wu, male, born on Dec. 12, 1968, Chinese nationality, is a good man and has been studying English for over 30 years. He teaches himself English, and he does not believe in fate, so he keeps working hard. Humorous and optimistic, he will become your good friend.
This page is synchronized from the post: Shigandang of Mount Tai (Non-material Cultural Heritage)


Luke Combs Breaks Records While Landing His First No.1 Album On Billboard 200
by Jamie SamhanLuke Combs has just gained his first No. 1 album on the Billboard 200 chart.
The country star released What You See Is What You Get on Nov. 8 and by the week ending on Nov. 14, the album had 172,000 equivalent album units in the United States.
Not only is Combs celebrating his No. 1 spot, the album also is the largest week for a country album in over a year and the biggest streaming week for a country album ever.
There was 74 million on-demand audio streams for all of the 17 tracks on What You See Is What You Get.
Combs’ last full-length studio album This One’s For You, which was released in 2017, peaked at No. 4 but has remained in the top 40 every week since June 2018.


Authenticate all users with Openid Connect.
Steps:
- Collect an client id & secret from your openid connect server so that jenkins can authenticate against the openid connect server.
- Add to the authorized redirect URLs the following: ${JENKINS_ROOT_URL}/securityRealm/finishLogin so that the callback for this jenkins is green lit.
- Fill in the client id and secret.
- Determine the token and authentication url of your openid connect provider. For us it's https://[dns-name]/openid/token/ and https://[dns-name]/openid/authorize/ for google the url's are: https://accounts.google.com/o/oauth2/token and https://accounts.google.com/o/oauth2/auth - your milage may vary. This is specific to your OIC provider.
- Fill in the url's and give it a go. - We suggest not setting security to logged in users only until you've successfully tested the authtentication.


Class container - a list of SQLObjects with aliases
# File lib/sqlobject.rb, line 199 def << ( *list ) @list += _getList *list return self end
# File lib/sqlobject.rb, line 216 def delete_if ( &block ) @list.delete_if &block end
# File lib/sqlobject.rb, line 212 def each ( &block ) @list.each &block end
# File lib/sqlobject.rb, line 232 def each_with_index ( &block ) @list.each_with_index &block end
# File lib/sqlobject.rb, line 224 def find ( &block ) @list.find &block end
# File lib/sqlobject.rb, line 204 def push ( *list ) @list += _getList( *list ) end
# File lib/sqlobject.rb, line 245 def _getList ( *list ) new_list = [ ] # If list is a hash of objects with aliases: if list.length == 1 && list[0].is_a?( Hash ) new_list += _hash2array list[0] # If list is an array of objects: else new_list = list.map { |src| SQLObject.get src } end end
Generated with the Darkfish Rdoc Generator 2.


In this post I want to make a short list of different ways to detect errors and bottle necks in our PHP projects. It’s an informal list of recommendations and best practises useful at least for me
Indent code.
Python has a great characteristic. Code blocks are defined with indentation. Not with any especial character like other program languages. That’s means if you don’t want syntax errors and you want to execute your program, your script must be properly indented. That’s is a great practise., even in program languages not as restrictive as python with code indention. For example when I need to check a piece of code with a any kind of error, if it isn’t correctly indented I start to indent it. I know it isn’t necessary but for me at least it helps me to understand the code (if I’m not the original developer of the code) and quickly find errors like wrong if clauses and another things like that.
Analyze code and check syntax
You must use a modern text editor or IDE with at least check syntax and also code analyze tools. That’s mandatory. Chose what you want but use one. Zend Studio is a great tool but you also can do it with another editors, even with vi. You can programing PHP with notepad but it’s definitely a waste of time. You will use significant less time programming with modern IDE. I like Zend Studio code Analyzer. It helps you with errors easy to implement and difficult to find like :
// error 1
if ($a=1) {
// error 2
$variable= 2;
if ($Variable == 2) {
...
}
I like to fix every warning even if those warnings are recommendations and not in fact a problem.
Check indentation level.
Even with a perfect indentation big indentation level is a clear signal of “code smell”. Take care of it. If you see a big indentation level you must ask yourself: Is it really the way to do it?
Loops.
If you want to check performance issues and you don’t have too many time,focus yourself finding loops and analyze them. If there is a performance problem is very probably to discover your problem inside a loop. One slow operation executed one time is a problem. But if this operation is executed 1000 times inside a loop is definitely a big problem. OK it’s the same problem but the impact is 1000 times bigger.
Copy-paste code
Avoid them like a plague. It can be helpfully and attractive but the use of the same piece of code distributed among a set of source code files will give you definitely a headache in the future, Be sure about it. We have a lot techniques in to avoid copy and paste code.


XiaoGuTech,Welcome the partners with abundant industry resources and profound industry accumulation to jointly develop the face recognition market, customize the overall face recognition solution for users, and promote a win-win situation for both sides.
For details, please consult：0731-85058649


Liverpool have made this key decision for Carabao Cup clash with Aston Villa
Aston Villa meet Liverpool in the final eight of the Carabao Cup, with AVFC looking to spring a surprise against the league leaders
by Ben Husband, https://www.birminghammail.co.uk/authors/ben-husband/Liverpool have confirmed that U23 coach Neil Critchley will take charge of a much changed squad when they take on Aston Villa in the Carabao Cup quarter final.
The Reds are splitting their squad into two, with the more senior players flying out to Qatar to play in the Club World Cup.
Villa face Liverpool in B6 on December 17, with Klopp leading out the rest of his players in the semi final of the Club World Cup 24 hours later.
Crithcley will be in charge of a young squad, who have managed to navigate their way to the last eight of the domestic cup competition.
A number of youngsters are expected to be involved against Villa, with Rhian Brewster, Caoimhin Kelleher, Sepp van den Berg, Curtis Jones and Harvey Elliott all set to be involved.
The Mirror has claimed that Jurgen Klopp was keen to put some senior players in the squad for the Villa game, but the consensus from the playing squad was they would rather play in the ‘bigger’ competition.
The side will be reminiscent of the one that beat Arsenal on penalties in the previous round after a remarkable 5-5 draw.
Crfitchley has been shadowing Klopp in recent weeks in order for their preparations to be as close as normal.
Villa also faced a very young Wolves team in the previous round. Nuno Espirito Santo made a whole host of changes, with Dean Smith’s men coming out as 2-1 winners.
Aston Villa latest
This is your round up of all things Villa; the one-stop shop that will keep you updated on the latest goings on at the club and beyond.
Transfers, injuries, match-days and managers, we’ve got you covered.
We’ll be bringing the very latest on the Villains throughout the week and around the clock.
Make sure you keep yourself updated with our handy daily catch up...
Must reads...
- Dean Smith fires Aston Villa transfer warning to Man United
- The injury update Aston Villa fans have been waiting for
- Aston Villa boss issues blunt Steve Bruce warning
- Club make decision on Villa target ahead of January
For all your latest AVFC news, opinion, analysis and transfer gossip, click here
You can follow our Villa reporter Ashley Preece on Twitter, and his email address is Ashley.Preece@reachplc.com.


Earliest sunsets of the year this week in Southwest Florida
by WFTX Digital TeamLEE COUNTY, Fla. -- Southwest Florida is seeing its earliest sunsets of the year this week, as we approach the winter solstice.
Beginning on Monday, November 25th, the sun has been setting at Sanibel Island at 5:35 p.m. It will continue to set at that time through December 6th, when it begins to slowly happen later each evening.
However, that doesn't mean our days are getting longer again just yet. Since the sunrise time is moving later at a faster pace in December, the amount of daylight each day will continue to shorten until the winter solstice on December 21st.
That day, Southwest Florida will only see just under 10 hours and 28 minutes of daylight.
.


I am an aspiring software engineer. I will graduate in May with a bachelor's degree in Computer Engineering from Lehigh University. In my free time, I write poetry, practice martial arts, and hike. I am currently searching for a job in my field. I have a stronger interest in software over hardware. In my software classes, I have primarily used Java. I have been learning vanilla Javascript, Jquery, and HTML/CSS for personal projects. This portfolio displays a few of my projects. I am currently developing an online card game called Rock Roulette with my friend. I am working on the server using node.js and express.js. You can play the current version of our game by clicking the link attached to the project's picture.
Email: cgelotte218@gmail.com


Technical writer / Copywriter
City
Experience
Key requirements:
- - 2 years of experience in a similar position;
- - Experience in modeling processes in UML;
- - Skills in writing clear, understandable and consistent technical requirements;
- - Skills in working with tools for managing requirements, tasks and versions;
- - An active approach and good communication skills;
- - Experience and understanding of the SCRUM methodology;
- - Competent written speech, ability to work with large amounts of data, attentiveness
- - Knowledge of English - Intermediate and higher;
- - Jira, Confluence;
Lorem ipsum dolor sit amet consectetur, adipisicing elit. Incidunt, porro.
 Fugit corporis aliquam cumque quos ducimus optio nobis.
Lorem, ipsum dolor.
Lorem, ipsum dolor sit amet consectetur adipisicing elit. Fugit corporis aliquam cumque quos ducimus optio nobis.
Lorem ipsum dolor sit.
Lorem, ipsum dolor sit amet consectetur adipisicing elit. Fugit corporis aliquam cumque quos ducimus optio nobis.
Lorem ipsum dolor sit amet consectetur.
Lorem, ipsum dolor sit amet consectetur adipisicing elit. Fugit corporis aliquam cumque quos ducimus optio nobis.
Lorem, ipsum dolor sit amet consectetur adipisicing elit. Fugit corporis aliquam cumque quos ducimus optio nobis.
- one
- two
- three
- four
- five
Lorem, ipsum dolor sit amet consectetur adipisicing elit. Fugit corporis aliquam cumque quos ducimus optio nobis.


My Team and I designed a volunteer portal catered to young adults for United Way. The portal would
be added as an extension to their existing website and is designed using their style guides. We
propose a focus on advertising the volunteer opportunities on College/University Job boards with a
direct link to the portal. People can create a profile and easily apply to take part in volunteer
opportunities in their community.
The target audience for this portal is college/university student who need to complete mandatory community service hours.
It is a place to make it easier for students to find opportunities that will help them with completing their goals, as well
as help United Way complete their goals. With the implementation of this portal and marketing campaign we predict that more
young adults will volunteer.
GenNext volunteering board listed along with post-secondary job boards
Creates a direct link to make it accessible
Updates proof of skills, networking opportunities, education, & character development
Re-advertising, updating the way united way presents their volunteer opportunities
Better chance at connecting to young adults
having greater involvement among that demographic
A portal on GenNext for young adults to browse, engage, and apply to volunteer opportunities that suits their
skill sets


Wast thou fastened by a blasphemous mumpsimus, or is thy brother-in-law normally so ostentatiously bug-eyed?
Hath thy lack-witted manner affrighted a woman to birth a blob of dizzy-hearted swordfish?
You flock of overripe sons of a gudgeon.
Wast thou admired by a cruelty-vexing catawump, or is that simply how thy shawl is?


The best way to think of this is that there is an invisible grid on the webpage which the smaller boxes can align to. You can of course go deeper and imagine every box has an invisible grid of its own, and you can put as many boxes within a box as needed. This allows the developer to easily align and position elements on a webpage, and offers the added advantage that a total page layout overhaul can be done relatively quickly by simplay moving boxes around on the grid.
In this day and age it is essential that websites be designed with responsive pages. The number of people viewing webpages on mobile devices increases every day, so if you want a website that people will find useful, it needs to be able to transform depending on the size of the screen it is being viewed on. Responsive webpages are able to detect the size of the screen, and the type of device and change the entire layout, colour, text size and even hide certain content from the webpage to enable it to be viewed easily and navigated easily no matter the screen size.
Semantic structure HTML uses elements which are easy to interperate by both the computer and human reading the code. This is achieved in a number of different ways, but the most common is by adding id="description of element" within the div tag of specific content on the webpage.


From EnsemblMetazoa:
Caenorhabditis japonica is a small, free-living roundworm which appears to be closely-associated with shield, or stink, bugs. Frequently, these insects can be found on cabbage plants and the worms have been reported feeding in the bug's nest on dead eggs and adult bugs. C. japonica has only been isolated on the Japanese islands of Saga and Shikoku. The biology of C. japonica is similar to that of C. elegans with the exception that C. japonica has both male and female adults.
C. japonica was first described by Kiontke, Hironaka and Sudhaus in 2002. The sequenced strain DF5081 was derived from a wild isolate DF5080, isolated from a dead shield bug (Parastrachia japonensis) in Takeo, Japan by Toyoshi Yoshiga. The wild isolate was inbred for 20 generations in the lab of David Fitch by transferral of a single plugged gravid female per generation.


Yifei Zhou
Welcome to IS445 Homework 2
Eudcation
2017 BA, Management of Information System, California State University, Long Beach
Working Experience
Student Assistant, CSULB, 3.5 years
Expectation for this course
Learn how to create a web page and to do a HTML project


|
|
Boost.RegexContacts and Acknowledgements |
|
The author can be contacted at<EMAIL_ADDRESS>the home page for this library is at www.boost.org.
I am indebted to Robert Sedgewick's "Algorithms in C++" for forcing me to think about algorithms and their performance, and to the folks at boost for forcing me to think, period.
Eric Niebler, author of the GRETA regular expression component, has shared several important ideas, in a series of long discussions.
Pete Becker, of Dinkumware Ltd, has helped enormously with the standardisation proposal language.
The following people have all contributed useful comments or fixes: Dave Abrahams, Mike Allison, Edan Ayal, Jayashree Balasubramanian, Jan Bölsche, Beman Dawes, Paul Baxter, David Bergman, David Dennerline, Edward Diener, Peter Dimov, Robert Dunn, Fabio Forno, Tobias Gabrielsson, Rob Gillen, Marc Gregoire, Chris Hecker, Nick Hodapp, Jesse Jones, Martin Jost, Boris Krasnovskiy, Jan Hermelink, Max Leung, Wei-hao Lin, Jens Maurer, Richard Peters, Heiko Schmidt, Jason Shirk, Gerald Slacik, Scobie Smith, Mike Smyth, Alexander Sokolovsky, Hervé Poirier, Michael Raykh, Marc Recht, Scott VanCamp, Bruno Voigt, Alexey Voinov, Jerry Waldorf, Rob Ward, Lealon Watts, John Wismar, Thomas Witt and Yuval Yosef. I am also grateful to the manuals supplied with the Henry Spencer, Perl and GNU regular expression libraries - wherever possible I have tried to maintain compatibility with these libraries and with the POSIX standard - the code however is entirely my own, including any bugs! I can absolutely guarantee that I will not fix any bugs I don't know about, so if you have any comments or spot any bugs, please get in touch.
Useful further information can be found at:
Short tutorials on regular expressions can be found here and here.
The main book on regular expressions is Mastering Regular Expressions, published by O'Reilly.
Information on the Boost.regex standardization proposal, along with other standard library extension proposals can be found on the C++ Committees web pages.
TheOpen Unix Specification contains a wealth of useful material, including the regular expression syntax, and specifications for <regex.h> and <nl_types.h>.
The Pattern Matching Pointers site is a "must visit" resource for anyone interested in pattern matching.
Glimpse and Agrep, use a simplified regular expression syntax to achieve faster search times.
Udi Manber and Ricardo Baeza-Yates both have a selection of useful pattern matching papers available from their respective web sites.
Revised 24 Oct 2003
© Copyright John Maddock 1998- 2003
Use, modification and distribution are subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


{% extends "crumbless.html" %} {% load hawc %} {% block content %}
| Can Create Assessments | {{user.can_create_assessments}} |
|---|---|
| HERO website | {% if object.HERO_access %}
https://heronet.epa.gov (authentication required)
{% else %}
https://hero.epa.gov (no authentication required)
{% endif %}
Website used to redirect HERO links. |
| API token |
{{token.key}}
Token is only valid during the current login session. |


Leviticus 11:7
And the swine, though he divide the hoof, and be cloven-footed, yet he cheweth not the cud; he is unclean to you.


Hey there! Welcome to RateMemoji. Please reply to this e-mail and attach both your Memoji and a picture of your face. Make sure to keep the line below: id: {{token}}


Jinia:
The Divine Sword was a symbol of loyalty in the old kingdom of Elmoreden. The leader of the Knights of Kanna, Kier, wielded it when he guarded Felicia and the rest of the royal court.
"Kier was turned to ice, though..."


(Last Update 1st May 2012)
Hello everyonehttp://forums.steampowered.com/forums/showthread.php?t=2646371
I'm here to bring you an application for Battlefield 3 that you'll find very interesting (hopefully).
Battlefield 3 Customization Editor is a program which allows you to edit your loadouts while not being in-game.

Download Link:
http://www.mediafire.com/?y8d9e13yw8rxeyd
NOTE
:
before proceeding to use it I recommend to create a back up copy of your settings file (My Douments\Battlefield 3\settings\)
You may also disable Origin Cloud. If you get a message from Origin Cloud while you're trying to launch Battlefield 3 you should select the Local file, otherwise every change will be undone.
Any feedback/question is appreciate.
Thanks for your attention. :)
//Changelog
+ The program should now check if player owns or not the unlocks
+ Added a checkbox which allow the user to select all the unlocks (owned or not)
+ Added the possibility to change all the classes Gadget One (currently not checked if owned)
+ Added the possibility to change all the classes Gadget Two (currently not checked if owned)
+ Added the possibility to change all the classes Specialization (currently not checked if owned)
+ Added the possibility to change all the classes Appearance (currently not checked if owned)
+ Added the possibility to change all the classes Primary Weapon (currently not checked if owned)
+ Added the possibility to change all the classes Secondary Weapon (currently not checked if owned)
+ Now you can save your favorite loadout and load it whenever you want
+ Added some program settings (to change them go on the "Settings" tab)
* Changed the icon (maybe a better one is needed)
* Fixed the FAMAS


| No.1 |
Hark! The Herald Angels Sing |
Length - 3:13 |
| No.2 |
White Winter Hymnal |
Length - 2:47 |
| No.3 |
Sleigh Ride |
Length - 2:17 |
| No.4 |
Winter Wonderland / Don't Worry Be Happy |
Length - 3:28 |
| No.5 |
That's Christmas to Me |
Length - 3:02 |
| No.6 |
Mary, Did You Know? |
Length - 3:323 |
| No.7 |
Dance of the Sugar Plum Fairy |
Length - 2:07 |
| No.8 |
It's the Most Wonderful Time of the year |
Length - 3:05 |
| No.9 |
Silent Night |
Length - 2:42 |
| No.10 |
Dance of the Sugar Plum Fairy |
Length - 3:13 |
| No.11 |
Let It Go (Bonus Track) |
Length - 3:27
|


In short, when you go through life, you feel like every singel moment is important. Any mistake will destroy the world.
However, when you are met with an incredible and uncromprehendable force.  It makes you feel small, but at the same time, in comfort.
In fact, that was the purpose I found in going to church every Sunday. It related people with an unstoppable force that made them feel small, but at the same time, comforted. They looked at the big picture and what was really important.
Society might not like us to think that way, but we are really just a tiny dot upon another tiny dot. So it's ok to make a few mistakes.


--- layout: post title: Immigration and the Railroads date: '2010-01-13 22:53:15 -0700' mt_id: 1427 blog_id: 1 post_id: 1427 basename: immigration-and-the-railroads categories: - essays ---
The last half of the nineteenth century experienced a level of immigration unprecedented in American history. America at the time was a land of opportunities for everyone, immigrants included. Per capita gross national product rose at an average annual rate of 2%. Real gross national product grew at an annual average rate of 4%.1 To illustrate the dramatic increase, historian Robert Higgs compared America's progress to other advanced industrial nations: "In 1870, after several decades of industrial growth, the United States had a manufacturing output equal to that of France and Germany combined, but only about three fourths as large as that of the United Kingdom; by 1913 the American manufacturing output equaled that of France, Germany, and the United Kingdom combined!"2 A total of more than 28 million immigrants made the trip to America between 1865 and 1915 in order to participate in this economic prosperity.3
Much of this fantastic growth came about because of the railroads. This half century saw the rise of four transcontinental railroads where none had existed previously.4 Total mileage expanded from 52,922 in 1870 to 166,703 in 1890.5 Passenger and freight traffic reached ever-climbing heights: 7.7 billion passenger miles in 1882 and 12.5 billion passenger miles by 1890; 39.3 billion and 79.2 billion ton-miles in 1882 and 1890, respectively.6 These numbers indicate a significant infusion of the railroads into American life. They also hint at the transformation of American life by the railroads. With the huge increase in passenger and freight traffic, the country got smaller—people could travel readily and goods could be shipped over great distances. The railroads' growth also presented a serious problem for the railroads: their tracks stretched across vast expanses of unsettled country, an area that generated no traffic.
To that end, the railroads expended tremendous energy in an attempt to settle the lands adjacent to their tracks. Most of the transcontinentals enjoyed significant land holdings granted to them by the federal government. The smaller railroads, both regional and local, also received land grants from the states. In addition to all this government-granted land, this was also an era of government sales of land to private citizens. The railroads attempted to facilitate settlement of all of these types of land grants. Previous settlers had to travel to these lands by ox and cart. Settlers of this period could count on railroad transportation to get them to this cheap land. The frontier of America was drawn closer for the immigrants by the railroads, thus attracting a more diverse group of settlers who had a greater chance of successfully arriving than the previous settlers.
This, then, is the background in which we find ourselves. It is my contention that the railroads contributed to the increased immigration of the time both through the direct actions of the roads' immigration bureaus as well as the indirect benefits of cheap land and transportation. This essay will examine the efforts of two transcontinental railroads, the Northern Pacific and the Great Northern, to attract and settle both immigrants and migrants in the American Northwest during the last three decades of the nineteenth century. We will primarily examine immigrants of German and Scandinavian descent, since those are the two dominant groups that came to that region. This essay will also integrate the views and perspectives of some important immigration historians with the subject of immigration and the railroads. There are some underlying problems with this subject. First, there has been very little written on this topic. There have been plenty of brief mentions in books on the railroads, but nothing done in a systematic fashion—examining railroad records, Census data, and other contemporary sources—and nothing written since 1956. Second, this is a huge subject. The scope of this topic could easily be expanded by including more railroads, more immigrant groups, and more regions. This essay will not provide that systematic examination of the issue, but it will compile the available information into a summary presentation about one particular railroad in one particular region.
The Northern Pacific, which was chartered in 1864 to build a line from Lake Superior to the Puget Sound (completing it in 1883), received a very generous land grant from Congress in order to complete its mission.7 It was given every other section within twenty miles of its tracks in states and within forty miles of its tracks in the territories. With the addition of an indemnity limit of ten additional miles on each side to account for already-granted or state lands, this meant that the Northern Pacific owned substantial land holdings in a strip of land that varied from sixty to one hundred miles wide across the northern part of the country.8 It was with this land that the Northern Pacific hoped to attract settlers from around the world, since its officers knew that, as historian Mark Wyman put it, "on land rested status; from land came dignity."9
Although the Northern Pacific did not take possession of its government-granted lands until 1872, plans were well underway by 1871.10 A Land Committee was formed with the Northern Pacific's future president, Frederick Billings, as its chairman. The Land Committee then selected as Land Commissioner (head of the Land Department) John S. Loomis, who was then president of another land development company. The Land Department was headquartered in New York—in the headquarters of the Northern Pacific—and St. Paul, and it had district offices throughout the land it would eventually help to populate. In February of 1871, Loomis drew up a plan for the operations of the Land Department at the behest of the Land Committee.11
The Land Department as envisioned by Loomis chiefly promulgated publicity. They developed maps and materials about the Northern Pacific (NP) in many different languages for distribution throughout the world by NP agents and United States consulates. The department also sought to cultivate relationships with the domestic and foreign press in an effort to develop outlets for distributing friendly publicity (or at least keep out negative publicity). It fostered good relations with professional, religious, and fraternal organizations in both America and Europe to enlist the support of those organizations' leaders in promoting the settlement of the northwestern United States.12 Through these means, it sought to establish a continuous flow of immigrants and migrants across its territory. Shortly after the establishment of the Land Department, the Northern Pacific set up an Immigration Department. It had as its head Major George B. Hibbard, a colorful figure of tireless energy, and its European headquarters in London, with branches in Liverpool, Germany, Holland, and the Scandinavian countries.13
Foreign promotion skyrocketed after Henry Villard took control of the Northern Pacific in 1881. In addition to the branch offices, there were hundreds of NP agents throughout Europe. By 1882. there were 83 local agents throughout Great Britain disseminating NP pamphlets and marketing materials. That number had risen to 831 by 1883! There were an additional 124 agents spread throughout Norway, Sweden, Denmark, Holland, Switzerland, and Germany.14 These foreign NP agents acted in much the same manner as the steamship agents mentioned by Mark Wyman in his book Round-Trip to America. As with the steamship company agents he cites, the Northern Pacific's men used their personal and professional contacts to encourage immigration. They answered their countrymen's anxious questions, distributed literature, and arranged transportation for the long journey abroad.
Because the journey was so long and complicated, these agents worked closely with the steamship companies. Competition among the railroads was intense and local agents were not above "redirecting" immigrant parties to other railroads.15 By maintaining friendly relations with the steamship companies, the Northern Pacific could insure that the immigrant families, once put on the right ship, would be directed to the NP agent at the end of the journey. The steamship companies, for their part, wanted to remain cordial because they sought to avoid the Northern Pacific from aligning itself too closely with rival lines. The Cunard lines, for example, offered to distribute NP literature through its agents in exchange for its non-alignment.16 Occasionally, the Northern Pacific used steamship company agents as its own local agents. The Immigration Bureau used the National Steamship Company's agent in Norway and the Allan Company's agents in Sweden and Denmark.17 There were no conflicts of interest because all parties wanted immigrants to cross the Atlantic—the Northern Pacific could not transport them over the water and the steamship companies could not transport them over land.
The railway's foreign agents were very active in organizing immigration colonies. A Scandinavian minister by the name of Tustin traveled throughout Scandinavia in 1872 for the Northern Pacific. He persuaded ministers in the Church of Sweden and the Swedish Baptists to lead groups of immigrants to Minnesota as well as several other clergymen in Norway and Denmark to do the same.18 The Northern Pacific in 1872 selected as its agent for Hereford, England the organizer of a farm labor movement which resulted rapidly in almost a hundred new immigrants.19 Another important NP agent around this time was Colonel Hans Mattson, who had written a book in Swedish about Minnesota's opportunities. In 1873, he acted as the NP agent in Norway and Sweden—a great coup for the Northern Pacific, given his knowledge of the area and his patent boosterism—until he led a party of 200 from Sweden bound for Minnesota.20 O.J. Johnson, agent for Norway and Sweden, in 1880 distributed over 40,000 pamphlets about North Dakota's wonders and circulars numbering in the hundreds of thousands, before leading a group of over three hundred Scandinavians to North Dakota.21
Interregional migration was important to the Northern Pacific as well. It focused efforts towards attracting veterans of the Civil War. Major Hibbard, himself a veteran, traveled across New England promoting the NP's colonization agenda to Grand Army of the Republic (GAR) posts. His efforts paid off. In addition to increased veteran migration, Congress in 1872 passed legislation increasing the amount of government land within the railroad grant that a Civil War veteran could purchase from 80 to 160 acres and counting the veteran's service time towards the five-year residency requirement, a move encouraged by Hibbard through the circulation of a petition among every GAR post in the country.22 Hibbard also organized the New England Military and Naval Bureau of Migration in Boston. That organization advertised in thirty different journals and circulated five thousand copies of the Homestead Journal, its publication. These efforts were not unique to the Northern Pacific, since the veterans represented an ideal demographic for colonization efforts, but none were as active as the NP.23
Another means by which the railroad promoted settlement was the rewarding of third parties for their efforts towards the same end. The Land Commissioner in 1881 suggested that the Northern Pacific could greatly supplement it efforts by paying commissions to anyone who would help sell company land. The company agreed and authorized the payment of a 5% commission on sales up to 160 acres with the condition that the purchaser had to settle on the land and farm twenty acres each year for two years—a provision added to discourage speculation, a rampant problem for the railroads. In 1883, commissions were liberalized somewhat so that they were paid on purchases up to 640 acres.24 These commissions enlisted thousands of private citizens towards the cause of settlement of NP lands through the use of the profit motive as an incentive and it paid off.
In order to encourage the immigrants and migrants to use its trains and to purchase lands adjacent to its tracks, the Northern Pacific enacted special fares and promotions. It sold exploration tickets at full fare, but credited the price of the fare towards the purchase price of land bought from the company within sixty days at up to forty acres. Once they purchased the land, the Northern Pacific provided free transportation for them, their families, and their belongings. Finally, parties of five or more received reduced fares when traveling to purchase company or government land.25 The Northern Pacific also extended special accommodations to land purchasers. Settlers could purchase land on credit, paying an additional 7% in interest annually over a period of seven years. Or, settlers could improve on the land before it was available for sale and purchase it at the original price once it became available.26
The Northern Pacific also built facilities to house the settlers while they surveyed available land. In Minnesota, these houses were equipped to comfortably shelter several hundred people. They offered health care through a company hospital, foodstuffs at cost, and beds for free.27 In Spokane Falls, Washington, the town built a large house along similar lines with company help and instructed the citizens to brush up on facts about the area in order to further town development.28
The other northern transcontinental railroad, the Great Northern Railway, was built north of the Northern Pacific, sandwiched between the latter's tracks and the Canadian border. Its path was started in 1878 in St. Paul, Minnesota and finished in 1893 in Seattle, Washington.29 The principal architect of the Great Northern was its president, James J. Hill. Hill recognized the need for a railroad in that part of Minnesota while he was owner of a steamboat company: "More than anything else … it was the growing stream of immigrants to the Red River country, which seemed to almost ready to back up all the way to the East Coast for want of adequate transportation to the valley, that caught Hill's imagination." Hill was prescient in his dreams, perceiving what "few others were aware of and none articulated: a railroad into the valley could save settlers not just a few months, but virtually an entire year."30
Unfortunately, the Great Northern Railway lacked the Northern Pacific's substantial land grants. Its predecessor company, the St. Paul & Pacific, had been given a state land grant of 2.46 million acres wholly within the state of Minnesota—relatively small when compared to the Northern Pacific's 47 million acres.31 Fortunately, the lands were in the very fertile Red River Valley and directly adjacent to the tracks. That meant that in its base state of operations—Minnesota—the company would be able to sell huge tracts of land and promote farming through cheap land prices, but in the rest of the territory it traversed—the Dakotas, Montana, Idaho, Washington, and Oregon—it would have to employ other means to encourage settlement and create traffic.
Hill and company were up to the task. It was certainly going to have to accomplish a momentous feat:
With only slight exaggeration, Northwest Magazine reported that the new transcontinental ran 1,500 miles through a wild country with only three "important" freight-producing centers—Kalispell, Bonners Ferry, and Spokane. A few branch lines in North Dakota were generating traffic, but the task of attracting settlers to much of that state and to Montana remained; Idaho was lightly populated, and except for the coastal areas, Washington was pretty much an open opportunity. If the GN were to prosper, millions of acres of land would have to be occupied and businesses of all kinds would have to be established.32
In 1882, the St. Paul, Minneapolis, and Manitoba (StPM&M)—the immediate predecessor to the Great Northern—published its first newsletter touting the advantages of the Northwest and distributed 100,000 copies in North America and northern Europe. He also enlisted an agent in Norway and Sweden, countries which dispatched immigrants by the tens of thousands.33 At the turn of the century, the Great Northern offered immigrants low transatlantic fares through special deals with the shipping lines and special fares so that they could bring their families and belongings—rates ranging from $22.50 to $50 to rent a part or all of a boxcar. Historians have estimated that over 250,000 people poured into North Dakota during the last decade of the nineteenth century.34 His and the Northern Pacific's efforts were so successful that the first North Dakota census in 1890 showed that 43% of the population were foreign-born!35
By 1894, the Great Northern had a little over one million acres of grant land to be sold. It began advertising the federal and state land adjoining its tracks, as well as some private lands owned by cattlemen and others.36 The Great Northern's General Immigration Agent Max Bass was very aggressive in marketing these lands: advertising in all manners of periodicals, talking up the prospects to farmers at fairs and exhibitions, and attending church meetings to drum up interest.This last effort was successful: he had settled almost 11,000 German Baptists in North Dakota by 1900.37 The Great Northern's successes in North Dakota were duplicated across the rest of its line.
Colonization by the Northern Pacific and Great Northern railroads have, as mentioned earlier, received scant attention by historians—at least relative to their importance in the development of the Northwest. The overall field of immigration history is, on the other hand, prodigious in scope and detail. In an effort to bridge some of the gap, let us look at the history of these two railroads influence on immigration from the perspective of these immigration historians by applying their questions and findings to the present subject. For each historian, I will briefly summarize his or her main line of argument and then integrate that with the information presented in this paper.
The first historian under consideration is Mark Wyman, whose 1993 book Round-Trip to America: The Immigrants Return to Europe, 1880-1930 has a direct bearing on our subject matter. In that book, Wyman argues that immigration to America was really a "two-way migration" in that millions of immigrants never intended to permanently stay in the United States. They came to America because of its heightened economic opportunities, and they left as soon as they had collected enough money to achieve whatever goals with which they set out. However, those that settled in northwestern America tended to remain for the long haul. They purchased land here, rather than working to purchase land in their homeland. Remigration from the Northwest probably amounted to little—data is not available—due to the nature of the economic opportunities in that region of America: farming is not rewarding in the short-term, which is the type of opportunity immigrants intent on returning to their countries sought.
Jose Moya's Cousins and Strangers: Spanish Immigrants in Buenos Aires, 1850-1930 also has some relevance to our subject. His 1998 book is a weighty examination of the chain migration from Spain to Buenos Aires, Argentina that took place during an eighty-year period, a migration which he contends was mightily influenced by global forces.38 The chain migration, he writes, "resembled more webs or unending branches than a chain."For Moya, this chain or web that influenced migration was paramount, becoming "autonomous" and "self-perpetuating."39 While there were certainly elements of chain migration occurring in the settlement of the Northwest, the immigration was much more pronounced. Rather than a stream of immigrants pouring into the Northwest on the recommendations of those already settled, significant chunks of foreign communities were persuaded to transport themselves en masse to the New World. Efforts by the railroads' immigration agents were far more important than missives sent to relatives back home—as far as is known today.
Rudolph Vecoli's influential 1964 article "The Contadini in Chicago: A Critique of The Uprooted looked at Italian immigrants in Chicago during the late nineteenth century. On the face of it, a study of Italians in Chicago seems to have nothing in common with a study of Scandinavians in the rural Northwest. However, the contadini were agricultural peasants in Italy and the Scandinavian immigrants tended to be of that makeup as well. His central argument is that "the contadini of the Mezzogiorno … came to terms with life in Chicago within the framework of their traditional pattern of thought and behavior."40 The Scandinavian settlers tended to cluster with their fellow countrymen. It is unclear whether they faced the same external impetuses to assimilate as did the contadini, but their clustering did engender retention of traditional elements of their culture, such as language and dress.
Russell Kazal's 1995 review of the evolving definition of assimilation illustrates another area that merits future attention by scholars. In "Revisiting Assimilation: The Rise, Fall, and Reappraisal of a Concept in American Ethnic History," Kazal opines that it is "most useful to define assimilation in the immigrant context as referring to processes that generate homogeneity beyond the ethnic-group level."41 This is an intriguing notion since, as mentioned previously, new immigrants tended to cluster in ethnic enclaves with those of similar stock. Unfortunately, it was well beyond the scope this inquiry to examine the history of relations among the peoples of this region. Given the remoteness and wide dispersion of the region's inhabitants, a study of the interaction between the different groups as well as with society-at-large would be difficult yet extremely interesting.
Another work with similar applicability that suffers from unavailable data is James Gregory's American Exodus: The Dust Bowl Migration and Okie Culture in California. The Okies migrated to California from Oklahoma because of the latter's dwindling economic opportunities. Once there, the Okies faced discrimination and economic hardship from the native Californians. Many of the native-born American migrants moved to the Northwest for its abundant land and agricultural opportunities. It is doubtful that they experienced much, if any, discrimination, though, because of the prevalent boosterism of the times. Incoming migrants and immigrants were welcomed by the innumerable towns of the interior since they represented progress and prosperity.
Ewa Morawska's article "In Defense of the Assimilation Model" issues a call for the historicization of the assimilation model—moving away from the universal model of assimilation to one that separates assimilation by time and place. She argues that the classical assimilation model espoused by Milton Gordon should be recast into three stages: "integration into primary social relations with the dominant group … ; the disappearance of a collective (group) identity; and finally, concluding the process, the extinction of individual or subjective ethnic identification."42 Her staging schema certainly provides an interesting renovation of the assimilation model and I would second her urging of scholars to periodicize this new model—noting that this period and this region would make an excellent starting point.
There have also been a number of studies on the subject of the children of immigrants. Herbert Gans works on second-generation decline and symbolic ethnicity, Alejandro Portes and Miz Zhou's article on segmented assimilation and the second generation, and Junot Díaz's novel about his experiences as a second-generation Dominican immigrant all are important works in immigration history. Unfortunately, they deal almost exclusively with the second generation of immigrants—a subject beyond the purview of this summary presentation. They raise interesting considerations for those who would study the progeny of immigrants that settled the Northwest.
As noted in earlier comments, this time and place in American history bears further scrutiny. Efforts have been made to understand the region's history of immigration, but they are incomplete in many areas. The railroad, though largely outdated as a means of transportation and hidden in the shadows of America's economy, still offers many lessons about America's past, present, and future. It is a shame that it goes unexplored while historians turn their attention to minutiae and trivia.
1 This meant a threefold increase in per capita GNP between the Civil War and World War I and an eightfold increase in real GNP. Robert Higgs, The Transformation of the American Economy, 1865-1914: An Essay in Interpretation, Wiley Series in American Economic History (New York: John Wiley and Sons, 1971), 19.
2 Ibid., 48.
3 Ibid., 24.
4 Richard B. Morris, The Encyclopedia of American History, (New York: Harper & Row, 1976), 611-2.
5 Alfred D. Chandler Jr., The Railroads: The Nation's First Big Business, The Forces in American Economic Growth Series (New York: Harcourt, Brace & World, 1965), 13.
6 Ibid., 14. By 1890, railroads carried twice as much freight as all other means of transportation combined. Mansel G. Blackford and K. Austin Kerr, Business Enterprise in American History, (Boston: Houghton Mifflin, 1986), 162.
7 James B. Hedges, "The Colonization Work of the Northern Pacific Railroad," The Mississippi Valley Historical Review 13:3 (December, 1926), 313. Morris, 612.
8 Hedges, "Colonization," 313.
9 Mark Wyman, Round-Trip to America: The Immigrants Return to Europe, 1880-1930, (Ithaca, NY: Cornell University Press, 1993), 129.
10 Robert L. Frey, "Jay Cooke," in Railroads in the Nineteenth Century, Encyclopedia of American Business History and Biography, Robert L. Frey, ed., (New York: Bruccoli Clark Layman, Facts on File, 1988), 62.
11 Hedges, "Colonization," 314.
12 Ibid., 315.
13 Ibid., 315.
14 Ibid., 330.
15 Ibid., 318.
16 Ibid., 318.
17 Ibid., 319.
18 Ibid., 316.
19 Ibid., 317-8.
20 Ibid., 317, 323.
21 Ibid., 338.
22 Ibid., 319.
23 Ibid., 320.
24 Ibid., 332.
25 Ibid., 320-1.
26 Ibid., 321.
27 Ibid., 320.
28 James B. Hedges, "Promotion of Immigration to the Pacific Northwest by the Railroads," The Mississippi Valley Historical Review 15:2 (September 1928), 200.
29 Don L. Hofsommer, "Great Northern Railway," in Railroads in the Nineteenth Century, Encyclopedia of American Business History and Biography, Robert L. Frey, ed., (New York: Bruccoli Clark Layman, Facts on File, 1988), 152.
30 Albro Martin, James J. Hill and the Opening of the Northwest, (New York: Oxford University Press, 1976), 116.
31 Ralph W. Hidy and others, The Great Northern Railway: A History, (Boston: Harvard Business School Press, 1988), 3. Michael P. Malone, James J. Hill: Empire Builder of the Northwest, (Norman, OK: University of Oklahoma Press, 1996), 35.
32 Hidy, 99.
33 Malone, 91.
34 Ibid. 261.
35 Ibid. 113.
36 Hidy, 100.
37 Ibid., 101.
38 Jose C. Moya, Cousins and Strangers: Spanish Immigrants in Buenos Aires, 1850-1930, (Berkeley, CA: University of California Press, 1996), 13-43.
39 Ibid., 392.
40 Rudolph J. Vecoli, "Contadini in Chicago: A Critique of The Uprooted," Journal of American History 51 (December 1964), 417.
41 Russell A. Kazal, "Revisiting Assimilation: The Rise, Fall, and Reappraisal of a Concept in American Ethnic History," American Historical Review 100 (April 1995), 439. Emphasis in original.
42 Ewa Morawska, "In Defense of the Assimilation Model," Journal of American Ethnic History 13:2 (Winter 1994), 76+.


I am a Computer Science major with a minor in Animation. My aim is to combine my creative side with my love of coding and various forms of technology.
About meI have always been a very creative person with a passion for creating in general, whether it be drawing, videos, websites, etc. My mindset, however, has always better attuned to math and technology rather than drawing and more traditional art forms. I have learned that I can utilize my computer skills to execute my own creative visions. What I lack in dexterity of the pencil I can make up for by learning how to get the technology to do it for me. Because of this, I have come to love coding and animation, in which I can take my creative side and apply it to the code and various technical programs within the Animation Industry.
My more visual and creative side has also led to a passion for UX/UI design, as I have a great appreciation for the research and thought required to make an appealing and easy to use website. My time as a UX intern helped to further solidify my interest in the field as I enjoyed the process of research to preliminary design all the way through coding the final product.
I am also a member of the Division I Loyola Marymount University Women's Water Polo Team. My time as a student athlete has taught me valuable lessons in time management, discipline, and working well with others under times of great stress.
SkillsProficient with Java, JavaScript, Python, HTML (Bootstrap), and CSS
Familiar with C++, C, Haskell, Ohm, and Typescript
Proficient in Axure
Performed UX research and designs, familiar with the UX design process
Proficient in Harmony, Adobe Premiere, and Adobe After Effects
Familiar with Adobe Photoshop, Adobe Bridge, and StoryboardPro
Familiar with Animating, Scripting, and Modeling in Maya
I am available by phone or email. I am most responsive between the hours of 8am-12pm and after 4pm.


Ever since the accident Mrs. Emoji have had a hard time going to public places and having their inner critics get the best of them. They feared they were being ridiculed in public and laughed at because of what they looked like. With much help from friends and family they are now learning to enjoy being who they are in public. They are just now starting to eat out at restaurants, grocery stores, and going on hikes which has been much like an adventure to them.
At home they just can't enough of who they are so, they buy little things that reminds them of who they are; great happy normal people. The picture below is how they do dishes.


Running Jekyll with Latent Semantic Indexing (or LSI) on a site of only 20-30 pages can take 5-10 minutes on a reasonably powerful Mac. I got tired of having to wait or isolate individual posts to get on with writing, so I took Jekyll’s recommendation and installed the GNU Scientific Library (or GSL).
After properly installing GSL on my MacBook Pro, building my site went from over 5 minutes for a site with about 100 posts, to under 5 seconds.
Install GSL via homebrew:
$ brew install gsl
If you don’t already have a Gemfile
for your Jekyll site, create one that looks similar to this:
source 'https://rubygems.org'
gem 'jekyll'
gem 'gsl'
Note: If you already have a Gemfile, the important lines are
narray
andgsl
. Be sure to include the git repository links, as these contain my fixes to compile on OS X 10.9 “Mavericks”.
Now use Bundler to install the dependencies on your Mac:
$ cd {YOUR SITE'S FOLDER}
$ bundle install
Note: It’s probably worth while looking into a tool like RVM, rbenv or similar that will let you create gemsets so that you don’t pollute the system rubygems unnecessarily.
Now start up Jekyll and activate LSI (add --watch
if you want to rebuild on any change to your content):
$ jekyll serve --lsi
Make yourself a coffee with all the extra time you’re going to save not sitting around waiting for the LSI indexer to finish!
Et voilà! Super speedy site rebuilds with more intelligent related posts for each page.


{% include prism.html %}
Bombs
menu
Home
Download
API Example
Spigot
Bombs
Home
Download
API Example
Spigot
{{ page.title }}
{{ content }}
we're on github


Use this workflow to build customized Bootstrap distributions (including CSS, js, etc...)
mock folder
(e.g. pantherCartridge
) under the dist
folderbootstrap\less\variables.less
files
@brand-primary
or the likebower_components
foldergunt dist
at the command line (@see a probable output below)
c:\Users\marco.silva\git\mockupSandbox\bower_components\bootstrap>grunt dist Running "clean:dist" (clean) task >> 1 path cleaned. Running "less:compileCore" (less) task File dist/css/bootstrap.css.map created. File dist/css/bootstrap.css created Running "less:compileTheme" (less) task File dist/css/bootstrap-theme.css.map created. File dist/css/bootstrap-theme.css created Running "autoprefixer:core" (autoprefixer) task File dist/css/bootstrap.css created. File dist/css/bootstrap.css.map created (source map). Running "autoprefixer:theme" (autoprefixer) task File dist/css/bootstrap-theme.css created. File dist/css/bootstrap-theme.css.map created (source map). Running "usebanner:files" (usebanner) task ? grunt-banner completed successfully Running "csscomb:dist" (csscomb) task >> Using custom config file "less/.csscomb.json"... >> Sorting file "dist/css/bootstrap-theme.css"... >> Sorting file "dist/css/bootstrap.css"... Running "cssmin:minifyCore" (cssmin) task Running "cssmin:minifyTheme" (cssmin) task Running "copy:fonts" (copy) task Copied 5 files Running "concat:bootstrap" (concat) task File dist/js/bootstrap.js created. Running "uglify:core" (uglify) task >> 1 file created. Running "commonjs" task File dist/js/npm.js created. Done, without errors. Execution Time (2015-02-22 13:08:34 UTC) less:compileCore 765ms ███████████████████ 23% less:compileTheme 94ms ███ 3% autoprefixer:core 490ms ████████████ 15% autoprefixer:theme 59ms ██ 2% csscomb:dist 1.4s ███████████████████████████████████ 42% cssmin:minifyCore 93ms ███ 3% uglify:core 363ms █████████ 11% Total 3.4s
css
, fonts
, js
folders to your own mock folder
img folder
json folder
for mimicking JSON outputs


|
Shader Tool
Small shader visualiser.
|
Controls the application Front-end. More...
#include <UIController.hpp>
Public Member Functions | |
| UIController (shared_ptr< st::DocumentManager > dm, shared_ptr< st::ConfigurationManager > cm) | |
| Creates the controller and creates the UIBuilder. More... | |
| void | run () |
| Starts the drawing of nanogui and enters it's main loop. More... | |
Public Attributes | |
| Canvas * | canvas |
| nanogui::TextBox * | save_shader_name |
| nanogui::TextBox * | open_shader_name |
| nanogui::TextBox * | texture_path |
Private Member Functions | |
| void | previewButton () |
| Preview button functionality. More... | |
| void | editButton () |
| Edit button functionality. More... | |
| void | saveButton () |
| Save button functionality. More... | |
| void | openButton () |
| Open shader functionality. More... | |
| void | openTexButton () |
| Open texture functionality. More... | |
| void | loadTexture (string path) |
| Loads and sets the texture from the provided path. More... | |
Private Attributes | |
| nanogui::Screen * | screen |
| shared_ptr< st::DocumentManager > | doc_manager |
| shared_ptr< st::ConfigurationManager > | conf_manager |
Controls the application Front-end.
| st::UIController::UIController | ( | shared_ptr< st::DocumentManager > | dm, |
| shared_ptr< st::ConfigurationManager > | cm | ||
| ) |
Creates the controller and creates the UIBuilder.
| dm | DocumentManager used in the application. |
| cm | CunfigurationManager |
|
private |
Edit button functionality.
Opens the current file with the configured text editor.
|
private |
Loads and sets the texture from the provided path.
|
private |
Open shader functionality.
Opens a new shader from the configured template.
|
private |
Open texture functionality.
Loads a new texture from the configured path.
|
private |
Preview button functionality.
Reads the shader from the file and sets it in the canvas.
| void st::UIController::run | ( | ) |
Starts the drawing of nanogui and enters it's main loop.
|
private |
Save button functionality.
Saves the current shader with another name. By not using this, if you are editing the default "newShader" will be overwritten the next time the program is ran.
| Canvas* st::UIController::canvas |
|
private |
|
private |
| nanogui::TextBox* st::UIController::open_shader_name |
| nanogui::TextBox* st::UIController::save_shader_name |
|
private |
| nanogui::TextBox* st::UIController::texture_path |