eve takes a list of event ids in binary format as input and generates a partition of event ids as a binary data stream, according to the parameters supplied. Events are "shuffled" by being assigned to processes one by one cyclically, rather than being distributed to processes in blocks, in the order they are input. This helps to even the workload by process, in case all the "big" events are together in the same range of the event list.
The output stream is a simple list of event_ids (4 byte integers).
Required parameters are;
Optional parameters are;
$ eve [parameters] > [output].bin
$ eve [parameters] | getmodel | gulcalc [parameters] > [stdout].bin
$ eve 1 2 > events1_2_shuffled.bin
$ eve -n 1 2 > events1_2_unshuffled.bin
$ eve -r 1 2 > events1_2_random.bin
$ eve 1 2 | getmodel | gulcalc -r -S100 -i - > gulcalc1_2.bin
In this example, the events from the file events.bin will be read into memory and the first half (partition 1 of 2) would be streamed out to binary file, or downstream to a single process calculation workflow.
The program requires an event binary. The file is picked up from the input sub-directory relative to where the program is invoked and has the following filename;
The data structure of events.bin is a simple list of event ids (4 byte integers).
getmodel generates a stream of effective damageability distributions (cdfs) from an input list of events. Specifically, it combines the probability distributions from the model files, footprint.bin and vulnerability.bin, to generate effective damageability cdfs for the subset of exposures contained in the items.bin file and converts them into a binary stream.
This is reference example of the class of programs which generates the damage distributions for an event set and streams them into memory. It is envisaged that model developers who wish to use the toolkit as a back-end calculator of their existing platforms can write their own version of getmodel, reading in their own source data and converting it into the standard output stream. As long as the standard input and output structures are adhered to, each program can be written in any language and read any input data.
| Byte 1 | Bytes 2-4 | Description |
|---|---|---|
| 0 | 1 | cdf stream |
None
$ [stdin component] | getmodel | [stout component]
$ [stdin component] | getmodel > [stdout].bin
$ getmodel < [stdin].bin > [stdout].bin
$ eve 1 1 | getmodel | gulcalc -r -S100 -i gulcalci.bin
$ eve 1 1 | getmodel > getmodel.bin
$ getmodel < events.bin > getmodel.bin
The program requires the footprint binary and index file for the model, the vulnerability binary model file, and the items file representing the user's exposures. The files are picked up from sub-directories relative to where the program is invoked, as follows;
The getmodel output stream is ordered by event and streamed out in blocks for each event.
The program filters the footprint binary file for all areaperil_id's which appear in the items file. This selects the event footprints that impact the exposures on the basis on their location. Similarly the program filters the vulnerability file for vulnerability_id's that appear in the items file. This selects conditional damage distributions which are relevant for the exposures.
The intensity distributions from the footprint file and conditional damage distributions from the vulnerability file are convolved for every combination of areaperil_id and vulnerability_id in the items file. The effective damage probabilities are calculated, for each damage bin, by summing the product of conditional damage probabilities with intensity probabilities for each event, areaperil, vulnerability combination across the intensity bins.
The resulting discrete probability distributions are converted into discrete cumulative distribution functions 'cdfs'. Finally, the damage bin mid-point from the damage bin dictionary ('interpolation' field) is read in as a new field in the cdf stream as 'bin_mean'. This field is the conditional mean damage for the bin and it is used to choose the interpolation method for random sampling and numerical integration calculations in the gulcalc component.
The gulcalc program performs Monte Carlo sampling of ground up loss by randomly sampling the cumulative probability of damage from the uniform distribution and generating damage factors by interpolation of the random numbers against the effective damage cdf. Other loss metrics are computed and assigned to special meaning sample index values as descibed below.
The sampling methodologies are linear interpolation, quadratic interpolation and point value sampling depending on the damage bin definitions in the input data.
Gulcalc also performs back-allocation of total coverage losses to the contributing subperil item losses (for multi-subperil models). This occurs when there are two or more items representing losses from different subperils to the same coverage, such as wind loss and storm surge loss, for example. In these cases, because the subperil losses are generated independently from each other it is possible to result in a total damage ratio greater than 1 for the coverage, or a total loss greated than the Total Insured Value "TIV". Back-allocation ensures that the total loss for a coverage cannot exceed the input TIV.
| Byte 1 | Bytes 2-4 | Description |
|---|---|---|
| 2 | 1 | loss stream |
Required parameters are;
The destination is either a filename or named pipe, or use - for standard output.
Optional parameters are;
$ [stdin component] | gulcalc [parameters] | [stout component]
$ [stdin component] | gulcalc [parameters]
$ gulcalc [parameters] < [stdin].bin
$ eve 1 1 | getmodel | gulcalc -R1000000 -S100 -a1 -i - | fmcalc > fmcalc.bin
$ eve 1 1 | getmodel | gulcalc -R1000000 -S100 -a1 -i - | summarycalc -i -1 summarycalc1.bin
$ eve 1 1 | getmodel | gulcalc -r -S100 -a1 -i gulcalci.bin
$ gulcalc -r -S100 -i -a1 gulcalci.bin < getmodel.bin
The program requires the damage bin dictionary binary for the static folder and the item and coverage binaries from the input folder. The files are found in the following locations relative to the working directory with the filenames;
If the user specifies -r as a parameter, then the program also picks up a random number file from the static directory. The filename is;
The stdin stream is a block of cdfs which are ordered by event_id, areaperil_id, vulnerability_id and bin_index ascending, from getmodel. The gulcalc program constructs a cdf for each item, based on matching the areaperil_id and vulnerability_id from the stdin and the item file.
Random samples are indexed using positive integers starting from 1, called the 'sidx', or sample index.
For each item cdf and for the number of samples specified, the program draws a uniformly distributed random number and uses it to sample ground up loss from the cdf using one of three methods, as follows;
For a given damage interval corresponding to a cumulative probability interval that each random number falls within;
An example of the three cases and methods is given below;
| bin_from | bin_to | bin_mean | Method used |
|---|---|---|---|
| 0.1 | 0.2 | 0.15 | Linear interpolation |
| 0.1 | 0.1 | 0.1 | Sample bin value |
| 0.1 | 0.2 | 0.14 | Quadratic interpolation |
If the -R parameter is used along with a specified number of random numbers then random numbers used for sampling are generated on the fly for each event and group of items which have a common group_id using the Mersenne twister psuedo random number generator (the default RNG of the C++ v11 compiler). These random numbers are not repeatable, unless a seed is also specified (-s{number}).
If the -r parameter is used, gulcalc reads a random number from the provided random number file, which produces repeatable results.
The default random number behaviour (no additional parameters) is to generate random numbers from a seed determined by a combination of the event_id and group_id, which produces repeatable results. See Random Numbers for more details.
Each sampled damage is multiplied by the item TIV, looked up from the coverage file.
Samples with negative indexes have special meanings as follows;
| sidx | description |
|---|---|
| -1 | Numerical integration mean |
| -2 | Numerical integration standard deviation |
| -3 | Impacted exposure |
| -4 | Chance of loss |
| -5 | Maximum loss |
The allocation method determines how item losses are adjusted when a coverage is subject to losses from multiple perils, because the total loss to a coverage from mutiple perils cannot exceed the input TIV. This situation is identified when multiple item_ids in the item file share the same coverage_id. The TIV is held in the coverages file against the coverage_id and the item_id TIV is looked up from its relationship to coverage_id in the item file.
The allocation methods are as follows;
| a | description |
|---|---|
| 0 | Pass losses through unadjusted (used for single peril models) |
| 1 | Sum the losses and cap them to the TIV. Back-allocate TIV to the contributing items in proportion to the unadjusted losses |
| 2 | Keep the maximum subperil loss and set the others to zero. Back-allocate equally when there are equal maximum losses |
The mean, impacted exposure and maximum loss special samples are also subject to these allocation rules. The impacted exposure value, sidx -3, is always back-allocated equally to the items, for allocation rules 1 and 2, since by definition it is the same value for all items related to the same coverage.
fmcalc is the reference implementation of the Oasis Financial Module. It applies policy terms and conditions to the ground up losses and produces loss sample output. It reads in the loss stream from either gulcalc or from another fmcalc and can be called recursively and apply several consecutive sets of policy terms and conditions.
| Byte 1 | Bytes 2-4 | Description |
|---|---|---|
| 2 | 1 | loss stream |
Optional parameters are;
$ [stdin component] | fmcalc [parameters] | [stout component]
$ [stdin component] | fmcalc [parameters] > [stdout].bin
$ fmcalc [parameters] < [stdin].bin > [stdout].bin
$ eve 1 1 | getmodel | gulcalc -r -S100 -a1 -i - | fmcalc -p direct -a2 | summarycalc -f -2 - | eltcalc > elt.csv
$ eve 1 1 | getmodel | gulcalc -r -S100 -a1 -i - | fmcalc -p direct -a1 > fmcalc.bin
$ fmcalc -p ri1 -a2 -S -n < gulcalci.bin > fmcalc.bin
$ fmcalc -p direct | fmcalc -p ri1 -n | fmcalc -p ri2 -n < gulcalci.bin > fm_ri2_net.bin
For the gulcalc item stream input, the program requires the item, coverage and fm input data files, which are Oasis abstract data objects that describe an insurance or reinsurance programme. This data is picked up from the following files relative to the working directory by default;
For loss stream input from either gulcalc or fmcalc, the program requires only the four fm input data files,
The location of the files can be changed by using the -p parameter followed by the path location relative to the present working directory. eg -p ri1
fmcalc passes the loss samples, including the numerical integration mean, sidx -1, and impacted exposure, sidx -3, through a set of financial calculations which are defined by the input files. The special samples -2, -4 and -5 are ignored and dropped in the output. For more information about the calculation see Financial Module
The purpose of summarycalc is firstly to aggregate the samples of loss to a level of interest for reporting, thereby reducing the volume of data in the stream. This is a generic first step which precedes all of the downstream output calculations. Secondly, it unifies the formats of the gulcalc and fmcalc streams, so that they are transformed into an identical stream type for downstream outputs. Finally, it can generate up to 10 summary level outputs in one go, creating multiple output streams or files.
The output is similar to the gulcalc or fmcalc input which are losses are by sample index and by event, but the ground up or (re)insurance loss input losses are grouped to an abstract level represented by a summary_id. The relationship between the input identifier and the summary_id are defined in cross reference files called gulsummaryxref and fmsummaryxref.
| Byte 1 | Bytes 2-4 | Description |
|---|---|---|
| 3 | 1 | summary stream |
The input stream should be identified explicitly as -i input from gulcalc or -f input from fmcalc.
summarycalc supports up to 10 concurrent outputs. This is achieved by explictly directing each output to a named pipe, file, or to standard output.
For each output stream, the following tuple of parameters must be specified for at least one summary set;
For example the following parameter choices are valid;
$ summarycalc -i -1 -
'outputs results for summaryset 1 to standard output
$ summarycalc -i -1 summarycalc1.bin
'outputs results for summaryset 1 to a file (or named pipe)
$ summarycalc -i -1 summarycalc1.bin -2 summarycalc2.bin
'outputs results for summaryset 1 and 2 to a file (or named pipe)
Note that the summaryset_id relates to a summaryset_id in the required input data file gulsummaryxref.bin or fmsummaryxref.bin for a gulcalc input stream or a fmcalc input stream, respectively, and represents a user specified summary reporting level. For example summaryset_id = 1 represents portfolio level, summaryset_id = 2 represents zipcode level and summaryset_id 3 represents site level.
$ [stdin component] | summarycalc [parameters] | [stdout component]
$ [stdin component] | summarycalc [parameters]
$ summarycalc [parameters] < [stdin].bin
$ eve 1 1 | getmodel | gulcalc -r -S100 -a1 -i - | summarycalc -i -1 - | eltcalc > eltcalc.csv
$ eve 1 1 | getmodel | gulcalc -r -S100 -a1 -i - | summarycalc -i -1 gulsummarycalc.bin
$ eve 1 1 | getmodel | gulcalc -r -S100 -a1 -i - | fmcalc | summarycalc -f -1 fmsummarycalc.bin
$ summarycalc -f -1 fmsummarycalc.bin < fmcalc.bin
The program requires the gulsummaryxref file for gulcalc input (-i option), or the fmsummaryxref file for fmcalc input (-f option). This data is picked up from the following files relative to the working directory;
summarycalc takes either ground up loss from gulcalc or financial loss samples from fmcalc as input and aggregates them to a user-defined summary reporting level. The output is similar to the input, individual losses by sample index and by event, but the ground up or financial losses are summed to an abstract level represented by a summary_id. The relationship between the input identifier, item_id for gulcalc or output_id for fmcalc, and the summary_id are defined in the input files.
The special samples are computed as follows;


Back to index
This returns all prime numbers up to this limit.
Setting the upper limit too high can result in a browser crash. Try to keep it under 10 million.


'Just withdraw' - Liverpool fans react to latest Aston Villa decision
Aston Villa latest news | Dean Smith’s side will play their Carabao Cup quarter-final against Liverpool at Villa Park just 24 hours before the Reds are in Club World Cup action in Qatar
by Jonny BonellAston Villa’s Carabao Cup quarter-final with Liverpool will take place on Tuesday, December 17 (7.45pm).
Uncertainty had surrounded the last-eight clash due to the Reds’ involvement in the club World Cup during December.
Jurgen Klopp’s side play in the semi-final a day after the scheduled quarter-final against Villa, and Liverpool today (Tuesday) confirmed their intention to play one team at Villa Park and another 24 hours later in Qatar.
“As a result, we will be utilising two playing squads simultaneously, with one squad participating in the FIFA Club World Cup in Qatar and another in the Carabao Cup,” a Liverpool statement read.
Here’s what the Liverpool fans have made of the decision.
@Luke_Chidlow4: We’re definitely playing a youth team in the quarter final.
@SamueILFC: Can’t wait to beat Aston Villa with our under 18’s and Andy Lonergan.
@LFCAaron_: Joke.
@rauidri: Punished for being successful.
@zerscna: So we’re actually splitting the team wow.
@socallfc: Would be a great statement if we just withdraw lol.
@ijc: Laughable. Field an under 18's. Exactly the reason why no-one cares about this tin pot cup anymore. This is a joke.
Aston Villa latest
This is your round up of all things Villa; the one-stop shop that will keep you updated on the latest goings on at the club and beyond.
Transfers, injuries, match-days and managers, we’ve got you covered.
We’ll be bringing the very latest on the Villains throughout the week and around the clock.
Make sure you keep yourself updated with our handy daily catch up...
Must reads...
- John McGinn's brilliant Liverpool verdict
- James Milner makes Aston Villa transfer admission
- Fans split on Villa transfer target
- Referee confirmed for Wolves v Villa - and fans won't like it
For all your latest AVFC news, opinion, analysis and transfer gossip, click here
You can follow our Villa reporter Ashley Preece on Twitter, and his email address is<EMAIL_ADDRESS>@maulty1983: This is a joke. The fact we have to do this says it all about the amount of fixtures we have in December.
 Happy to play in nets at Villa Park if we're short.


The Ambience Project
Ambience is a room environment controller.
The project mainly intends to create a LED light controller, with the user interface being a smartphone application. Project evolution includes automation of power outlets, which may be used to control fans, heaters and other utilities.
Overview
The project contains three parts with their respective repositories:
Functionalities
Current implementation allows to choose color and light intensity for the RGB LED strip.
Future work
Future functionalities include:
- Set up timers for turning the light on and off
- Add external relay board control on Android and python applications
- Implement some method of authentication should be implemented to avoid agents other than the Ambience Android application to send commands.


{envelope-decay-cluster.png width=373}
This contains a {Envelope_decay_time time} {_slider} to set the time it takes for the envelope to drop toward zero once it has completed its attack phase. Since it slows down as it approaches zero, and theoretically never gets there, this is actually the "time constant", indicating how long it would have taken to get to zero if it didn't slow down. The {_default_value} is infinity, for a note that lasts as long as the key is held.
This also includes two modulation inputs. The {Envelope_decay_self_mod self mod} slider determines how much the decay time is affected by its own value. When set to a negative value, it causes the initial decay to be sped up; setting it to a large negative value yields a very short initial spike and a long tail, but the lower the envelope amplitude, the less of a spike.
The {Envelope_decay_mod_select mod select} {_button buttons} and {Envelope_decay_mod_depth mod depth} {_slider} allow the decay time to be modulated by either {_lever} or {_pedal}, the note pitch, the {_velocity}, or the optional pressure sensor. Positive modulation increases the decay time, negative modulation decreases it.


Laporin Aja is a web that contains response services regarding information on loss and damage reports to facilities on the ITERA campus. This website contains a feature that can report ITERA activists' responses about the facilities and report the discovery or loss of items. Another feature of this website is the presence of Live Chat which can be used to report missing items or damage to facilities which will be immediately responded by the admin. Furthermore, the admin will respond by immediately following up the report by giving an announcement on the website or reporting to the authorities at ITERA.
Team :


Bamboo Law Group is a law firm based in Seattle, WA, but we help clients from all over the world in a wide variety of services and industries. We love working with individuals, small businesses, and startups. We have experience working with clients in the video game industry, like game developers, streamers/youtubers, and professional eSports atheletes.
It is our goal to deliver high quality, effective legal advice and solutions to our clients, and to provide our services at affordable prices. We can tailor our services in a way that fits your business strategy and helps you stay on budget.
Check out our about page to learn more about our firm and our attorney.
What We Can Do For You
Bamboo Law Group offers legal advice and solutions in several different areas of law to clients all over the world.
- Contracts
- Business Formation
- Employment Law
- General Counsel Services
- Game Developers
- eSports Atheletes and Teams
- Web Designers and Web Developers
- Startups
- Small Businesses
Head over to our services or industries pages to learn more about what we offer and how we can help, or contact us for a free consultation.


{{extend 'zlayout.html'}}
It appears that you have just finished installing pyForum for the first time, this page contains important information that you should read carefully. This page will not be shown again under normal circumstances, unless you decide to wipe-out the database containing this information.
Users:
A New user has been created in the system, this user automatically has the 'zAdministrator' role, the highest role any user can have in the system, this user has administrative privileges on the system, please write down the user information below and use it to access the system:
Username: {{=tmp_username}}
Password: {{=tmp_passwd}}
Please log in with the user's credentials above and immediately change the password to your choice, you will need this user to give other users access to the system, or perform administrative tasks in the system, once you create your own account in the system, you can use this user to grant your own account SysAdmin privileges, and then you may remove this username from the system permanently.
In addition, several other storage tables have been automatically populated for this system to function properly.


Preparation time
less than 30 mins
Cooking time
over 2 hours
Serves
Serves 4
Fennel and tomatoes are gently served with wine, herbs and garlic and then topped with pan-fried sea bass. A tasty combination of classic Mediterranean ingredients.
Preheat the oven to 170C/325F/Gas 3.
Slash the skin of the sea bass fillets and place in the fridge.
Cut the fennel lengthways into quarters. Heat the olive oil in a heavy-based ovenproof pan and add the fennel. Cook the fennel over a medium heat, turning frequently, for 20 minutes or until starting to brown.
Add the tomatoes, garlic, boiling water, wine, oregano and some black pepper. Bring to the boil, cover and cook in the oven for 1½ hours.
Remove the pan from the oven and add the olives, balsamic vinegar and basil leaves. Place on a low heat, season and simmer gently.
Take the sea bass from the fridge, rub the surface with the olive oil and season with salt and pepper. Heat a large frying pan. Add the sea bass fillets, skin side down and cook for 3-4 minutes until the skin is crisp. Turn the fillets over and cook for a further minute or until the fish is just cooked through.
Place a spoonful of the fennel and tomatoes into the centre of each plate and top each with a piece of sea bass.


you have just logged out
Username
$(username)
IP Address
$(ip)
MAC Address
$(mac)
Session Time
$(uptime)
$(if session-time-left)
Time Left
$(session-time-left)
$(endif)
bytes up/down
$(bytes-in-nice) / $(bytes-out-nice)
LOGIN


Under The Sun is a cover band from Columbia, South Carolina. As their name rightly suggests, Under The Sun plays a variety of genres. Whether you like country, classic rock, 90’s rock, or pop, this band has something for you.  The band is comprised of members Liz Johnson (vocals), Ryan Johnson (drums), Andy Johnson (sound and lights), Russ McKissick (guitar), Alex Roberts (bass and vocals), and Addie Padula (keyboard, synth, and vocals).


class: middle, center ![ferris](public/img/ferris.png) # a very brief intro to rust --- class: middle, left ## links - web: https://ghotiphud.github.io/a-very-brief-intro-to-rust/#1 - github: https://github.com/ashleygwilliams/a-very-brief-intro-to-rust - fork: https://github.com/ghotiphud/a-very-brief-intro-to-rust ### PRs and issues welcome! made by [@ag_dubs](https://twitter.com/ag_dubs) who is, at best, an advanced beginner in Rust --- class: middle, left ## Quickly - Why Rust? ### Systems Programming #### Limited Resources (Memory, CPU, Time, Latency) Happens in most languages/projects eventually. What are your options? - Manage resources better - Thinking about memory management - Sometimes fighting language/design - Redesign (large undertaking) - Unsafe lower-level langs (C/C++) - Segfaults/Unreliable code - Exploits (Security issues) --- class: middle, left ## Rust ### Hack without fear! Compiler's got your back. ```rust extern crate rayon; fn load_images(paths: &[PathBuf]) -> Vec
{ paths.iter() // par_iter() .map(|path| { Image::load(path) }) .collect(); } ``` --- class: middle, left ### Concurrency Bug ```rust extern crate rayon; fn load_images(paths: &[PathBuf]) -> Vec
{ let mut jpegs = 0; paths.par_iter() .map(|path| { if path.ends_with("jpeg") { jpegs += 1; } Image::load(path) }) .collect(); } ``` No Data-Races! Replace with AtomicU32 or Mutex. --- class: middle, left ### Motivating Examples: - http://blog.skylight.io/introducing-helix/ - https://www.wired.com/2016/03/epic-story-dropboxs-exodus-amazon-cloud-empire/ - Why? - (https://news.ycombinator.com/item?id=11283230) - In Depth: https://blogs.dropbox.com/tech/2016/05/inside-the-magic-pocket/ - Another Dropbox thing: https://blogs.dropbox.com/tech/2016/06/lossless-compression-with-brotli/ - http://www.agildata.com/building-scalable-mysql-proxy-rust/ --- class: middle, left ## Ruby String.blank? ```ruby class String # A string is blank if it's empty or contains whitespaces only: # # ''.blank? # => true # ' '.blank? # => true # "\t\n\r".blank? # => true # ' blah '.blank? # => false # # Unicode whitespace is supported: # # "\u00a0".blank? # => true # def blank? /\A[[:space:]]*\z/ === self end end ``` --- class: middle, left ## https://github.com/SamSaffron/fast_blank .long-code[ ```c static VALUE rb_str_blank(VALUE str) { rb_encoding *enc; char *s, *e; enc = STR_ENC_GET(str); s = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) == 0) return Qtrue; e = RSTRING_END(str); while (s < e) { int n; unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc); switch (cc) { case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0x20: case 0x85: case 0xa0: case 0x1680: case 0x2000: case 0x2001: case 0x2002: case 0x2003: case 0x2004: case 0x2005: case 0x2006: case 0x2007: case 0x2008: case 0x2009: case 0x200a: case 0x2028: case 0x2029: case 0x202f: case 0x205f: case 0x3000: /* found */ break; default: return Qfalse; } s += n; } return Qtrue; } ``` ] --- class: middle, left ## Fast_blank in Rust ```rust pub extern "C" fn fast_blank(buf: Buf) -> bool { buf.as_slice().chars().all(|c| c.is_whitespace()) } ``` ``` =========== Test String Length: 6 =========== Rust 11.043M (± 3.5%) i/s - 54.744M C 10.583M (± 8.5%) i/s - 52.464M Ruby 964.469k (±27.6%) i/s - 4.390M ``` *Boilerplate Omitted* We'll circle back in a bit. --- class: middle, left ## C-like Performance ![MySQL proxy performance](public/img/xBenchmark-TPC-C_Cloud.png) MySQL proxy developed over a few weeks vs official C++ proxy --- class: middle, left ## C-like Performance ![MiniHttp](public/img/minihttp-bench-pipelined.png) Not guaranteed fastest, but definitely up there. --- class: middle, left ### This guide is an intro to Rust syntax. It doesn't touch on concepts at all. ### Concepts are more important, but sometimes you need a little boost to get to a point where the concepts make sense. ### This is that boost. --- class: middle, left ## install rust The best way to install Rust is with [rustup](https://www.rustup.rs/). rustup is a Rust version manager. To install it: Prereq: [Microsoft Visual C++ Build Tools 2015](https://www.visualstudio.com/downloads/) (Visual Studio install option) ``` Run rustup-init.exe... Choose toolchain x86_64-pc-windows-msvc ``` To keep your rust up-to-date with the latest stable version of rust, type: ``` rustup update ``` To check which version of Rust you have type: ``` rustc -- version ``` --- class: middle, left ## setting up a project There are many ways to setup a project in Rust, but this is the simplest. 1. Create a repository on Github 2. Clone the repository 3. `cd` into the repository directory 4. Type `cargo init .` * Use `--bin` if you are not writing a library This will create several files and folders for you automatically: - `Cargo.toml`: metadata about your project and its dependencies - `.gitignore`: ignores compiled files built by Rust - `src/lib.rs` or `src/main.rs`: where your Rust code goes --- class: middle, left ## setting up a project #### `lib.rs` vs `main.rs` There are 2 main types of projects you can make in Rust: a library and not a library. If you are writing a
library
, it means you intend for your code to be used in someone else's application as a crate or module. If you want to do this, you should use a `lib.rs`. If you are writing a
not library
, it means that you'd like to write code that compiles into a binary that someone can run. If you want to do this, you need to use a `main.rs`. Inside the `main.rs` you should have a `main` function that looks like this: ```rust fn main() { // your app code goes here } ``` --- class: middle, left ## cargo Cargo is a tool that helps you develop Rust. It does several things: - Runs tasks: `cargo build` (compile your app), `cargo test` (test your app), `cargo run` (run your app) - Start a project: `cargo new`, `cargo init` Cargo is also the package manager for Rust. This means that you can use Cargo to install and manage bits of other people's code. - A package in Rust is called a Crate. - You can find Crates on http://crates.io - You list the Crates you want to use in the `Cargo.toml` file - You app keeps track of what crates you are using in the `Cargo.lock` file --- class: middle, left ## storing values To get started using Rust you'll probably want to assign values so that you can use them. To do this in Rust: ``` let name = "ashley"; let age = 30; ``` If you want to make a constant, you must specify a type: ``` const FAVENUM: u32 = 6; ``` --- class: middle, left ## types There are a lot of types, but just to get you started: - `u32`: unsigned 32-bit integer - `i32`: signed 32-bit integer - `String` and/or `&str`: more on these below - `bool`: a boolean --- class: middle, left ## dealing with strings Strings in Rust are a lot more complicated than you might be used to if you are coming from another language, in particular, interpreted languages like Ruby or JavaScript. Here's some key points: #### `&str` and `String` - "my string" is not a `String`. It's a `str`. the difference between a `String` and a `str` is how they are allocated. Don't worry about that right now. - Pretty much always use `str` with an `&`, as `&str`. - You can turn a `&str` into a `String` by using `to_string()` or `String::from()`. You want to do this because `String` has a ton of awesome convenience methods. --- class: middle, left ## concatenation - add a `&str` to a `String` using `push_str()` ```rust let mut realstring = String::from("hello "); let str1 = "world!"; realstring.push_str(str1); println!("{}", realstring); ``` - add `&str`s using `format!` ```rust let str1 = "hello "; let str2 = "world!"; let message = format!("{}{}", str1, str2); ``` --- class: middle, left ## characters - a `char` is a different type than a `str` or `String`. `char` always uses single quotes. - to get a `String`'s `char`s you can call `chars()` - you might find that instead of `chars()` you really want `as_bytes()` but if you aren't sure don't sweat it rn Example: ```rust let letters = String::from("ashley").chars(); for l in letters { // do something cool with characters } ``` --- class: middle, left ## macros Macros are an interesting part of Rust. You know something is a macro if its name has a `!`. The least technical way to describe the cool thing about macros is that they kinda get compiled twice. Don't worry if that doesn't make any sense. - `println!` is the equivalent of `console.log` or `puts`. It prints printable things to standard output, which is usually just the console. ```rust println!("i get printed on the screen"); println!("hello {}!", "world"); ``` - `format!` is also a macro. We talked about it before as a way to concatenate `str`s. ```rust format!("my dogs are named: {} and {}", "cheeto", "frito"); ``` --- class: middle, left ## https://github.com/rustbridge/helix ```rust #[macro_use] extern crate helix; declare_types! { reopen class RubyString { def is_blank(self) -> bool { self.chars().all(|c| c.is_whitespace()) } } } ``` --- class: middle, left ## function signatures ```rust pub fn say_hello(name: &str) -> &str { let message = format!("hello, {}!", name); message } ``` - put `pub` at the beginning if you want the function to be accessible outside the file as in a module or crate - the keyword `fn` is how we know it is a function - list parameters inside the parens in the style `parameter_name: Type`, separate by commas - use the `->` to say what type the function returns - return a value from the last line of a function by omitting the semicolon - return early in a function using the `return` keyword --- class: middle, left ## `match` syntax Rust has pattern matching and it's great! ```rust match animal { "cat" => "Meow", "dog" => "Woof", _ => "
", // trailing comma! } ``` - `_` is used as a catch-all for anything that doesn't match - `match` supports trailing commas, and it's best practice to use them :) --- class: middle, left ## the `Option` type Rust doesn't have `nil`/`null` so if you want to express that something might return something or nothing, you need to use the `Option` type. To write the `Option` type, write the word `Option`, followed by angle brackets with a Type inside, e.g. `Option
`. For example, if a parameter is optional you'd write: ```rust fn greeting(name: Option<&str>) -> &str { let who = match name { Some(n) => n, None => "World", }; format!("Hello, {}!", who) } greeting(Some("ashley")); // "Hello, ashley!" greeting(None); // "Hello, World!" ``` --- class: middle, left ## the `Result` type `Result` is kind of like `Option` except instead of something or nothing, you expect something that is Ok (`Ok()`) or an error (`Err()`). To write the `Result` type, write the word `Result`, follow by angle brackets with a Type and an Error Type inside, e.g. `Result
`. For example: ```rust fn parse_name(name: Option<&str>) -> Result<&str, &'static str> { match name { Some(n) => Ok(n), None => Err("You must provide a name."), } } ``` --- class: middle, left ## testing Rust has unit testing built in! You can write tests in their own file or right inline with your code. To designate a test write `#[test]` above a code block with asserts: ```rust fn say_hello(name: &str) -> &str { let who = match name { Some(n) => n, None => "World", }; format!("Hello, {}!", who) } #[test] fn it_should_say_hello() { assert_eq!(say_hello(None), "Hello, World!"); assert_ne!(say_hello(Some("ashley")), "Hello, World!"); assert_eq!(say_hello(Some("ashley")), "Hello, ashley!"); } ``` --- class: middle, left ## good resources - The Rust Docs, https://doc.rust-lang.org/ - The Rust Book, https://doc.rust-lang.org/book/ - `into_rust` Screencasts, http://intorust.com/ - The Rust Playground, https://play.rust-lang.org/ - Alternate Playground with popular crates, http://play.integer32.com/ - Rust by Example, http://rustbyexample.com/ - Rust on exercism.io, http://exercism.io/languages/rust - New Rustacean Podcast, http://www.newrustacean.com/ --- class: middle, center ![ferris](public/img/ferris.png) # go forth and write some Rust!


What to buy
Don't forget to buy this stuff.
A tin of beans
Cheese
Milk
This paragraph has the special class
So does this headline


GOV.UK Pay - Sandbox: Successful Payment [Reference number]
Thank you for your recent payment for GOV.UK Pay - Sandbox
Your payment summary:
Reference: [Reference number]
Date of payment: [Date]
Payment for: [Payment description detail]
Total amount: [Amount]
*Optional custom paragraph - add this below*
From GOV.UK Pay - Sandbox
This is an automatically generated email, please do not reply.
The optional custom paragraph should give users extra information related to your service.


--
min
--
max
--
--
---
- ---
- ----
- ----
- ----
Covid-19 Info
----
Sick Now:
Today Cases:
Recovered Today:
Died Today:
Total Cases:


CMPDRP is a simple way to view website design comps in a desktop browser.  Images are aligned to the top of the window and horizontally centered (horizontal scrolling is disabled) because that's how I need it right now.
Note: You are viewing files on your own machine. Files are NOT uploaded to any server. No one else can see what you are seeing (unless they are standing behind you).
| Key | Action |
|---|---|
| ? | Help (this menu) |
| J | Previous image |
| K | Next image |
| I | List of images |
| T | Toggle list / thumbnail view |
| R | Reset |


From the code that sent Apollo 11 to the moon, to an open source curriculum that helps nonprofits—you shared and built lots of amazing things over the past year. Here are the most starred open source repositories on GitHub, showing which repos users starred in common.
The most commonly used open source licenses on GitHub are MIT, Apache-2.0, and GNU General Public License v3.0.
In total, GitHub is home to open source projects written in 316 unique programming languages. Here are the most popular by number of pull requests in the last twelve months.
Standouts include JavaScript, C#, and Go who have seen almost doubled growth. Swift and TypeScript are up and coming with 3.5x growth.
There was a lot of public activity on GitHub over the last 12 months. To give you the full picture, here are the totals and stories of active users, repositories, organizations, and active issues in public projects on GitHub. Active means there was some activity within the last year, e.g. code commited, a comment created, a repository starred, or an issue opened. The queries and data that power these open source metrics are available to everyone, thanks to our partnership with Google BigQuery.
Like @acabunoc, Lead Developer for Open Source Engagement at the Mozilla Foundation who is developing new ways to engage contributors on open source projects.
Like the Dat project who are working openly to develop a peer to peer tool for distributing datasets in science, journalism and government.
Like the Federal Source Code Policy on GitHub released by The White House, who this year solicited community feedback on GitHub.
Like this one opened in the Go programming language repo that used open source data on Google’s BiqQuery to help decide whether to add new functionality to a Go standard library.
Here are some of the most active Organizations and well-loved projects by the number of unique contributors (users who pushed code, opened or commented on an issue or PR), unique code reviewers (users who commented on the changed files), and most forks.
Earlier this year we released Reactions and it seems like you’ve given them an overwhelming
This one made us chuckle—here is the issue with most laugh reactions: chrislgarry/Apollo-11#3
Over the past year, GitHub partnered with, held, and sponsored events all over the world. At Patchworks we watched new developers learn how to use Git. Our ConnectHome partnership provided low-cost internet access for families living in HUD-assisted housing. Sponsoring events like Rails Girls and hosting our own conferences allowed us to meet more GitHub users than ever before.
We loved meeting you. We invite you to follow along and join us for a future event.
This year GitHub grew by more than 5.2 million users and 303K organizations. We have more new students, developers, and businesses using GitHub than ever before.
Like this pull request opened by @dawnpaladin. After being connected with Pybee’s Batavia project through the amazing Twitter account @yourfirstpr, @dawnpaladin found some failing tests in the project. Project maintainer @freakboy3742 took the time to discuss the problem and walk him through submitting his first PR, and the issue was solved.
Like this Comic Book Search Engine repo created by @katana171. She was one of our Patchwork Toronto attendees, and even though she was new to GitHub, she jumped in with both feet, and wasted no time building a useful and fun project that anyone can contribute to.
Like current student @NickTikhonov, a GitHub Campus Expert and summer intern from the University of St Andrews in Scotland, who created the Sourcerer Atom plugin as a tool to teach his classmates about JavaScript and web APIs.
With almost 80M total Pull Requests on GitHub, we know that 85% of all requests for change come from within organizations.
Alongside businesses using Organizations, the largest companies on planet Earth are adopting the GitHub workflow using GitHub Enterprise.
It’s not just technology companies either—from retailers to healthcare and financial services companies—GitHub Enterprise provides the security and easy management these types of businesses require with the same GitHub experience developers love.
From chat applications to continuous integration services and project management tools, teams are integrating their favorite development tools with GitHub. Here are the top GitHub integrations that helped you and your team work better this past year.


Does It Exist
Wooh! Existence. Simple enough.
While working with data in Excel, often, we question “Does this value(s) exist within a data set?”. Below, I’ve outlined a couple of methods to answer this question.
VLOOKUP or MATCH
My go-to function was =VLOOKUP(cell,single_column,1,0)
. If the value exists, it simply returns itself, else #N/A, which means that the value doesn’t exist.
MATCH will yield the same result, albeit, if the value exists, the function will return the row number of the found value.
COUNTIF
EXCELJET uses =COUNTIF(range, cell) > 0
. This method counts the number of times a value exists within a given range. COUNTIF
has the added ability to check across multiple columns.
UDF - User Defined Function Using VBA
Because I was constantly checking if one dataset existed within another, I wrote a User Defined Function in VBA. Checkout the 18 lines of code below! I’ve commented a good bit to help explain what the code is doing.
The idea is that returning TRUE or FALSE won’t always clearly explain what’s going on in the data. Using the optional TRUE_MATCH or FALSE_MATCH string variables will help in that aspect.
As an illustration, column E and F contain World Cup finalists up to 2014. The task is to find out if countries listed in column H have ever been finalists.
Simply typing =EXISTSIN(cell,range)
will yield standard TRUE and FALSE outputs. Alternatively, by entering a different TRUE or FALSE default, the analysis becomes clear to the reader.
=EXISTSIN(cell, range, "Finalist", "Not a Finalist")
makes clear who was and who wasn’t in a final match.
VBA Source Code for the EXISTSIN Function
Function EXISTSIN(ByVal CELL As Range, ByVal LOOK_IN_RANGE As Range, Optional ByVal TRUE_MATCH As String, Optional ByVal FALSE_MATCH As String)
'Declaring variables
Dim Exists As Boolean
'using the CountIf function, EXISTSIN can look across multiple columns.
'if CountIf is greater than 0, it sets the Exists variable to TRUE.
'if CountIf is 0, it sets the Exists variable to FALSE.
Exists = Application.CountIf(LOOK_IN_RANGE, CELL.Value) > 0
Select Case Exists
'1. here, the function checks if variable Exists is set to TRUE or FALSE,
'2. it checks whether or not the user is using the optional TRUE_MATCH or FALSE_MATCH strings
'and define the output of EXISTSIN depending on 1 and 2.
Case True
If TRUE_MATCH = "" Then'checking to see if TRUE_MATCH is blank
EXISTSIN = Exists 'if TRUE_MATCH is blank, simply return TRUE
Else
EXISTSIN = TRUE_MATCH 'if TRUE_MATCH isn't blank, then return what the user entered.
End If
Case False
If FALSE_MATCH = "" Then 'checking to see if FALSE_MATCH is blank
EXISTSIN = Exists 'if FALSE_MATCH is blank, simply return FALSE
Else
EXISTSIN = FALSE_MATCH 'if FALSE_MATCH isn't blank, then return what the user entered.
End If
End Select
End Function


Jeremy Vine sorry for cannabis mix up during interview with Scotland's oldest bagpiper
The Radio 2 presenter told Billy McVie, 93, he had "plenty of puff" to spare if the musician ran out.
by Alex GreenJeremy Vine has apologised after giving some people the impression he was offering Scotland's oldest bagpipe player a "shedload" of cannabis.
The presenter, 54, made the gaffe on BBC Radio 2 during a live broadcast from Glasgow on Monday.
Vine told Billy McVie, 93, that he had "plenty of puff" to spare if the musician happened to run out during his time on the show.
Vine later apologised after being made aware that his comments could be interpreted as meaning "I've got a shedload of ganja".
He said on Twitter: "I apologise for the phrase I used earlier on the radio.
"While interviewing Scotland's oldest bagpiper, Billy McVie, 93, I told him: "I have got plenty of puff if you run out.
"I now understand that means 'I've got a shedload of ganja if you've smoked all yours'."
Mr McVie gave Vine a tutorial in playing the great Highland bagpipe, as well as a lesson in the instrument's history.
Referring to his guest as Bob, Vine told listeners: "Bob is on a mission to convince us that the bagpipe is capable of producing the most melodic and beautiful music and that it has unfairly been described as discordant and screechy.
"The joy of having you here is that we can cleanse our minds of all the election talk now.
"We don't have to do any politics. Do we? You don't need to say anything about politics here."
Earlier in the programme, a General Election special, Vine discussed Glasgow's "international reputation" for "the scourge of drugs" and spoke to a former heroin addict helping others in the city to fight addiction.


LANGUAGE (EN)
ENGLISH (EN)
FRENCH (FR)
SPANISH (SPN)
CURRENCY (USD)
USD
EURO
POUND
CREATE ACCOUNT
LOG IN
LANGUAGE (EN)
ENGLISH (EN)
FRENCH (FR)
SPANISH (SPN)
CURRENCY (USD)
USD
EURO
POUND
LOG IN
CREATE ACCOUNT
PAGES
PROMOTIONS
PRODUCTS
SUNGLASSES
ARMANI
ARNETTE
COACH
DKNY
MICHAEL KORS
OAKLEY
RAY-BAN
BAGS
JEWELLERY
CLOTHES
Zirou Fashion
PAGES
PROMOTIONS
PRODUCTS
SUNGLASSES
ARMANI
ARNETTE
COACH
New
DKNY
MICHAEL KORS
OAKLEY
RAY-BAN
BAGS
CHANEL 2.55
COACH
DOLCE & GABBANA
DKNY
GUCCI
New
MICHAEL KORS
PRADA
JEWELLERY
ANNA HU
BEC ASTLEY CLARKE
CHARLES HORNER
ELIZABETH GAGE
JOSEPH MAYER
New
SUDHA PENNATHUR
UGO CORREANI
CLOTHES
3
3
SUNGLASSES
2 x $170.00
BAG
1 x $650.00
BAG
5 x $825.00
SUBTOTAL
$1645.00
View Cart
Checkout
NEW COLLECTION
JUST ARRIVED
Shop Now
Shop Now
NEW COLLECTION
JUST ARRIVED
Shop Now
Shop Now
NEW COLLECTION
JUST ARRIVED
Shop Now
Shop Now
NEW COLLECTION
JUST ARRIVED
Shop Now
Shop Now
FEATURED PRODUCTS
|
ADD TO CART
BLACK
$825.00
LEATHER
BAGS
Add to wishlist
|
ADD TO CART
BROWN
$275.00
CANVAS
BAGS
Add to wishlist
|
ADD TO CART
BLACK
$650.00
LEATHER
BAGS
Add to wishlist
|
ADD TO CART
TAN
$925.00
LEATHER
BAGS
Add to wishlist
|
ADD TO CART
BLACK
$750.00
LEATHER
BAGS
Add to wishlist
JEWELLERY COLLECTION
|
ADD TO CART
SILVER
$370.00
MEDIUM
JEWELLERY
Add to wishlist
|
ADD TO CART
SILVER
$450.00
SMALL
JEWELLERY
Add to wishlist
|
ADD TO CART
SILVER
$185.00
SMALL
JEWELLERY
Add to wishlist
|
ADD TO CART
GREEN
$3500.00
DIAMONDS
JEWELLERY
Add to wishlist
|
ADD TO CART
GREEN
$2700.00
DIAMONDS
JEWELLERY
Add to wishlist
DELIVERY
Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum tortor quam, feugiat vitae, ultricies eget, tempor sit amet, ante.
Read more
SUPPORT
Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum tortor quam, feugiat vitae, ultricies eget, tempor sit amet, ante.
Read more
RETURNS
Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum tortor quam, feugiat vitae, ultricies eget, tempor sit amet, ante.


Four childhood friends, united by secrets, are caught in the quarantine zone when something crashes into the remote forests of Maine; and the question becomes who will avoid being eaten alive by alien fungi, torn from the inside by alien ferrets, possessed by alien minds or menaced by a psychotic military commander to whom ruthlessness has become a macho ego trip?
The Earth is in peril as well, needless to say, but most of our attention is taken up with a few men caught on the edge, and where the most important thing in the world turns out to be the fact that four small boys saved a fifth from a beating.
To say that Beaver's marriage didn't work would be like saying that the launch of the Challenger space shuttle went a little bit wrong.


With 2+ years of experience in front end development and studying at SkillCrush, I am ready to bring a diverse and growing skillset to develop high-functioning, user-friendly interfaces and websites using multiple programming languages, testing, debugging, and most importantly, teamwork. My goal is to join the tech field as a Full-Stack Web Developer, with specialization in ReactJS and Python.
ABOUT ME
SKILLS
- HTML5
- CSS3
- GitBash/GitHub
- Responsive Web Dev
- JavaScript/APIs
- ReactJS
- Python
- Ruby
PROJECTS
Unplugged
A fully responsive website featuring a getaway for the modern company!
Guess the Word
JavaScript/APIs: Can you guess the word in 8 tries or less?
Github Repo Gallery
JavaScript/APIs: A custom showcase of my github repos.
Hotel Booking UI
ReactJS: A stateful app which simulates hotel room filtering.
Sticky Notes
ReactJS: A stateful app which enables the user to add, delete, edit, and search their notes!


Loading Model...
Add an Example to Class "Hello"
0 "Hello" examples
0 "Goodbye" examples
Start predicting! Clear all classes
KNN Classifier with mobileNet model labeled this as Class: ... with a confidence of ...


Namespace SudokuSpice.RuleBased.Rules
Classes
BoxUniquenessRule
Restricts that each 'box' contains all unique values.
ColumnUniquenessRule
Restricts that each column contains all unique values.
DiagonalUniquenessRule
Restricts that the forward and backward diagonals each contain all unique values.
MagicSquaresRule
Enforces a rule that certain regions in a puzzle must be magic squares, i.e. the sums of the values in each of their rows, columns, and (optionally) their diagonals add up to the same value.
Note that this does not enforce uniqueness of values within the magic square as a whole. It does, however, prevent value duplication within each row, column, and/or diagonal. This can be combined with other rules if you need proper row, column, box, and/or diagonal uniqueness.
MaxCountPerBoxRule
Restricts that each box contains a max count of each value, as specified by the CountPerUniqueValue dictionary.
MaxCountPerColumnRule
Restricts that each column contains a max count of each value, as specified by the CountPerUniqueValue dictionary.
MaxCountPerRowRule
Restricts that each row contains a max count of each value, as specified by the CountPerUniqueValue dictionary.
MaxCountRule
Simplifies the logic needed to implement a "max-count" rule, such as "each row must contain n copies of value m." In this case, the count n can vary for each value m.
RowUniquenessRule
Restricts that each row contains all unique values.
StandardRules
Combines the standard rules (row, column, and box uniqueness) for efficiency and convenience.
UniquenessRule
Simplifies the logic needed to implement a uniqueness rule, such as "all values in a row must be unique."
Interfaces
IMissingBoxValuesTracker
Tracks all the required unset values for a given box in the Puzzle.
IMissingColumnValuesTracker
Tracks all the required unset values for a given column in the Puzzle.
IMissingRowValuesTracker
Tracks all the required unset values for a given row in the Puzzle.
IRule
Enforces a rule for a puzzle, such as "all values must be unique within a row." This is done by tracking possible values for each square specifically as determined by this rule. These possible values are then enforced along with any other rules by an IRuleKeeper.


{% extends "horizon/common/_modal_form.html" %} {% load i18n %} {% load url from future %} {% block form_id %}create_network_form{% endblock %} {% block form_action %}{% url 'horizon:admin:networks:create' %}{% endblock %} {% block modal_id %}create_network_modal{% endblock %} {% block modal-header %}{% trans "Create Network" %}{% endblock %} {% block modal-body %}
{% trans "Create a new network for any project as you need."%}
{% trans "Provider specified network can be created. You can specify a physical network type (like Flat, VLAN, GRE, and VXLAN) and its segmentation_id or physical network name for a new virtual network."%}
{% trans "In addition, you can create an external network or a shared network by checking the corresponding checkbox."%}


I started taking this 2 years ago and was then taken off it by another doctor as my symptoms had cleared up. All my anxiety/depression symptoms started coming back gradually and I was put on various other drugs like Lyrica, Cymbalta, Lustral, etc and none of them worked and the side effects with some of them were cruel. I am now back on Lexapro, starting at 5mg and increasing by 5mg every week till I reach 20mg. This was the only drug that cured me before, I found it wonderful first time round so fingers crossed it will work again.
The side effects starting off are not to bad.
SENT5
I know last time round I didn't gain weight so I hope I don't this time either. It's so good.


Unicode Tips & Tricks¶
We allow our developers to use Unicode in comments and text outputs. It is especially useful to typeset mathematical symbols and equations. Here is an example.
// The multivariable chain rule states:
// df/dv_i = (∂f/∂x * dx/dv_i) + (∂f/∂y * dy/dv_i)
// ∂f/∂x is y*x^(y-1)
// ∂f/∂y is (x^y)*ln(x)
Here we collect tips and tricks that we have found while using Unicode. Please consider contributing if you find useful things to share:
- unicodeit.net : A website converts LaTeX expressions into corresponding Unicode symbols.
- latex-input : Latex input method for macOS and Microsoft Windows.
- Emacs’ TeX input method : Emacs’ input method which allows users to enter Unicode characters by typing their (La)TeX names.
- If you experience a problem rendering Unicode symbols in your system, please download and install the following fonts on your machine:


WITNESS LIST Finance Committee January 28, 1997-9:00A Budget/CTFOTC On: Fields, Janie D. (CTFOTC), Austin Martinez-Flores, Sylvia (CTFOTC), Lubbock Smith, Peggy B. (CTFOTC), Austin Strickland, Bill (Self), Dallas Registering, but not testifying: On: Roberts, Dorothy (CTFOTC), Austin Winkler, Sarah (CTFOTC), Austin Budget/Dept. of Health On: Dunkelberg, Anne (CFPPP), Austin Elkins, James N. (TDH), Austin Jordan, Laura (CFRHI), Austin Parker, Carolyn A. (TX MDS Network), Austin Patterson, Dr. Patti (TDH), Austin Phillips, Michael (TDH), Austin Reeves, Greg (Self), Austin Romberg, Peggy (TX Family Planning Assc), Austin Simpson, Dr. Diane (TDH), Austin Stewart, Ruth F. (TDH), Austin Vasek, Heather (TX Assc for Home Care), Austin Washington, Randy P. (TDH), Austin Wilkerson, Dr. Walter (TDH), Conroe Registering, but not testifying: On: Collins, David L. (TDH), Austin Hogan, Roy (TDH), Austin Mansolo, Ron P. (TDH), Austin Merriam, Rosemary (TX Family Planning Assc), Austin Noble, Shannon (League of Women Voters), Austin Ringer, Jr., Frank (TDH), Austin Stabeno, Debra C. (TDH), Austin Thompson, Wanda M. (TDH), Austin Triplett-Hurt, Betsy (TDH), Odessa Written materials submitted: On: Bower, Bruce P. (Self), Austin Budget/HHSC On: McGiffert, Lisa (Consumers Union), Austin McKinney, Mike (HHSC), Austin Registering, but not testifying: On: Arrell, Vernon M. (TRC), Austin Harrison, Charles E. (TRC), Austin Raiford, Barton F. (HHSC), Austin Ward, Dave (TRC), Austin Wolfe, Mary (TRC), Austin


Requirement Fulfillment
This is explanation steps of the Guide/Process of requirement fulfilment after project presentation
Please continues and follow these step and fulfill requirements below;
- Step: Project Revision(PF10), the student must complete revision and get all signatures from Advisor(s) and three(3) Committees.
- Step: Project Approve(PF11), the form will insert and attach to after cover of the Project Book
- Step: Project document and resources, consist of
- (1)Final Project Book,
- (2)Project Application,
- (3)Project Poster,
- (4)Project Vinyl (X Stand) size 60cmx160cm or 80cmx180cm,
- (5)Paper / Journal
- Step: Project Approve(PF11) have to sign by (1) Adviser(s), (2) Committees, (3) Head of Department and (4) Dean of Faculty. This must completed by the student self.
- Step: Submit complete project document and related resources to Adviser, to get Free From Advisor(PF12).
- Step: Submit complete project document and related resources, and PF10, PF11, and PF12 to officer.
Requirement MUST complete after Final Project Presentation
[HARDCOPY] :
- 1. Project Revision Sheet
- 2. Project Poster
- 3. Project X Stand Vinyl
- 4. Project Book
[SOFTCOPY] :
- 1. Project Poster
- 2. Poster X Stand Vinyl
- 3. Journal / Paper
Requirement submission SOFT COPY, please provide in CD, DVD, Flash Disk or other media with file naming as below:
- Student_ID-name-Project_Book example: 491431002-Kholed-Langsari-Project_Book
- Student_ID-name-Project_Vinyl example: 491431002-Kholed-Langsari-Project_Vinyl
- Student_ID-name-Project_Poster example: 491431002-Kholed-Langsari-Project_Poster
- Zip all files above and naming as Student_ID-name-Graduate example: 491431002-Kholed-Langsari-Graduate.zip
Requirement of Poster and X Stand Vinyl
- 1. Poster in A3 size and one side
- 2. Poster have to be readable from 2 meter read.
- 3. Typography must be suitable format
- 4. Format must be in .psd/.cdr and .jpg/.jpeg
- 5.  Poster resolution for printing minimal is 300 dpi from original resource photo
Requirement of Journal / Paper
The journal or paper format should follow IEEE or ScienceDirect standard
Submission
For requirement submission above, please submit directly to IT officer, before dateline as mentioned in the schedule