--- tags: - data - overview - planning author: display_name: ugrc email<EMAIL_ADDRESS>date: 2011-10-21 15:15:11 -0600 title: Planning Data Resources categories: [] ---
The list shown below includes dataset names, descriptions, and links to some of the most important statewide and regional data resources for transportation planning, land use planning, and economic development. It also includes some datasets that represent the geography of notable formal plans and proposals.
The list is meant as a starting point and users are encouraged to reach out to agencies, local government, and further search across UGRC's State Geographic Information Database for additional existing data. The overall objective of keeping this list is to connect others to valuable resources efficiently and avoid duplicative work.
If you have ideas for additions to this list, {% include contact.html subject="Planning Data Page Additions" contact=site.data.contacts.sgid text="please contact " hide-punctuation=true %}, or {% include contact.html subject="Planning Data Page Additions" text=" " contact=site.data.contacts.wfrc %}
| Subcategory | Product Name | Type | Steward(s) | Description |
|---|---|---|---|---|
| click a product name for more information and/or download links | ||||
| Accessibility | Workplace Accessibility | map data | WFRC | Workplace Access to Opportunities (ATO) metrics for typical peak period auto and transit commutes, at the Traffic Analysis Zone (TAZ) level. Includes measures for household (access to jobs) and employer (access to workers/customers) perspectives. These datasets use a 'distance decay' travel cost weighting based on typical Wasatch Front commuting and are designed to take the place of "jobs within x minutes" datasets. This extent of this dataset currently is the Wasatch Front urban area although this will soon be expanded statewide. More info on ATO |
| Accessibility | Household and Employment Intensity | map data | WFRC | A quick summary of residential and employment intensity within ~1/4 mile for city-block-sized polygons in the Wasatch Front urban areas. This roughly represents commuter trip producing and attracting areas. More info on ATO |
| Active Transportation | On-Street Bike Facilities | map data | UGRC, WFRC, MAG | Existing and planned bicycle infrastructure on/near roadways (bike lanes, cycle tracks, bike boulevards etc.), is coded on the road centerline dataset using Bike_L(eft), Bike_R(ight), Bike_Plan_L, Bike_Pln_R attributes. The Bike_RegPr field is used to distinguish regional bike facilities from more locally oriented facilities. This dataset is populated based on local data and local plans compiled by WFRC & MAG, and 2019 aerial photography review by UDOT Traffic and Safety. See Trails and Pathways for non-road bike/ped facilities. |
| Active Transportation | Trails and Pathways (Bike/Ped/Hike) | map data | UGRC | Existing and planned trails and pathways (off-street), statewide. The Status field differentiates planned from existing and Carto_Code and Class differentiate different types of trails and pathways. See On-Street Bike Facilities for bike lanes, cycle tracks, etc. |
| Active Transportation | Road and Highway System | map data | UGRC, WFRC, MAG | Existing and planned bicycle infrastructure on/near roadways is coded on the road centerline dataset using Bike_L(eft), Bike_R(ight), Bike_Plan_L, Bike_Pln_R attributes. The Bike_RegPr field is used to distinguish regional bike facilities from more locally oriented facilities. This dataset is populated based on local data and local plans compiled by WFRC & MAG, and 2019 aerial photography review by UDOT Traffic and Safety. |
| Aerial Photography | Current High Res Aerial Photography | map data services | UGRC | The most current high resolution aerial photography for Utah is made available to GIS users (desktop and webapps) from UGRC's Discover server. This commercially-licensed imagery is available at no charge to state and local government (including tribes, k-12, and colleges), and their contractors and formal partners, for download and as high-performance web services. |
| Aerial Photography | Archival Aerial Photography | map data | UGRC & UGS | This link opens the UGRC aerial photography page with information on accessing older aerial photography including 1990's era DOQ's and older scanned aerial imagery |
| Base Maps | Base Maps | map data services | UGRC | UGRC's Discover server provides high-performance base maps -- built exclusively from GIS data in the State Geographic Information Database -- from its Discover server. Base map themes include terrain, lite, topographic, address points, and overlay. These are open to public use,, but require a free Discover account. |
| Boundaries | City, County and State Boundaries | map data | UGRC | Utah city (municipal), county, and state boundaries |
| Cadastral (Land Ownership) | Parcels | map data | UGRC | Parcel boundaries and characteristics from Utah's County Recorders ("Basic" parcels) and County Assessors ("LIR" tax parcels -- includes valuation, property types, tax exemption, and improvement characteristics) |
| Demographic (Socioeconomic) | Population and Employment Projections (TAZ-level) | map data | WFRC, MAG, Cache MPO, Dixie MPO, UDOT | Forecasted population, household, and job counts, annually from 2019-2050, at the Traffic Analysis Zone (TAZ) and 'City Area' levels. These dataset was developed for the purpose of transportation modeling and conforms with the county-level population projections developed by GPI for the Utah Population Committee. Utah has 9855 TAZ's statewide, 3547 of which are within the Wasatch Front urban modeling area. 'City Areas' are combinations of TAZ that approximate current city boundaries |
| Demographic | Equity Focus Areas (WFRC Area) | map data | WFRC | WFRC has adopted an Equity Focus Area (EFA) framework as an input to its transportation planning efforts. EFAs are census block groups where either of the following criteria (last updated in 2023) are met: > 20% low income or > 40% Persons of Color |
| Destinations | Community Centers | map data | WFRC | Recreation centers, libraries, and other community recreation facilities along the Wasatch Front |
| Destinations | Community Services | map data | WFRC/UDAF | Community services along the Wasatch Front including city halls, county offices, courthouses, food banks, human services, the state capitol, vehicle services, and workforce services. Locations were primarily derived from digitizing or geocoding office locations listed on various state and nonprofit websites (DMV, Utah Food Bank, DWS) |
| Destinations | Grocery Stores | map data | WFRC/UDAF | Grocery Stores and other food stores from the Utah Department of Agriculture and Food (UDAF) database (2018). Use the 'TYPE' field to filter by type of store. |
| Destinations | Child Care Facilities | map data | WFRC/HIFLD | Child care and preschool facilities from the US DHS HIFLD open data site. |
| Destinations | Healthcare Facilities | map data | UGRC, Utah Department of Health, Division of Emergency Management | Healthcare Facilities and Emergency Medical Service (EMS) locations in Utah |
| Destinations | Post Offices | map data | UGRC | Locations of Utah Post Offices according to an address list from the Salt Lake City USPS District Office. |
| Destinations | Retail Centers | map data | WFRC | Locations of shopping malls and retail centers along the Wasatch Front. |
| Destinations | Schools & Libraries | map data | UGRC | Locations and information for schools and libraries in Utah. |
| Environment | Conservation Easements | map data | UGRC | Conservation Easements in Utah. |
| Environment | Conservation Districts and Zones | map data | UGRC | Conservation Districts and Zones in Utah. |
| Environment | Primitive Areas | map data | UGRC | Only in Emery County. |
| Environment | Public Lands Initiative Proposal PLI Areas and Public Lands Initiative Proposal PLI Lines | map data | BLM | Features in these data were produced by the BLM for HR 5780 to designate federal lands as wilderness and components of the National Wilderness Preservation System in Utah. The Public Lands Initiative (PLI) is a locally-driven effort to bring resolution and certainty to some of the most challenging land disputes in Utah. |
| Environment | Urban Interface Areas | map data | UGRC | Locations of Wildland Urban Interfaces. |
| Environment | Wilderness, Proposals & Protected Areas | map data | USFS/BLM | Wilderness boundaries including BLM re-inventory and suitability, WSAs, roadless inventory and existing wilderness. |
| Environment | Wetlands | map data | USFWS | Wetland areas in Utah. |
| Health | Health Indicators | map data | Utah Dept of Health | Obesity and physical activity rates by small health statistical areas |
| Housing | Mobile Home Parks | map data | WFRC | Mobile Home parks in the Wasatch Front and Wasatch back areas (Davis, Morgan, Salt Lake, Summit, Tooele, Utah, Wasatch, Weber counties |
| Land Use | Cemeteries | map data | Utah State History | Cemetery locations in Utah. |
| Land Use | Generalized Future Land Use | map data | WFRC | A generalized interpretation (2020) of city and county general plans in the WFRC urban area. General plans present a community's aspirations for allowable future land use types and intensities. |
| Land Use | Golf Courses | map data | UGRC | Locations of Municipal, Private, Public and Resort Golf Courses. |
| Land Use | Housing Unit Inventory | map data | WFRC, MAG, UGRC | Characteristics of housing units on a per-parcel or per-development (for PUDs, townhomes, condos, etc) basis derived from LIR parcels and county assessor data. |
| Land Use | Local Parks | map data | UGRC | Locations of non state and non federal parks. |
| Land Use | Wasatch Choice Urban Centers | map data | WFRC/MAG | This dataset represents the regionally significant centers and other specialized land use from the Wasatch Choice 2050 Vision Map. Land use types in this dataset include four levels of centers (metropolitan, urban, city, neighborhood), employment districts, education districts, industrial districts, and special districts (airports, mining, military, etc.). |
| Transportation | Annual Average Daily Traffic (AADT), Historic & Forecasted | map data | WFRC, MAG, Cache MPO, Dixie MPO, UDOT | This statewide traffic volume GIS dataset contains observed (historic, from UDOT) and forecasted traffic volumes (from MPOs and UDOT) on highways and major roads. |
| Transportation | Annual Average Daily Traffic (AADT), Historic & Forecasted | webmap | WFRC, MAG, Cache MPO, Dixie MPO, UDOT | This statewide traffic volume viewer shows observed (historic, from UDOT) and forecasted traffic volumes (from MPOs and UDOT) on highways and major roads. The advanced tab allows for traffic volumes to be seen in the context of forecasted population, employment, and future regional transportation projects. |
| Transportation | Average Commute Times | map data | WFRC/MAG | Projected average auto and transit commute times (one way) for residents of Wasatch Front traffic analysis zones (TAZs) for 2019, 2030, 2040, & 2040 |
| Transportation | Functional Class (Roadways) | map data | UDOT | UDOT Functional Class definitions (interstate, other freeway/expressway, principal/minor arterial, major/minor collector, etc.) for existing and planned UDOT and federal aid eligible roads. This dataset can be viewed in this webmap. |
| Transportation | Major Transit Investment Corridors (per SB34) | map data | WFRC | This dataset identifies transit service routes that meet the definition within Senate Bill 34 (line 858), passed during the Utah Legislature's 2019 General Session |
| Transportation | Pathways, Trails, and Trailheads | map data | UGRC | Established trails and trailheads in Utah. |
| Transportation | Railroads | map data | UGRC | Statewide railroads data, including transit rail |
| Transportation | Road and Highway System | map data | UGRC | Statewide road and highway system data for cartography and address location. Includes local streets, mileposts, and numbered exit data. |
| Transportation | Street Connectivity | map data | WFRC | Street Connectivity analysis datasets for the Wasatch Front and Back counties. Data set options include intersection points, dead ends/culdesacs, and intersection density scores by 1 km hexagon and by traffic analysis zone (TAZ). These can be viewed in WFRC's Street Connectivity interactive map. |
| Transportation | Street Network Analysis | map data | UGRC | Network datasets designed for routing, service areas, drive times, and distance analysis. Includes statewide street network dataset and Wasatch Front multimodal network dataset. |
| Transportation | Transit Routes, Stations, and Stops | map data | UTA | Routes and stops for buses, light rail and commuter rail |
| Transportation | UDOT Business System Data | data portal | UDOT | Utah Department of Transportation geospatial data and services gateway website. Includes detailed data for projects, pavement management, planning, medians, barriers, signs,traffic volume, lanes, etc available in various formats |
| Transportation | Utah Transit Authority (UTA) Open Data Site | data portal | UTA | Utah Transit Authority (UTA) geospatial data and services gateway website. Includes stop/station, route, and mode-level boarding counts. |
| Transportation | Utah Transit Authority (UTA) Ridership Dashboard | dashboard | UTA | Utah Transit Authority (UTA) ridership dashboard, includes views of Commuter Rail, Light Rail, Streetcar, Regular Bus, Express Bus, Ski Bus, BRT Bus (UVX), Vanpool, and Paratransit modes |
| Water | Water Related Land Use | map data | DNR | Water usage-related polygon map data, published annually that depicts the types and extent of irrigated crops as well as information concerning phreatophytes, wet/open water areas, dry land agriculture and residential/industrial areas |


Start
Add funds
Raise
Manage
Welcome to Swapy Exchange!
We have plenty of investor looking for investment offers
Create a fundraising offer


--- layout: default lang: en pageId: loading-content title: Loading content (WIP) description: Using aria-busy to show some loading content. keywords: loading, content, aria-busy, examples section: misc ---
We strongly encourage to use the default version of the loader, but in smaller case, we need to embold circle strokes to make the animation more visible: .is-bold
for medium size, .is-xbold
for small size.
| Flag | Preview |
|---|---|
| Default, without flag | |
.is-bold |
|
.is-xbold |
Both versions may also exist in standalone images /assets/img/shared/loading-atom.svg
, and /assets/img/shared/loading-atom-smaller.svg
Be carefull when using these, dark mode is difficult to activate on them, better using inline versions!!!
Basically, the idea is to rely on attribute aria-busy="true"
.
div
button
Remember to add attribute disabled
when aria-busy="true"
is applied.
table > tr
/table > td
| id | Amount | Type | Status | Date | Action |
|---|---|---|---|---|---|
| 123456 | 24 € | Subscription | active default origin | 16 Mar. 2018 | |
| 123456 | 24 € | Subscription | disabled error | 16 Mar. 2018 |
progress
barDecrypting contacts: 0%
value
attribute of the progress bar and the text explaining the action in progress.aria-atomic="true" aria-live="polite"
on the container describing the current progress (helps to vocalize correctly the description).progress
tag to its description via aria-describedby
.aria-busy
in this case<progress
class="progressbar w100"
aria-describedby="description_progress">
</progress>
<p
aria-atomic="true" aria-live="polite"
id="description_progress">
Decrypting contacts: 0%
</p>
progress
modifiersprogressbar--success
/progressbar--error
/progressbar--warning
modifiers when needed on progress
tag.aria-describedby
.<progress
class="progressbar progressbar--success w100">
</progress>
…
<progress
class="progressbar progressbar--error w100">
</progress>
…
<progress
class="progressbar progressbar--warning w100">
</progress>


A small build automation tool that ships with your software.
Copyright © 2017 Raise Authors
Last updated on May 12th 2017
https://github.com/workhorsy/raise
Raise is licensed as freely as possible, in the hopes that it will be compatible with most other software licenses.
The Raise software is licensed under The MIT License .
The Raise documentation is license under The Creative Commons Attribution License v3.0 .
Copyright © 2012 - 2017 Matthew Brennan Jones<EMAIL_ADDRESS>Other authors please add your copyright and contact info here.
If you find any errors, bugs, or misinformation, please report a bug at https://github.com/workhorsy/raise or contact one of the authors.
Documentation is provided in the docs/index.html file. It is generated from the Python Mako Template file docs/templates/index.html.mako.
Warning! Because Raise uses scripts to generate the documentation, you won't be able to generate the documentation unless you have all the compilers and tools installed. Doing this also requires root, because it runs all the code examples to get the actual output from those code examples.
To generate the index.html file you can run:
python generate_documentation.py
Any changes should be added to the index.html.mako file, as it will wipe out any changes in index.html when generate_documentation.py is run.
The philosophy of Raise is that it says what it is doing. Not how it is doing it. It only shows the details when something goes wrong. That way the build output does not fill with information you don't need. It shows the output for each step of the build process, as its own line.
Raise should not be installed into your Operating System. It is designed to run from inside your project's directory.
Raise consists of a small shim script called "raise" and a directory of modules called ".lib_raise". The "raise" shim is safe to save into your VCS along with your source code. It is small (10kB) and should not change very often. All the ".lib_raise" modules are automatically downloaded by the "raise" shim. You should not check the ".lib_raise" directory into your VCS.
If you want to check the raise modules into your VCS (So your project will build without needing an Internet connection). You should rename the ".lib_raise" directory to "lib_raise". This is also a good idea to do before you release your source code as a compressed file.
The file hierarchy of Raise looks like this:
# Your script that builds your software rscript # The shim that gets everything ready raise # The modules that are automatically downloaded .lib_raise-+ |-cpuinfo.py |-findlib.py |-findlib_server.py |-lib_raise.py |-lib_raise_ar.py |-lib_raise_c.py |-lib_raise_config.py |-lib_raise_cpu.py |-lib_raise_csharp.py |-lib_raise_cxx.py |-lib_raise_d.py |-lib_raise_find.py |-lib_raise_fs.py |-lib_raise_helpers.py |-lib_raise_java.py |-lib_raise_linker.py |-lib_raise_process.py |-lib_raise_python.py |-lib_raise_terminal.py |-lib_raise_users.py `-osinfo.pyThere are eight basic OS types:
Fully supported.
Has been tested on FreeBSD, and PCBSD, but not on OpenBSD, NetBSD, or DragonflyBSD.
wget https://raw.githubusercontent.com/workhorsy/raise/master/raise
chmod +x raise
./raise
Bugs:
Fully Supported.
wget https://raw.githubusercontent.com/workhorsy/raise/master/raise
chmod +x raise
./raise
Partially supported.
Can build basic exes, shared/static libraries, but not install anything, or search for programs/libraries. Not yet tested on BeOS.
wget https://raw.githubusercontent.com/workhorsy/raise/master/raise
chmod +x raise
./raise
Fully supported.
Primarily developed on Linux with kernel 2.6 and greater. Tested primarily on Ubuntu, Debian, Linux Mint, Fedora, and Centos. It should "just work" on other Linux distros.
wget https://raw.githubusercontent.com/workhorsy/raise/master/raise
chmod +x raise
./raise
Not supported.
None of the mobile OSes are supported. They either do not support the required compilers, or are locked down too tightly to use. Hopefully this will change in the future.
Partially Supported
Can build basic exes, shared/static libraries, and find programs/libraries.
Bugs:
wget https://raw.githubusercontent.com/workhorsy/raise/master/raise
chmod +x raise
./raise
Fully supported.
Tested on Open Indiana, Open Solaris, and Open SXCE. Not yet tested on Oracle Solaris.
wget https://raw.githubusercontent.com/workhorsy/raise/master/raise
chmod +x raise
./raise
Partially supported.
Tested on Windows XP, Windows 7, and Windows 8. There are still issues with building and finding C/C++ libraries on Windows. It is recommended that Windows users use Cygwin.
Download from https://github.com/workhorsy/raise
python raise
Bugs:
Has not been tested on Windows Vista or Windows RT.
Source code can be checked out using the Git VCS.
git clone
cd raise/examples/c_simple
./raise test
C and C++ are fully supported with GCC, and Clang. MS cl.exe support is not yet complete.
D is fully supported with DMD, and LDC. GDC support is disabled, because the packages in debian/ubuntu are broken.
C# works with Mono and MS .NET. Some advanced features such as installing into the GAC have not been implemented.
Java works with OpenJDK 7.
Raise uses a specific format to show messages to the user. It prints what it is going to do. Then when it is done, it prints an emoticon for success, warning, or failure. By using this format, it should be easy for anyone to quickly tell if everything is okay or not.
For example this prints out "Building C++ program 'main.exe' ..." when it starts. Then prints a ":)" when it is successful.
Building C++ program 'main.exe' ... :)
:) - A green smile represents success. This is used when a command has a return code of zero, and has nothing printed to stderr.
:\ - A yellow half smile represents success with a warning. This is used when a command has a return code of zero, but has something printed to stderr.
:( - A red frown represents failure. This is used when a command has a return code that is not zero.
One of the huge issue in dealing with different platforms, is how they handle file extensions. Many have different extensions for the same type of file. For example Windows typically uses .exe for executable, and .obj for object. While Linux typically uses no extension for executable, and .o for object.
Raise gets around this by having its own list of file extensions and mapping them to the native type for that Operating System.
For example when building a C program you would say:
C.build_program('main.exe', ['main.c'])
On Windows it will create "main.exe", but on Linux it will create "main".
To see the mappings, look at the section for each language.
# Most of this section requires the modules:
import lib_raise_process as Process
The fundamental way that Raise works, is that it wraps function calls. It says that it is going to call a function, calls the function, then prints an emoticon for success or failure.
For example: Below the Process.do_on_fail_exit function will print "Running simple_function", call the function, then print a smiley on success. The function output will be printed below the smiley.
def simple_function():
print('blah')
Process.do_on_fail_exit(
"Running simple_function", "It failed", simple_function)
Running that code will produce this result:
Running simple_function ... :)
blah
If the function Process.do_on_fail_exit is called on a function that raises an error. The function will print "Running simple_function", call the function while catching the exception, print the frown, then print the failure message "It failed". The function output will be printed below the failure message.
def simple_function():
raise Exception('broken')
Process.do_on_fail_exit(
"Running simple_function", "It failed", simple_function)
Running that code will produce this result:
Running simple_function ........................................................:(
It failed Exiting ...
broken
If you do not want the script to exit when the function is_broken throws an exception, you can use the Process.do_on_fail_pass function. It will ignore any exceptions raised by the functions.
def is_broken():
raise Exception('broken')
def is_not_broken():
pass
Process.do_on_fail_pass("Running is_not_broken", is_not_broken)
Process.do_on_fail_pass("Running is_broken", is_broken)
Running that code will produce this result:
Running is_not_broken ... :) Running is_broken ... :)
If you want to run a command and have its result printed, you can use the Process.run_print convenience function. The command itself will be printed, then the result of the command.
Process.run_print("uptime")
Produces the result:
Running command ... :)
uptime
17:15:09 up 3:43, 4 users, load average: 0.12, 0.13, 0.14
If you want to run a command and get its standard output, you can use the Process.run_and_get_stdout convenience function.
result = Process.run_and_get_stdout("uptime")
print(result)
Produces the result:
17:15:09 up 3:43, 4 users, load average: 0.12, 0.13, 0.14
# Most of this section requires the modules:
import lib_raise_users as Users
If you want to ensure that a script is run as root. You can use the Users.require_root function. If the script is not run as root, it will print an error and exit.
Example:
def users_running_as_root():
# Print the user id
print('Effective user id: {0}'.format(os.getuid()))
# Will print an error and exit if the user is NOT root
Users.require_root()
Example output when run as root:
Effective user id: 0
Example output when NOT run as root:
Effective user id: 1000
Must be run as root. Exiting ...
If you want to ensure that a script is run as a normal user, you can use the Users.require_not_root function. If the script is run as root, it will print an error and exit.
Example:
def users_running_as_a_normal_user():
# Print the user id
print('Effective user id: {0}'.format(os.getuid()))
# Will print an error and exit if the user is root
Users.require_not_root()
Example output when run as root:
Effective user id: 0
Must not be run as root. Exiting ...
Example output when NOT run as root:
Effective user id: 1000
Often you will need do some actions as root, and others as a normal user, all in the same script. A common example is to compile a program as a normal user, then install it as root. You can do this by running the script as root, then using the function Users.do_as_normal_user to temporarily step down as a normal user.
Example:
def users_privilege_escalation():
# User id by default
print('Effective user id: {0}'.format(os.geteuid()))
# User id when running as a normal user
def cb():
print('Effective user id: {0}'.format(os.geteuid()))
Users.do_as_normal_user(cb)
# User id by default
print('Effective user id: {0}'.format(os.geteuid()))
Example output:
Effective user id: 0 Effective user id: 1000 Effective user id: 0
When running a script with a privilege escalation tool such as sudo, you often need to get the actual user name. Most python functions such as getpass.getuser will return 'root', because it is actually being run as root. To get the actual user name, you can use the Users.get_normal_user_name function.
Example:
def users_user_name():
import getpass
print('Current user name: {0}'.format(getpass.getuser()))
print('Normal user name: {0}'.format(Users.get_normal_user_name()))
Example output when NOT run as root:
Current user name: matt Normal user name: matt
Example output when run as root:
Current user name: root Normal user name: matt
When running a script with a privilege escalation tool such as sudo, you often need to get the actual user id. Most python functions such as os.getuid and os.geteuid will return 0, because it is actually being run as root.
Example:
def users_user_id():
print('Current user id: {0}'.format(os.getuid()))
print('Normal user id: {0}'.format(Users.get_normal_user_id()))
Example output when NOT run as root:
Current user id: 1000 Normal user id: 1000
Example output when run as root:
Current user id: 0 Normal user id: 1000
# Most of this section requires the modules:
import lib_raise_fs as FS
change_dir(name)
Uses the standard Python os.chdir
function to change to the name directory.
Example:
def fs_change_dir():
FS.change_dir('example')
Example output:
Changing to dir 'example' ... :)
move_file(source, dest)
Uses the standard Python shutil.move function to move the file
source to dest.
Example:
def fs_move_file():
FS.move_file('one', 'two')
Example output:
Moving the file 'one' to 'two' ... :)
copy_file(source, dest)
Uses the standard Python shutil.copy2 function to copy the file
source to dest.
Example:
def fs_copy_file():
FS.copy_file('one', 'two')
Example output:
Copying the file 'one' to 'two' ... :)
copy_new_file(source, dest)
Copies the file only if dest does not exist, or source is
different from dest.
Example:
def fs_copy_new_file():
FS.copy_new_file('one', 'two')
Example output:
Copying the file 'one' to 'two' ... :)
copy_dir(source, dest, symlinks = False)
Uses the standard Python shutil.copytree function to recursively copy
the directory from source to dest. If
symlinks is True, symlinks remail links. If symlinks is False the links
are replaced with copies of the actual data.
Example:
def fs_copy_dir():
FS.copy_dir('example', 'new_example', symlinks = False)
Example output:
Copying the dir 'example' to 'new_example' ... :)
make_dir(source, ignore_failure = False)
Uses the standard Python os.mkdir function to make the
directory source. If ignore_failure
is False, any errors will be ignored.
Example:
def fs_make_dir():
FS.make_dir('example', ignore_failure = True)
Example output:
Making the dir 'example' ... :)
remove_dir(name, and_children = False)
Uses the standard Python shutil.rmtree function to remove the
directory name. If name is the current
directory, it will display an error. If and_children
is True it will remove any child directories.
Example:
def fs_remove_dir():
FS.remove_dir('example', and_children = True)
Example output:
Removing the dir 'example' ... :)
remove_file(name, ignore_failure = False)
Uses the standard Python os.rmdir function to remove the
file name. If ignore_failure
is True it will ignore any errors.
Example:
def fs_remove_file():
FS.remove_file('does_not_exist', ignore_failure = True)
Example output:
Removing the file 'does_not_exist' ... :)
remove_binaries(name)
Will remove any files that start with name, and have the
extensions .exe, .o, .obj, .so, .a, .dll, .lib, .pyc, .exe.mdb, .dll.mdb,
.jar, .class.
Example:
def fs_remove_binaries():
FS.remove_binaries('main')
Example output:
Removing binaries 'main' ... :)
symlink(source, link_name)
Uses the standard Python os.symlink function to create a
symlink from source to link_name.
Example:
def fs_symlink():
FS.symlink('example', 'example_link')
Example output:
Symlinking 'example' to 'example_link' ... :)
# Most of this section requires the modules:
import lib_raise_terminal as Terminal
If you want to print your own OK message, you can use the Terminal.status and Terminal.ok functions.
Example:
def terminal_ok():
Terminal.status("Looks like things will be okay")
Terminal.ok()
Example output:
Looks like things will be okay ... :)
If you want to print your own warning message, you can use the Terminal.status and Terminal.warning functions.
 Here is the warning")
Example output:
Looks like this may give a warning .........................................:\
Yep. Here is the warning
If you want to print your own fail message, you can use the Terminal.status and Terminal.fail functions.
Example:
def terminal_fail():
Terminal.status("This may fail")
Terminal.fail("Yep. Here is the fail message")
Example output:
This may fail ..............................................................:(
Yep. Here is the fail message
# Most of this section requires the modules:
import lib_raise_find as Find
import lib_raise_python as Python
Raise has built in functionality for finding programs, libraries, and header files. It tries to use the OSes native way of searching for files. If that is not available, or does not find anything, it will fall-back to searching the file system. Raise can also include the version number when searching for libraries and header files.
Raise searches the OS packaging sources in this order:Version numbers use the standard format major.minor.micro. They are stored in a named tuple. You can access the complete version as a tuple. And you can access the major, minor, or micro section as a property.
ver # (1, 2, 0)
ver.major # 1
ver.minor # 2
ver.micro # 0
When creating your version requirements, you have to use a string:
# Version 1.2.0
'ver == (1, 2, 0)'
# Version 1.2.0 the long way
'ver.major==1 and ver.minor==2 and ver.micro==0'
# Version 1.9 or greater
'ver >= (1, 9)'
# Version 1
'ver.major == 1'
# Version 1.X with an odd minor number like 1.3 not 1.2
'ver >= (1.0) and ver.minor % 2'
You can find a program, by searching for it with the Find.program_paths function. You can also use regular expressions in the name. There is currently no standard way to specify what version of the program you want to find.
Example:
def find_finding_programs():
paths = Find.program_paths('gcc')
print(paths)
paths = Find.program_paths('g++', r'g++-[0-9|\.]*')
print(paths)
Example output:
['/usr/bin/gcc'] ['/usr/bin/g++', '/usr/bin/g++-5']
You can make sure a program is installed, by using the Find.require_programs function. If the program is not installed, it will print an error and exit. There is currently no way to specify what version of the program you want to require.
Example:
def find_requiring_programs():
Find.require_programs(['gcc'])
Example output:
Checking for program 'gcc' ... :)
You can find a library, by searching for it with the Find.get_static_library and Find.get_shared_library functions. Optionally you can use the version lambda to specify what version you want.
Example:
def find_finding_libraries():
# SDL Library any version
print(Find.get_static_library('libSDL'))
print(Find.get_shared_library('libSDL'))
# SDL Library at least version 1.2
print(Find.get_shared_library('libSDL', 'ver >= (1, 2)'))
# SDL Library of version 1.X
print(Find.get_shared_library('libSDL', 'ver.major == 1'))
Example output:
/usr/lib/x86_64-linux-gnu/libSDL.a /usr/lib/x86_64-linux-gnu/libSDL.so /usr/lib/x86_64-linux-gnu/libSDL.so /usr/lib/x86_64-linux-gnu/libSDL.so
You can make sure a library is installed, by using the Find.require_static_library and Find.require_shared_library functions. If the library is not installed, it will print an error and exit. Optionally you can use the version lambda to specify what version you want.
Example:
def find_requiring_libraries():
# SDL Library any version
Find.require_static_library('libSDL')
Find.require_shared_library('libSDL')
# SDL Library at least version 1.2
Find.require_shared_library('libSDL', 'ver >= (1, 2)')
# SDL Library of version 1.X
Find.require_shared_library('libSDL', 'ver.major == 1')
Example output:
Checking for static library 'libSDL' ... :) Checking for shared library 'libSDL' ... :) Checking for shared library 'libSDL' ... :) Checking for shared library 'libSDL' ... :)
You can find a header file, by searching for it with the Find.get_header_file function. Optionally you can use the version lambda to specify what version you want.
Example:
def find_finding_headers():
# SDL Library any version
print(Find.get_header_file('libSDL'))
# SDL Library at least version 1.2
print(Find.get_header_file('libSDL', 'ver >= (1, 2)'))
# SDL Library of version 1.X
print(Find.get_header_file('libSDL', 'ver.major == 1'))
Example output:
/usr/include/SDL/SDL.h /usr/include/SDL/SDL.h /usr/include/SDL/SDL.h
You can make sure a header file is installed, by using the Find.require_header_file function. If the header is not installed, it will print an error and exit. Optionally you can use the version lambda to specify what version you want.
Example:
def find_requiring_headers():
# SDL Library any version
Find.require_header_file('libSDL')
# SDL Library at least version 1.2
Find.require_header_file('libSDL', 'ver >= (1, 2)')
# SDL Library of version 1.X
Find.require_header_file('libSDL', 'ver.major == 1')
Example output:
Checking for header file 'libSDL' ... :) Checking for header file 'libSDL' ... :) Checking for header file 'libSDL' ... :)
You can search for environmental variables by using the Find.require_environmental_variable function.
Example:
def find_requiring_environmental_variable():
# Require that PATH exists
Find.require_environmental_variable('PATH')
Example output:
Checking for environmental variable 'PATH' ... :)
You can make sure Python modules are installed by using the Python.require_python_modules function.
Example:
def find_requiring_python_modules():
# Require that os, sys, and platform are installed
Python.require_python_modules(['os', 'sys', 'platform'])
Example output:
Checking for python module 'os' ... :) Checking for python module 'sys' ... :) Checking for python module 'platform' ... :)
# Most of this section requires the modules:
import lib_raise_c as C
import lib_raise_ar as AR
Many C compilers/OSes use different extensions for different types of files. To get around this limitation, you can use the file extension for the Raise rows below, and it will automatically be mapped to the OS type below.
| Raise | Cygwin | Windows | OS X | Linux/Unix | |
|---|---|---|---|---|---|
| Executable | .exe | .exe | .exe | ||
| Object | .o | .o | .obj | .o | .o |
| Shared Library | .so | .so | .dll | .dylib | .so |
| Static Library | .a | .a | .lib | .a | .a |
Raise supports the GCC, Clang, and MS cl.exe C compilers. The compiler is abstracted away in a generalized way, as to make it so you don't have to worry about compiler specific functionality.
You can select the best C compiler for your platform by using the C.get_default_compiler function.
You can also select the compiler specifically by using the C.c_compilers dictionary. Be careful as only compilers that were found by Raise will be in the dictionary.
Example:
def c_compilers():
cc = C.get_default_compiler()
# Print the compiler name and path for fun
print("name: {0}".format(cc._name))
print("path: {0} ".format(cc._path))
cc = C.c_compilers['clang']
# Print the compiler name and path for fun
print("name: {0}".format(cc._name))
print("path: {0} ".format(cc._path))
Example output:
name: gcc path: /usr/bin/gcc name: clang path: /usr/bin/clang
After the compiler is selected, it can be configured using the properties.
Example:
def c_compiler_setup():
# Get a C compiler
cc = C.get_default_compiler()
# Compiler setup
cc.debug = True
cc.standard = C.Standard.std2011
cc.position_independent_code = True
cc.optimize_level = 2
cc.warnings_all = True
cc.warnings_extra = True
cc.warnings_as_errors = True
cc.compile_time_flags = ['SDL=true']
# Print environmental variables to see what happens under the hood
print("$CC: {0}".format(cc.cc))
print("$CFLAGS: {0}".format(cc.cflags))
Example output:
$CC: gcc $CFLAGS: -g -std=c11 -fPIC -Wall -Wextra -Werror -O2 -DSDL=true
C object files can be built using the C.build_object function.
Example:
def c_building_object():
# Get and setup the C compiler
cc = C.get_default_compiler()
cc.debug = True
# Build the object
cc.build_object('main.o', ['main.c'])
Example output:
Building C object 'main.o' ... :)
C programs can be built using the C.build_program function.
Example:
def c_building_program():
# Get and setup the C compiler
cc = C.get_default_compiler()
cc.debug = True
# Build the program
cc.build_program('main.exe', ['main.c'])
Example output:
Building C program 'main.exe' ... :)
C shared library can be built using the C.build_shared_library function. C static libraries can be built using the AR.build_static_library function.
Example:
def c_building_library():
# Get and setup the C compiler
cc = C.get_default_compiler()
cc.debug = True
# Build the library into an object
cc.build_object('libexample.o', ['libexample.c'])
# Build the library as a shared and static library
cc.build_shared_library('libexample.so', ['libexample.o'])
AR.build_static_library('libexample.a', ['libexample.o'])
Example output:
Building C object 'libexample.o' ... :) Building C shared library 'libexample.so' ... :) Building static library 'libexample.a' ... :)
C programs can be installed with the C.install_program function, and uninstalled with the C.uninstall_program function.
Example:
def c_program_installation_and_uninstallation():
# Get and setup the C compiler
cc = C.get_default_compiler()
cc.debug = True
# Build the program
cc.build_program('main.exe', ['main.c'])
# Install the program
C.install_program('main.exe')
FS.remove_binaries('main')
# Run the C program from the system
C.run_print('main.exe')
# Uninstall the program
C.uninstall_program('main.exe')
Example output:
Building C program 'main.exe' ... :) Installing the program 'main.exe' ... :) Removing binaries 'main' ... :) Running C program ... :) main.exe Hello World! Uninstalling the program 'main.exe' ... :)
C libraries can be installed with the C.install_library function, and uninstalled with the C.uninstall_library function.
Example:
def c_library_installation_and_uninstallation():
# Get and setup the C compiler
cc = C.get_default_compiler()
cc.debug = True
# Build the library
cc.build_object('libexample.o', ['libexample.c'])
cc.build_shared_library('libexample.so', ['libexample.o'])
# Install the library
C.install_library('libexample.so')
# Uninstall the library
C.uninstall_library('libexample.so')
Example output:
Building C object 'libexample.o' ... :) Building C shared library 'libexample.so' ... :) Installing the library 'libexample.so' ... :) Uninstalling the library 'libexample.so' ... :)
C headers can be installed with the C.install_header function, and uninstalled with the C.uninstall_header function.
Example:
def c_header_installation_and_uninstallation():
# Get and setup the C compiler
cc = C.get_default_compiler()
cc.debug = True
# Install the header
C.install_header('libexample.h')
# Uninstall the header
C.uninstall_header('libexample.h')
Example output:
Installing the header 'libexample.h' ... :) Uninstalling the header 'libexample.h' ... :)
C programs can be ran with the C.run_print function.
Example:
def c_running_and_printing():
# Get and setup the C compiler
cc = C.get_default_compiler()
cc.debug = True
# Build the program
cc.build_program('main.exe', ['main.c'])
# Run the C program
C.run_print('./main.exe')
Example output:
Building C program 'main.exe' ... :) Running C program ... :) ./main.exe Hello World!
# Most of this section requires the modules:
import lib_raise_cxx as CXX
import lib_raise_ar as AR
Many C++ compilers/OSes use different extensions for different types of files. To get around this limitation, you can use the file extension for the Raise rows below, and it will automatically be mapped to the OS type below.
| Raise | Cygwin | Windows | OS X | Linux/Unix | |
|---|---|---|---|---|---|
| Executable | .exe | .exe | .exe | ||
| Object | .o | .o | .obj | .o | .o |
| Shared Library | .so | .so | .dll | .so | .dylib |
| Static Library | .a | .a | .lib | .a | .a |
Raise supports the GCC, Clang, and MS cl.exe C++ compilers. The compiler is abstracted away in a generalized way, as to make it so you don't have to worry about compiler specific functionality.
You can select the best C++ compiler for your platform by using the CXX.get_default_compiler function.
You can also select the compiler specifically by using the CXX.cxx_compilers dictionary. Be careful as only compilers that were found by Raise will be in the dictionary.
Example:
def cxx_compilers():
cxx = CXX.get_default_compiler()
# Print the compiler name and path for fun
print("name: {0}".format(cxx._name))
print("path: {0} ".format(cxx._path))
cxx = CXX.cxx_compilers['clang++']
# Print the compiler name and path for fun
print("name: {0}".format(cxx._name))
print("path: {0} ".format(cxx._path))
Example output:
name: g++ path: /usr/bin/g++ name: clang++ path: /usr/bin/clang++
After the compiler is selected, it can be configured using the properties.
Example:
def cxx_compiler_setup():
# Get a C++ compiler
cxx = CXX.get_default_compiler()
# Compiler setup
cxx.debug = True
cxx.standard = CXX.Standard.std2011
cxx.position_independent_code = True
cxx.optimize_level = 2
cxx.warnings_all = True
cxx.warnings_extra = True
cxx.warnings_as_errors = True
cxx.compile_time_flags = ['SDL=true']
# Print environmental variables to see what happens under the hood
print("$CXX: {0}".format(cxx.cxx))
print("$CXXFLAGS: {0}".format(cxx.cxxflags))
Example output:
$CXX: g++ $CXXFLAGS: -g -std=c++11 -fPIC -Wall -Wextra -Werror -O2 -DSDL=true
C++ object files can be built using the CXX.build_object function.
Example:
def cxx_building_object():
# Get and setup the C++ compiler
cxx = CXX.get_default_compiler()
cxx.debug = True
# Build the object
cxx.build_object('main.o', ['main.cc'])
Example output:
Building C++ object 'main.o' ... :)
C++ programs can be built using the CXX.build_program function.
Example:
def cxx_building_program():
# Get and setup the C++ compiler
cxx = CXX.get_default_compiler()
cxx.debug = True
# Build the program
cxx.build_program('main.exe', ['main.cc'])
Example output:
Building C++ program 'main.exe' ... :)
C++ shared library can be built using the CXX.build_shared_library function. C++ static libraries can be built using the AR.build_static_library function.
Example:
def cxx_building_library():
# Get and setup the C++ compiler
cxx = CXX.get_default_compiler()
cxx.debug = True
# Build the library into an object
cxx.build_object('libadd.o', ['libadd.cc'])
# Build the library as a shared and static library
cxx.build_shared_library('libadd.so', ['libadd.o'])
AR.build_static_library('libadd.a', ['libadd.o'])
Example output:
Building C++ object 'libadd.o' ... :) Building C++ shared library 'libadd.so' ... :) Building static library 'libadd.a' ... :)
C++ programs can be installed with the CXX.install_program function, and uninstalled with the CXX.uninstall_program function.
Example:
def cxx_program_installation_and_uninstallation():
# Get and setup the C++ compiler
cxx = CXX.get_default_compiler()
cxx.debug = True
# Build the program
cxx.build_program('main.exe', ['main.cc'])
# Install the program
CXX.install_program('main.exe')
FS.remove_binaries('main')
# Run the C++ program from the system
CXX.run_print('main.exe')
# Uninstall the program
CXX.uninstall_program('main.exe')
Example output:
Building C++ program 'main.exe' ... :) Installing the program 'main.exe' ... :) Removing binaries 'main' ... :) Running C++ program ... :) main.exe Hello World! Uninstalling the program 'main.exe' ... :)
C++ libraries can be installed with the CXX.install_library function, and uninstalled with the CXX.uninstall_library function.
Example:
def cxx_library_installation_and_uninstallation():
# Get and setup the C++ compiler
cxx = CXX.get_default_compiler()
cxx.debug = True
# Build the library
cxx.build_object('libadd.o', ['libadd.cc'])
cxx.build_shared_library('libadd.so', ['libadd.o'])
# Install the library
CXX.install_library('libadd.so')
# Uninstall the library
CXX.uninstall_library('libadd.so')
Example output:
Building C++ object 'libadd.o' ... :) Building C++ shared library 'libadd.so' ... :) Installing the library 'libadd.so' ... :) Uninstalling the library 'libadd.so' ... :)
C++ headers can be installed with the CXX.install_header function, and uninstalled with the CXX.uninstall_header function.
Example:
def cxx_header_installation_and_uninstallation():
# Get and setup the C++ compiler
cxx = CXX.get_default_compiler()
cxx.debug = True
# Install the header
CXX.install_header('libadd.h')
# Uninstall the header
CXX.uninstall_header('libadd.h')
Example output:
Installing the header 'libadd.h' ... :) Uninstalling the header 'libadd.h' ... :)
C++ programs can be ran with the CXX.run_print function.
Example:
def cxx_running_and_printing():
# Get and setup the C++ compiler
cxx = CXX.get_default_compiler()
cxx.debug = True
# Build the program
cxx.build_program('main.exe', ['main.cc'])
# Run the C++ program
CXX.run_print('./main.exe')
Example output:
Building C++ program 'main.exe' ... :) Running C++ program ... :) ./main.exe Hello World!
# Most of this section requires the modules:
import lib_raise_d as D
Many D compilers/OSes use different extensions for different types of files. To get around this limitation, you can use the file extension for the Raise rows below, and it will automatically be mapped to the OS type below.
| Raise | Cygwin | Windows | Standard | |
|---|---|---|---|---|
| Executable | .exe | .exe | .exe | |
| Object | .o | .obj | .obj | .o |
| Shared Library | .so | .dll | .dll | .so |
| Static Library | .a | .lib | .lib | .a |
Raise supports the DMD, and LDC, D compilers (not GDC). The compiler is abstracted away in a generalized way, as to make it so you don't have to worry about compiler specific functionality.
You can select the best D compiler for your platform by using the D.get_default_compiler function.
You can also select the compiler specifically by using the D.d_compilers dictionary. Be careful as only compilers that were found by Raise will be in the dictionary.
Example:
def d_compilers():
dc = D.get_default_compiler()
# Print the compiler name and path for fun
print("name: {0}".format(dc._name))
print("path: {0} ".format(dc._path))
dc = D.d_compilers['ldc']
# Print the compiler name and path for fun
print("name: {0}".format(dc._name))
print("path: {0} ".format(dc._path))
Example output:
name: dmd path: /usr/bin/dmd name: ldc path: /usr/bin/ldc2
After the compiler is selected, it can be configured using the properties.
Example:
def d_compiler_setup():
# Get a D compiler
dc = D.get_default_compiler()
# Compiler setup
dc.debug = True
dc.optimize = True
dc.warnings_all = True
dc.unittest = True
dc.compile_time_flags = ['SDL=true']
# Print environmental variables to see what happens under the hood
print("$DC: {0}".format(dc.dc))
print("$DFLAGS: {0}".format(dc.dflags))
Example output:
$DC: dmd $DFLAGS: -g -w -O -unittest -version=SDL=true
D object files can be built using the D.build_object function.
Example:
def d_building_object():
# Get and setup the D compiler
dc = D.get_default_compiler()
dc.debug = True
# Build the object
dc.build_object('main.o', ['main.d'])
Example output:
Building D object 'main.o' ... :)
D programs can be built using the D.build_program function.
Example:
def d_building_program():
# Get and setup the D compiler
dc = D.get_default_compiler()
dc.debug = True
# Build the program
dc.build_program('main.exe', ['main.d'])
Example output:
Building D program 'main.exe' ... :)
D static library can be built using the D.build_static_library function. The main DMD compiler and spec does not yet support building shared libraries.
Example:
def d_building_library():
# Get and setup the D compiler
dc = D.get_default_compiler()
dc.debug = True
# Build the library
dc.build_object('libsubtract.o', ['libsubtract.d'])
dc.build_static_library('libsubtract.a', ['libsubtract.o'])
Example output:
Building D object 'libsubtract.o' ... :) Building D static library 'libsubtract.a' ... :)
D interface can be built using the D.build_interface function.
Example:
def d_building_interface():
# Get and setup the D compiler
dc = D.get_default_compiler()
dc.debug = True
# Build the interface
dc.build_interface('libsubtract.d')
Example output:
Building D interface 'libsubtract.di' ... :)
D programs can be installed with the D.install_program function, and uninstalled with the D.uninstall_program function.
Example:
def d_program_installation_and_uninstallation():
# Get and setup the D compiler
dc = D.get_default_compiler()
dc.debug = True
# Build the program
dc.build_program('main.exe', ['main.d'])
# Install the program
D.install_program('main.exe')
FS.remove_binaries('main')
# Run the D program from the system
D.run_print('main.exe')
# Uninstall the program
D.uninstall_program('main.exe')
Example output:
Building D program 'main.exe' ... :) Installing the program 'main.exe' ... :) Removing binaries 'main' ... :) Running D program ... :) main.exe Hello World! Uninstalling the program 'main.exe' ... :)
D libraries can be installed with the D.install_library function, and uninstalled with the D.uninstall_library function.
Example:
def d_library_installation_and_uninstallation():
# Get and setup the D compiler
dc = D.get_default_compiler()
dc.debug = True
# Build the library
dc.build_object('libsubtract.o', ['libsubtract.d'])
dc.build_static_library('libsubtract.a', ['libsubtract.o'])
# Install the library
D.install_library('libsubtract.a')
# Uninstall the library
D.uninstall_library('libsubtract.a')
Example output:
Building D object 'libsubtract.o' ... :) Building D static library 'libsubtract.a' ... :) Installing the library 'libsubtract.a' ... :) Uninstalling the library 'libsubtract.a' ... :)
D interfaces can be installed with the D.install_interface function, and uninstalled with the D.uninstall_interface function.
Example:
def d_interface_installation_and_uninstallation():
# Get and setup the D compiler
dc = D.get_default_compiler()
dc.debug = True
# Build the interface
dc.build_interface('libsubtract.d')
# Install the interface
D.install_interface('libsubtract.di')
# Uninstall the interface
D.uninstall_interface('libsubtract.di')
Example output:
Building D interface 'libsubtract.di' ... :) Installing the interface 'libsubtract.di' ... :) Uninstalling the interface 'libsubtract.di' ... :)
D programs can be ran with the D.run_print function.
Example:
def d_running_and_printing():
# Get and setup the D compiler
dc = D.get_default_compiler()
dc.debug = True
# Build the program
dc.build_program('main.exe', ['main.d'])
# Run the D program
D.run_print('./main.exe')
Example output:
Building D program 'main.exe' ... :) Running D program ... :) ./main.exe Hello World!
# Most of this section requires the modules:
import lib_raise_csharp as CS
Raise supports the Mono, and MS.NET C# compilers. The compiler is abstracted away in a generalized way, as to make it so you don't have to worry about compiler specific functionality.
You can select the best C# compiler for your platform by using the CS.get_default_compiler function.
You can also select the compiler specifically by using the CS.cs_compilers dictionary. Be careful as only compilers that were found by Raise will be in the dictionary.
Example:
def csharp_compilers():
csc = CS.get_default_compiler()
# Print the compiler name and path for fun
print("name: {0}".format(csc._name))
print("path: {0} ".format(csc._path))
csc = CS.cs_compilers['dmcs']
# Print the compiler name and path for fun
print("name: {0}".format(csc._name))
print("path: {0} ".format(csc._path))
Example output:
name: dmcs path: /usr/bin/dmcs name: dmcs path: /usr/bin/dmcs
After the compiler is selected, it can be configured using the properties.
Example:
def csharp_compiler_setup():
# Get a C# compiler
csc = CS.get_default_compiler()
# Compiler setup
csc.debug = True
csc.optimize = True
csc.warnings_all = True
csc.warnings_as_errors = True
# Print environmental variables to see what happens under the hood
print("$CSC: {0}".format(csc.csc))
print("$CSFLAGS: {0}".format(csc.csflags))
Example output:
$CSC: dmcs $CSFLAGS: -debug -warn:4 -warnaserror -optimize
C# programs can be built using the CS.build_program function.
Example:
def csharp_building_program():
# Get and setup the C# compiler
csc = CS.get_default_compiler()
csc.debug = True
# Build the program
csc.build_program('main.exe', ['main.cs'])
Example output:
Building C# program 'main.exe' .............................................:\
warning CS8001: SDK path could not be resolved
C# static library can be built using the CS.build_shared_library function.
Example:
def csharp_building_library():
# Get and setup the C# compiler
csc = CS.get_default_compiler()
csc.debug = True
# Build the library
csc.build_shared_library('math_helper.dll', ['math_helper.cs'])
Example output:
Building C# shared library 'math_helper.dll' ...............................:\
warning CS8001: SDK path could not be resolved
C# programs can be installed with the CS.install_program function, and uninstalled with the CS.uninstall_program function.
Example:
def csharp_program_installation_and_uninstallation():
# Get and setup the C# compiler
csc = CS.get_default_compiler()
csc.debug = True
# Build the program
csc.build_program('main.exe', ['main.cs'])
# Install the program
CS.install_program('main.exe', 'csharp_example')
FS.remove_binaries('main')
# Run the C# program from the system
#FIXME: CS.run_print does not work on Linux, because when installed it runs
# the app from a shell script that does "mono blah.exe".
#CS.run_print('main.exe')
findlib.run_print("main")
# Uninstall the program
CS.uninstall_program('main.exe', 'csharp_example')
Example output:
Building C# program 'main.exe' .............................................:\ warning CS8001: SDK path could not be resolved Installing the program 'main.exe' ... :) Removing binaries 'main' ... :) Running command ... :) main Hello World! Uninstalling the program 'main.exe' ... :)
C# libraries can be installed with the CS.install_library function, and uninstalled with the CS.uninstall_library function.
Example:
def csharp_library_installation_and_uninstallation():
# Get and setup the C# compiler
csc = CS.get_default_compiler()
csc.debug = True
# Build the library
csc.build_shared_library('math_helper.dll', ['math_helper.cs'])
# Install the library
CS.install_library('math_helper.dll', 'libmath_helper')
# Uninstall the library
CS.uninstall_library('math_helper.dll', 'libmath_helper')
Example output:
Building C# shared library 'math_helper.dll' ...............................:\ warning CS8001: SDK path could not be resolved Installing the library 'math_helper.dll' ... :) Uninstalling the library 'math_helper.dll' ... :)
C# programs can be ran with the CS.run_print function.
Example:
def csharp_running_and_printing():
# Get and setup the C# compiler
csc = CS.get_default_compiler()
csc.debug = True
# Build the program
csc.build_program('main.exe', ['main.cs'])
# Run the C# program
csc.run_print('main.exe')
Example output:
Building C# program 'main.exe' .............................................:\ warning CS8001: SDK path could not be resolved Running C# program ... :) main.exe Hello World!
# Most of this section requires the modules:
import lib_raise_java as Java
Raise supports the OpenJDK 7 Java compiler. The compiler is abstracted away in a generalized way, as to make it so you don't have to worry about compiler specific functionality.
You can select the best Java compiler for your platform by using the Java.get_default_compiler function.
You can also select the compiler specifically by using the Java.cs_compilers dictionary. Be careful as only compilers that were found by Raise will be in the dictionary.
Example:
def java_compilers():
javac = Java.get_default_compiler()
# Print the compiler name and path for fun
print("name: {0}".format(javac._name))
print("path: {0} ".format(javac._path))
javac = Java.java_compilers['javac']
# Print the compiler name and path for fun
print("name: {0}".format(javac._name))
print("path: {0} ".format(javac._path))
Example output:
name: javac path: /usr/bin/javac name: javac path: /usr/bin/javac
After the compiler is selected, it can be configured using the properties.
Example:
def java_compiler_setup():
# Get a Java compiler
javac = Java.get_default_compiler()
# Compiler setup
javac.debug = True
javac.warnings = True
javac.verbose = False
javac.deprecation = True
# Print environmental variables to see what happens under the hood
print("$JAVAC: {0}".format(javac.javac))
print("$JAR: {0}".format(javac.jar))
print("$JAVA: {0}".format(javac.java))
print("$JAVAFLAGS: {0}".format(javac.javaflags))
Example output:
$JAVAC: javac $JAR: jar $JAVA: java $JAVAFLAGS: -g -deprecation
Java programs can be built using the Java.build_program function.
Example:
def java_building_program():
# Get and setup the Java compiler
javac = Java.get_default_compiler()
javac.debug = True
# Build the program
javac.build_program('main.class', ['main.java'])
Example output:
Building Java program 'main.class' ... :)
Java static library can be built using the Java.build_shared_library function.
Example:
def java_building_library():
# Get and setup the java compiler
javac = Java.get_default_compiler()
javac.debug = True
# Build the library
javac.build_jar('math_helper.jar', ['lib_math.java'])
Example output:
Building Java jar 'math_helper.jar' ... :)
Java programs can be installed with the Java.install_program function, and uninstalled with the Java.uninstall_program function.
Example:
def java_program_installation_and_uninstallation():
# Get and setup the Java compiler
javac = Java.get_default_compiler()
javac.debug = True
# Build the program
javac.build_program('main.class', ['main.java'])
# Install the program
Java.install_program('main.class', 'java_example')
FS.remove_binaries('main')
# Run the Java program from the system
#FIXME: Java.run_print does not work on Linux, because when installed it runs
# the app from a shell script that does "java blah".
#Java.run_print('main')
findlib.run_print("main")
# Uninstall the program
Java.uninstall_program('main.class', 'java_example')
Example output:
Building Java program 'main.class' ... :) Installing the program 'main.class' ... :) Removing binaries 'main' ... :) Running command ... :) main Hello World! Uninstalling the program 'main.class' ... :)
Java libraries can be installed with the Java.install_library function, and uninstalled with the Java.uninstall_library function.
Example:
def java_library_installation_and_uninstallation():
# Get and setup the Java compiler
javac = Java.get_default_compiler()
javac.debug = True
# Build the jar
javac.build_jar('lib_math.jar', ['lib_math.java'])
# Install the jar
Java.install_jar('lib_math.jar', 'lib_math')
# Uninstall the jar
Java.uninstall_jar('lib_math.jar', 'lib_math')
Example output:
Building Java jar 'lib_math.jar' ... :) Installing the jar 'lib_math.jar' ... :) Uninstalling the jar 'lib_math.jar' ... :)
Java programs can be ran with the Java.run_print function.
Example:
def java_running_and_printing():
# Get and setup the Java compiler
javac = Java.get_default_compiler()
javac.debug = True
# Build the program
javac.build_program('main.class', ['main.java'])
# Run the Java program
javac.run_print('main')
Example output:
Building Java program 'main.class' ... :) Running Java program ... :) java main Hello World!
# Most of this section requires the modules:
import lib_raise_process as Process
Raise normally runs events in serial. If you want to run events concurrently and leverage multiple CPU cores, you can use Process.concurrent_start and Process.concurrent_end. Make sure to only group the same type of events, between start and end. Otherwise it may give you unexpected results.
Example:
def concurrency():
# Get and setup the C compiler
cc = C.get_default_compiler()
cc.debug = True
# Tell Raise to start queueing the events after this function
Process.concurrent_start()
cc.build_object('main.o', ['main.c'])
cc.build_object('libexample.o', ['libexample.c'])
# Tell Raise to start running all the queued events concurrently
Process.concurrent_end()
Example output:
Building C objects concurrently ... 'main.o' ... :) 'libexample.o' ... :)
# Most of this section requires the modules:
import lib_raise_cpu as CPU
Information about the CPU can be gotten from properties:
Example:
def cpu():
print("Architechture: {0}".format(CPU.arch))
print("Bits: {0}".format(CPU.bits))
print("MHz: {0}".format(CPU.mhz))
print("Name: {0}".format(CPU.name))
print("Vendor Name: {0}".format(CPU.vendor_name))
print("Flags: {0}".format(str.join(', ', CPU.flags)))
print("Cores: {0}".format(CPU.cpus_total))
Example output:
Architechture: X86_64 Bits: 64 MHz: 2.8000 GHz Name: Intel(R) Pentium(R) CPU G640 @ 2.80GHz Vendor Name: GenuineIntel Flags: acpi, aperfmperf, apic, arat, arch_perfmon, bts, clflush, cmov, constant_tsc, cx16, cx8, de, ds_cpl, dtes64, dtherm, dts, eagerfpu, epb, ept, est, flexpriority, fpu, fxsr, ht, lahf_lm, lm, mca, mce, mmx, monitor, msr, mtrr, nonstop_tsc, nopl, nx, pae, pat, pbe, pcid, pclmulqdq, pdcm, pebs, pge, pln, pni, popcnt, pse, pse36, pts, rdtscp, rep_good, sep, ss, sse, sse2, sse4_1, sse4_2, ssse3, syscall, tm, tm2, tpr_shadow, tsc, tsc_deadline_timer, vme, vmx, vnmi, vpid, xsave, xsaveopt, xtopology, xtpr Cores: 2
If you choose to do development on Raise itself, there are some tools that can make it easier. These are located in the "tools" directory. These scripts are smart enough to automatically figure out the correct directories to work on. So you do not need to run them from the "tools" directory. Any directory will do.
If you make changes to the root "raise" file, you will want those same changes to be copied to all the other directories that have their own "raise" file (tests, docs, and examples). Instead of having to do this manually, you can use the "tools/update_raise_in_sub_directories.py" script. It will automatically look through all the sub directories and replace any files named "raise" with the root "raise" file.
python tools/update_raise_in_sub_directories.py


TD joins ranks of systemic banks, Deutsche drops a level
by Huw JonesCanada’s second-biggest lender, Toronto Dominion Bank, has been added to a global list of systemic banks that must hold extra capital, while Deutsche Bank has dropped a rank within the list, the Financial Stability Board (FSB) said on Friday.
The international body, based in Basel, Switzerland, was updating its list of systemic banks, introduced in the aftermath of the global financial crisis a decade ago, when taxpayers in some countries had to bail out struggling lenders.
The addition of TD Bank brings the total number of systemic banks to 30.
Systemic banks are slotted into one of five buckets, although the fifth – where banks would be required to hold an extra 3.5 per cent of capital to risk-weighted assets on top of minimum requirements – remains empty.
TD has been placed in the first bucket, with a 1-per-cent surcharge.
TD, along with Canada’s five other big banks, is already designated a domestic systemically important bank, which subjects it to a 1-per-cent common equity capital surcharge, according to Canada’s banking regulator. Canadian banks are required to hold 8 per cent of capital to risk-weighed assets, and an additional capital conservation buffer of 2.5 per cent.
“Management does not expect any impact to TD’s capital position with this designation,” TD said in a statement.
The bank is “well-positioned to meet the [global systemically important bank] requirements starting in November 2020,” Canada’s Office of the Superintendent of Financial Institutions, which regulates the industry, said in a separate statement.
JP Morgan Chase remains the sole occupier of the fourth bucket, with a 2.5-per-cent capital surcharge.
Citigroup and HSBC are in the third bucket, with a 2-per-cent surcharge.
Deutsche Bank has dropped from the third to the second bucket, which has a 1.5-per-cent surcharge, in a sign of how the struggling German lender is shrinking and simplifying its operations.
“This was primarily driven by reductions in leverage, strategic adjustments in the bank’s business and geographic perimeter and lower derivative volumes, together with wider industry developments,” Deutsche Bank said in a statement.
Deutsche Bank is, however, still required to meet a 2-per-cent extra capital requirement as a “domestic systemically important bank,” and therefore the overall capital buffer is expected to remain unchanged, the German bank said.
Changes to capital requirements come into effect in January, 2021.
Banks on the list also face more onerous requirements for issuing special bonds that can be written down to replenish capital burnt in a crisis to shield taxpayers.


An application that allows you to keep track
of your Marvel Comics and see the current
value of them.
(In Progress)
An application with a Tinder Style card User
Interface that allows you to find a
restaurant near you, without a hassle.
(In Progress)
A Google Chrome extension that analyzes
emails and returns an emoji based on the mood
of the email.
sudo HackStetson 2017


Alpha Web Version of
Adalogical Ænigma #28
Plant Trees and Connect Paths to Fulfill the Numbered Vistas
Disclaimer
This is a rough version, although it does save in browser. Other features present in previous puzzles are missing. I'll likely add them into future puzzles.
- Validation
- Legend
- Rules (for now please see the PDF version)
- Simple Undo
Completed
Example Puzzle & switching
Conjecture Mode
Also, see other web puzzles which are more complete.


For the fig-swirl: Melt butter over medium heat in a saucepan. Add brown sugar and stir to dissolve. Have all of the figs and toss in the saucepan with the lemon juice. Cook over medium heat, stirring frequently until you have a chunky-jammy mixture. Add salt with one or two stirs, set aside and let cool completely.
Ice cream: in a small pot over medium heat, combine milk and granulated sugar until sugar is completely dissolved and the milk is just barely lukewarm. Whisk in the egg yolks. Set mixture in the fridge and wait and wait until the fig mixture is cooled.
Using an icecream machine, pour liquids into the frozen basin and process according to the manufacturers instructions, i.e., let it spin and thicken for 20 minutes before adding mascarpone, fig jam mixture and nuts. Continue to process for +/-10 minutes. Pour semi-frozen mixture into a pyrex dish or glass tupperware. Freeze for at least two hours before serving.


Hodl Settings
General
Customize
Locale
Enabled
Matching Websites
Reset Settings
Buy me a coffee
ETH Address:
BTC Address:
LTC Address:
Replacement Word
Override matching words
Separated by comma
On Pageload
On Interval
Interval
2 seconds
5 seconds
15 seconds
30 seconds
Every minute
5 minutes
10 minutes
On change
Initial delay
Delay Time
1 second
5 seconds
10 seconds
15 seconds
Locale
Deutsch
English
Deutsch
Español
Français
bahasa Indonesia
Italiano
Nederlands
Português
Japanese


Nokia 5.3
Capture a whole range of new angles with the quad camera and ultra-wide 118° lens Shoot like a pro with advanced AI imaging to bring your nighttime and portrait shots to life
realme 5 Pro
48MP+8MP+2MP+2MP rear camera | 16MP front camera 16.002 centimeters (6.3-inch) Full HD+ capacitive touchscreen with 1080 x 2340 pixels resolution, 409 ppi pixel density
OnePlus 7T Pro
48+8+16MP triple rear camera with telephoto lens 16MP front camera with 4K video capture, ultrashot, nightscape, portrait, pro mode, panorama, HDR, AI scene detection, RAW image
Vivo X50 Pro
48+13+8+8MP rear camera | 32MP front camera 16.66 centimeters (6.56 inch) curved ultra O display with 1080 x 2376 pixels resolution Memory, Storage & SIM: 8GB RAM | 256GB internal memory


Speech
A speech by Glenys Stacey, Chief Regulator, at the Inside Government conference on GCSE and A level reform.
“I want my car to be composed purely of those components whose principles have been tried and tested and accepted as reliable standards, in fact, I will name my car the Standard car.” This is a quote from Reginald Walter Maudslay, founder of the Standard Motor Company (see note 1).
Starting my speech today with a quote from the founder of a now defunct motor company might initially appear rather odd. But do please bear with me.
Many of you here will know that our head office is located in Coventry, which was for many years the principal home of the Standard Motor Company. The firm was an engineering pioneer and in its heyday one of the biggest employers in the city. Immediately before the Second World War it was building just over 50,000 vehicles a year, rising to nearly 140,000 in 1960. Then everything changed. The company’s new flagship vehicle, the Triumph Herald, was poorly received by the public, being viewed as both expensive and of poor quality. The firm’s reputation was damaged. And while the Standard brand was killed-off in an attempt to save the business, the firm never recovered. The last car rolled off its production line in 1984, and the factory was successively demolished during the 1990s.
So it is with perhaps with a fair degree of serendipity that nearly five years ago we - the then newly-vested regulator charged with ensuring ‘reliable standards’ in the field of assessments - was located to a building that sits on part of the firm’s once prestigious Canley Halt factory site. I rather hope our future is less torrid than that of the Standard Motor Company, but its story contains a number of lessons for the reform of GCSE and A level qualifications from which we can benefit. These include having a clear vision for what we are trying to achieve, and investing the time and energy in the design of assessments to ensure their performance over time. But arguably the most important is to remember is that what is being created must meet our end user’s wants and needs. The Triumph Herald arguably failed on all these fronts. We will not.
The then Secretary of State for Education, Michael Gove, set out the current government’s vision for reforming GCSE and A level qualifications back in 2013. He called for GCSEs to be made more challenging so pupils are better prepared for further academic or vocational study, or for work. And said that the primary function of A levels should be to prepare students for university education (see note 2).
Those aims have translated into a rich programme of work for us, the Department for Education and the exam boards. Our role, as the assessment regulator, is to make sure the exam boards design appropriate ways of testing the revised curriculum and curriculum aims set by the Department. So our accreditation of the exam boards’ specifications forms the ‘accepted standards’ in Reginald Maudslay’s parlance. But we call it validity, and this is something we have been working on a great deal over the past few years.
Validity can be something of an abstract concept, and certainly much academic debate has been conducted in this area. Indeed the earliest discussions also happen to date back to around the time of the birth of the Standard Motor Company (see note 3). But for us, and I quote, validity is the degree to which it is possible to measure what needs to be measured by implementing an assessment procedure. I hope that is surprisingly underwhelming! Nevertheless, it is the absolute essence of what we do and why we matter, and therefore great care has gone into its definition. As such, let me just take a moment to unpack it a little.
You’ll notice that we do not talk about tests or qualifications here; instead our focus is on assessment procedures. That’s because they encompass each and every step in the journey from producing an assessment task to interpreting an assessment outcome. It means we are focussed on the features that are controlled, or standardised, rather than those that might vary from year to year, the most obvious of which are the questions asked on exam papers. This standardisation ensures that qualifications hold their value from one period to the next.
The other dimension to this description of validity is the measurement of skills, and specifically the right skills. For example, if the primary use of the outcome of a vehicle maintenance exam is to provide reassurance of a learner’s ability to change a tyre and spot weld a repair, then what needs to be measured in the exam are the learning outcomes that are fundamental to completing those tasks.
So that’s the vision, but what about the nuts and bolts of the new design? The reform process has been phased over three years, starting with the most high volume and traditional A level subjects prioritised to be available for first teaching this September. In order to deliver reform, we have run public consultations on a subject-by-subject basis in conjunction with the Department for Education. Those consultations have looked at how each qualification is designed and how the Department’s proposed content is to be assessed.
So far we’ve carried out consultations on just over 40 subjects at A level and GCSE, covering the subjects to be taught in schools and colleges for the first time in either September 2015 or September 2016. In each case this has involved the publication of an initial policy consultation, its findings and a decision; followed by a ‘technical’ consultation and its findings; and in turn regulatory requirements and subject guidance. Only after that have the exam boards submitted specifications to us for accreditation, and these have frequently required several iterations to achieve approval. And we haven’t finished yet; in the next few weeks we will confirm the subjects that will be available for teaching from 2017 and begin the process again.
I have to say I have been impressed by the degree of thought and the extent of public discussion through this process to date. It has been hugely encouraging to witness first-hand the passion that exists in this country regarding education and to receive the many innovative ideas that are being put forward. This helps to emphasise that we are not working through a simple mechanistic process, and in a limited number of circumstances it has become apparent that more time is required to build consensus around assessment design. In recent months, for example, the first teaching of GCSE design and technology has been deferred to 2017. Such decisions are not taken lightly, but we recognise that the additional time we invest in their design today will be worthwhile in terms of the additional confidence it will bring to those qualifications over the years ahead.
That said we are making good progress. There are accredited exam board specifications available for all subjects for first teaching this September. Some exam board specifications for some subjects are still to be accredited and we are working with those boards to ensure that they can be approved, but we must adhere to our robust accreditation process.
It should also be recalled that our changes do not begin and end at exam board specifications, we have been reflecting and redesigning a number of other aspects of the assessment process. As part of our reform programme we have removed modularisation, determined a new grading system and reconsidered tiering across GCSEs. We will also be making changes to non-exam assessment for both GCSEs and A levels. We have worked with subject and assessment experts as we have developed and tested our thinking on these matters, but these are rightly our judgements.
I hope it is apparent that we have taken care to involve and consult interested parties as we have considered how best to implement reform; we want our new standards to sell themselves. Some of our decisions have been contentious however, as we expected: for example our decision to implement new assessment arrangements for practical skills in A level biology, physics and chemistry. In each case, we have considered carefully the assessment and awarding arrangements most likely to deliver the best educational experience and outcomes for students. They are the end user after all.
Taken in sum, we are undergoing a period of unprecedented reform and confidence in the system’s operation needs to be earned. Returning to the derided Triumph Herald, it was unlikely that owners, or potential owners, found reason to fault the vehicle on their first journey. They gathered evidence with each bump along the road, and I suspect from each part that fell off. Similarly, the introduction of a new assessment framework can only take us so far in our reform journey. As the new qualifications are taught and assessments are undertaken, all parties would benefit from an extended period of stability. In particular, teachers would gain confidence in the qualifications and their ability to teach the new curriculum and those who use and observe the new assessments could be reassured that they are achieving their goals.
Now I don’t think I’m going to surprise anyone by saying that the upcoming General Election brings a degree of uncertainty to this aspiration. For example, there has already been some discussion as to whether a new government may wish to recouple AS and A levels. I spoke about this issue in November last year and we continue to hold a neutral stance. If any new government wishes to change policy and recouple, that can be done. However I would stress that assessment reform is not easy. This is a once in a generation opportunity to make changes that are well thought through and principled. Change has never been attempted in this way before and it will result in materially better qualifications that best reflect the needs of students and learners. As such, I would ask any incoming government to consider carefully before tinkering under the bonnet of GCSEs and A levels in the near future.
In conclusion, we have been given a clear vision for GCSEs and A levels and we are redesigning their assessment with the end user in mind. So what should this mean for students receiving the first reformed GCSEs and A levels in 2017?
To modify Reginald Maudslay’s quote: “I want assessments to be composed purely of those components whose principles have been accepted as reliable standards.” Our students will therefore have confidence that the qualification they receive at the end of their studies has a great deal of worth, to both them and those looking at their results. They will also know that it has measured the skills they have learned and compares favourably with international comparators. And finally, through our focus on validity they can be assured that the value of their qualification will not be eroded over time.
I therefore have great confidence that if the new specifications are taught well students will benefit from a better educational experience and fairer outcome from a more level playing field. We are raising educational and assessment standards and, in contrast to our Canley forebears, I am sure history will look favourably on the decisions we are taking today.
Thank you.
Notes:
Reginald Walter Maudslay quote taken from ‘The Book of the Standard Motor Company’ by Graham Robson
Letter from the Rt Hon Michael Gove MP to Ofqual Chief Regulator Glenys Stacey , 6 February 2013
Validity in educational and psychological assessment , Paul Newton and Stuart Shaw


| About Dailyrotten |
|
Feedback
If you like this page, hate it, or would like to suggest changes,
<EMAIL_ADDRESS>is listening. This page
is experimental and somewhat different from what we usually offer, so please
do send your feedback.
Adding Stories
If you are a rotten newshound and you would like to suggest a story,
visit our submit page to
send us the URL. Stories that are accepted will have your name credited.
Posting Comments
In order to post comments to stories, you will have to
create an account.
Accounts will generally be validated within 24 hours, and of
course will be disabled if there is abuse.
Viewership
On the first full day this page went live, 100,000 people visited this Rotten
News page. Of course that was the day after the WTC attacks, so that number is
somewhat distorted. Right now this page gets between 50,000 and 75,000 people
every day.
Linking
We encourage everyone to link to this page; if you like it, others probably
will as well.
Other Rotten
Rotten
Gaping Maw
Celebrity Morgue
Mugshots
Rotten Store
Rate My Poo
Rate My Kitten
Rate My Finger
Penny Postcards
Phallic
Boners
Home
Make Dailyrotten your start page
|
|
|
September 25, 2002
Teenagers burn bus shelters to get high
The Scotsman | Submitted by: Patricia Graeme
"Youths are setting light to plastic bins and bus shelters in a desperate
attempt to get high by inhaling the fumes... It’s because shops are clamping
down on selling glue that they are resorting to this sort of thing...
Since 1999 it has been illegal to sell lighter fuel to anyone under 18.
Traders who break the law can face a fine of UKP 5000 or six months in prison."
|
|
Read article...
|
|
Attempt at humor goes down like an altar boy
New York Post | Submitted by: cunt d
"Columbia University's marching band hit the Catholic Church below the
belt during a weekend football game, by announcing that rival Fordham's
tuition is "going down like an altar boy," fuming critics charge...
"If they're offended by those things, maybe they should think about the
victims of the church's sex-abuse scandals," said Hao, who calls
himself a former Catholic."
|
|
Read article...
|
|
Media falling down on the job
Toronto Star | Submitted by: Ann Onymous
"Last Thursday on CNN, anchor Kyra Phillips introduced a report by
Washington correspondent Bob Franken who said that the Rev. Jesse Jackson
was leading a march on the Justice Dept. "They are complaining about the
loss of civil liberties, and the loss of access to this administration,"
said Franken. "It is the coalition of the same civil rights, labour,
women's rights groups that we have known for decades now." He then gave
Jackson about 10 seconds. To my ears he sounded awfully dismissive. But
it got worse: A few seconds later Phillips gave at least three minutes
to a story about a two-legged dog.
|
|
Read article...
|
|
Early adventures in germ warfare
Globe and Mail | Submitted by: Ann Onymous
"Sheep infected by anthrax during secret trials on Gruinard were accidentally
blown into the water during disposal. Two carcasses floated to the mainland
and sparked an outbreak that killed seven cows, two horses, three cats and as
many as 50 sheep. Security services swept the incident under the rug by
suggesting that infected carcasses had fallen off a Greek ship in the vicinity."
|
|
Read article...
|
|
Corpse to get TV makeover
Guardian | Submitted by: Drole Noel
"Television producers were accused of "sick ratings chasing" yesterday
after announcing a search for a terminally ill person who would allow their
body to be dissected, rebuilt and exhibited by the scientist behind the
controversial Body Worlds exhibition." The article also mentions that
dissectors have discussed a number of improvements that could be done to correct
several of the body's failings, no word from any Higher Powers in response.
|
|
Read article...
|
|
Employer squirms over jury duty firing
Oklahoman | Submitted by: david kilmer
A company behaving badly:
"When he was first called for jury duty in February, Ford said Doug Owen,
the company's vice president, and Kenneth Owen, the company's chief executive
officer, told him he should tell the judge he was a racist and hated white
people so that he would be excused from jury service... Gray called James
Owen, who confirmed that Ford had been fired because he was on jury duty. The
judge said she told James Owen that was against the law... The company
claims Ford was fired for unethical business practices and violations of
company policy."
|
|
Read article...
|
|
UFO Politics 102: An Update
Pravda | Submitted by: anonymous
"Mr. Bassett is best known as an UFO activist. He believes that the United
States government is keeping secrets regarding the existence of UFOs and ET
from the American public. Stephen Bassett's campaign is called Disclosure
2003. Bassett is of the opinion that that the US government will eventually
come clean about what it knows, as so many Americans no longer believe what
the US government says on the issue."
 Officers broke into
the flat but by this time he was already outside hanging."
|
|
Read article...
|
|
Cheap smack for Brit kids
Evening Gazette | Submitted by: Son of Benway
"And today a former heroin user from Stockton, who became hooked when
he was just 12, spoke of schoolchildren spending their school dinner money
on drugs. The boy, who cannot be named, said: "The most I ever bought
heroin for is UKP 3 a bag and I've got mates who've bought it for UKP 2.50.
People can't scrape a fiver but they can get UKP 2.50 so the dealers just
sell them it for that to make more money."
 Some, including Penland, think the end for New
Orleans could come quickly with a monstrous hurricane overwhelming the
manmade levees that separate the city from the gulf waters and the Mississippi
River. New Orleans is sinking at the rate of three feet per century, and it
is already, on average, eight feet below sea level." The second link is an
earlier NPR segment on the situation. 40,000 to 100,000 people may lose their
lives if a strong enough hurricane hits New Orleans dead on.
|
|
Read article... and
This article...
|
|
British music industry extortion backfires
The Register | Submitted by: Soylent
The British equivalent of RIAA seems just as bad:
"Originally the BPI warned easyInternetCafe that it would get "bad PR"
if it became public knowledge that easyInternetCafe customers had been
downloading music files protected by copyright onto CDs in its stores...
Now the BPI have done an about-turn and are attempting to gag easyInternetCafe
from discussing anything further, presumably because they are embarrassed
that it has become public knowledge they have tried to extort as much
as UKP 1 million from easyInternetCafe."
|
|
Read article...
|
|
Woman loses eyes in accidents 30 years apart
Philadelphia Inquirer | Submitted by: anonymous
Sandy Peirson got shot in the eye after someone was trying to show off
a loaded gun in a bar. The bullet went off the shooter's hand, knicked his
brother's ear, then hit Peirson in the eye. The kicker is that she already
lost sight in her other eye in another shooting accident 30 years ago.
|
|
Read article...
|
|
Florida principal uses redneck logic
Florida Today | Submitted by: Son of Benway
"Eau Gallie High School's principal is allowing students to wear
clothing depicting the Confederate flag despite complaints that it is
culturally insensitive... "We don't have any rules or regulations
against the Confederate flag, what we do have on the dress code is
that students can't convey messages that are culturally insensitive,"
school principal Tom Sawyer said."
|
|
Read article...
|
|
Bumfights charged
Sign On San Diego | Submitted by: freakymeatballs
"Four Las Vegas men have been charged in San Diego County with illegally
soliciting homeless people to participate in "Bumfights," a reality video
that shows them fighting and performing dangerous stunts... The District
Attorney's Office charged Ryan Edward McPhearson, 19, Zachary Bubeck, 24,
Daniel Jamon Tanner, 21, and Michael Joseph Slyman with soliciting to
commit a felony, conspiring to pay someone to fight and other counts."
|
|
Read article...
|
|
High school grants illiteracy diploma
Halifax Daily News | Submitted by: Gorg
"Some of the class of 2009 won't be able to read the fine print on their
diplomas. The Nova Scotia government plans to introduce standardized literacy
tests for Grades 6, 9 and 12. Deputy Education Minister Dennis Cochrane said
some graduates will receive an "adjusted diploma" that alerts potential
employers about their short-comings. "They will graduate, but it will be a
diploma that will indicate they haven't met the literacy requirement."
|
|
Read article...
|
|
Boater adrift for four months, new fad diet
Los Angeles Times | Submitted by: The Great American Pickle
"He ate roasted turtle, tuna and a seagull and drank rainwater. And when
he was finally rescued by the U.S. Navy, all he wanted was help fixing his
broken mast and motor so he could sail on again. "I see nothing. Then one
day, I see a plane. I know I'm close to people. They tip their wings to say
hello. Two hours later, a ship comes to my boat. I am very, very happy."
|
|
Read article...
|
|
Enron's E sold for $44K
Wire Services | Submitted by: Soylent
"Jimmy Luu, sent by his boss at a Microcache Computer store in Houston
to buy the sign, said he was given explicit marching orders regarding the
five foot, stainless steel sign that once stood outside a downtown
satellite office. "He said, `Just do anything to get it,'" Luu told a
crush of reporters who surrounded him shortly after his bid was gaveled
out in a crowded southwest Houston hotel ballroom."
|
|
Read article...
|
|
|
|
|


About
Is a 2016 American science fiction action comedy film based on the Mirage Studios characters the Teenage Mutant Ninja Turtles, produced by Nickelodeon Movies and Platinum Dunes, and distributed by Paramount Pictures. It is the sixth film of the Teenage Mutant Ninja Turtles film series and sequel to the 2014 film Teenage Mutant Ninja Turtles. The film was directed by Dave Green, written by Josh Appelbaum and André Nemec, and stars Megan Fox, Stephen Amell, Will Arnett, Brian Tee, Tyler Perry, Brittany Ishibashi and Laura Linney, and featuring voices of Pete Ploszek, Alan Ritchson, Noel Fisher, Jeremy Howard, Tony Shalhoub, Gary Anthony Williams, Stephen "Sheamus" Farrelly and Brad Garrett.
Release
the film began on April 27, 2015, in New York City. It was released in theaters on June 3, 2016, in 3D, RealD 3D, 4DX, and in IMAX 3D, received generally mixedreviews from critics and grossed over $156 million.


Python API examples¶
This section lists a few examples in Python. These are the same files that can be found in the examples directory of the distribution, and show the basic usage of the Python API.
Example 1: First steps¶
This example shows how to
read an AMPL model
reassign values to parameters
solve the model
display the objective function value
Example 4: Get and set data through DataFrames¶
This example shows how to:
Use
amplpy.DataFrame
objects to assign values to sets and parametersUse an
amplpy.DataFrame
object to fetch and decouple values from a variable
Example 5: Operate with multidimensional data¶
This example shows how to:
Use a
amplpy.DataFrame
to assign values to multidimensional parameters
Example 6: Assign all data to a model and solve it¶
This example shows how to:
Assign all the data necessary to generate a model instance programmatically
Example 7: Build an efficient frontier¶
This example shows how to:
build an efficient frontier by repeteatly solve a portfolio problem in AMPL
Example 8: Simple heuristic¶
This example shows how to:
Do a simple heuristics for solving a QMIP problem, using the relaxed solution as a hint


The wise anchorite, an experienced analyst, sought refuge in his anchormanship, channeling his knowledge and wisdom to educate and enlighten those around him. [G|D]
As Aphrodite smiled down from her deific perch, the two lovers stood apart and anted up for the game of love, promising to be together forevermore. [G|D]
An archaicapathy had settled over the Appalachian mountains, leaving the residents with an overwhelming sense of desolation and neglect. [G|D]
It was an ascendant moment as the people celebrated their newfound ascendancy; they had reached the summit of their evolution through their collective ascension. [G|D]


release-history.json in the update center captures the history of every version of every Jenkins plugin ever released to the Jenkins update center.
The whole file is essentially an array of the following entry, which represents releases of plugins in a given day:
{ "releases" : [ { "gav" : "org.jvnet.hudson.plugins:build-timeout:1.1", "timestamp" :<PHONE_NUMBER>000, "version" : "1.1", "wiki" : "https://wiki.jenkins-ci.org/display/JENKINS/Build-timeout+Plugin", "title" : "Build-timeout Plugin" }, { "firstRelease" : true, "gav" : "org.jvnet.hudson.plugins:emma:1.0", "timestamp" :<PHONE_NUMBER>000, "version" : "1.0", "wiki" : "https://wiki.jenkins-ci.org/display/JENKINS/Emma+Plugin", "title" : "Emma Plugin" } ], "date" : "Nov 18, 2006" },
The 'timestamp' field is a number of milliseconds since the epoch.
The 'gav' field refers to the Maven groupId/artifactId/version triplet that identifies the Maven release that became the plugin. You can use GAV-Repository mapping to further tie this to the buildable source tree.