WITNESS LIST Public School Finance, Select Committee May 1, 2004-1:30P HB 1 Committee Substitute (Grusendorf #1) Against: Carr, Susan (Self)


Select route to update:
Type:
{{ routeBox.type }}
Current Weight Cost: $
{{ routeBox.weightcost }}
Update weight cost :
Current Volume cost: $
{{ routeBox.volumecost }}
Update volume cost:
Current Max Weight:
{{ routeBox.maxWeight }}
kgs
Update Max Weight :
Current Max Volume:
{{ routeBox.maxVolume }}
cubic meters
Update max volume :
Current duration
{{ routeBox.duration }}
hours
Update Duration___ :
Current frequency of route:
{{ routeBox.frequency }}
hours
Update frequency__:
Current shipping day:
{{ routeBox.day }}
Submit
Cancel
Update Status:
{{updateMessage}}


You may contact us to let us know of your On the Blog experience. Feel free to subscribe again for new post alerts.
Bye!


It is easy to use the utility that is
supplied with the
MQTT for JS client.
The utility helps you to get your
JS client to connect to an MQTT server, subscribe to a topic, receive a message,
publish to a topic, view lastest received messages and add the message to a log.
The utility can also hold many connections to the server.
Getting the utility up and running is very straighforward.
How to deploy
- Download open source libararies of Dojo toolkit and Gridx.
- Copy the MQTT JavaScript library mqttws31.js to the folder js/
- Put dojo, dijit, dojox and gridx to the folder js/, namely at the same level as mqttui, e.g:
- dojo
- dijit
- dojox
- gridx
- mqttui
- mqttws31.js
- dojoConfig.js
- Directly open index.html in browser.
- If can not open directly in a browser, please put the folder of utility in Web Server. This is due to more restrictive handling of HTTP requests from local file system than from a web server.You can disable web security when starting the browser.
e.g. Chrome:
chrome --disable-web-security or chrome --allow-file-access-from-files
How to work
- Click connection1 to open the connection. It is a demo of a connection to the server.
- Click New Connection to create a new connection. The connection metadata is persisted in cookie.
- Right click newConn to rename or delete.
- Use one connection to connect, subscribe, and publish.
- Connect to a server.
- Input client id, host and port or use server URI to connect. If connect successfully, the red icon on the left of Client ID will turn to green.
- Click the Options tab to set connect options include basic options, HA,and LWT.
- Subscribe to a topic.
- Publish to a topic.
- Receive a message. Click the Last Message tab to view recevied messages.
- Click the Histroy tab. It includes actions, event and messages.
- View message detail. Double click message item in Last Message or Histroy.
- Disconnect the connection. Click the Disconnect button.
Development suggestion
If you want to develp your own apps using MQTT JS library, you can refer to the file of mqttui/TabConn.js


Adobe Dreamweaver is a proprietary web development tool developed by Adobe Systems. Dreamweaver was created by Macromedia in 1997 and was maintained by them until Macromedia was acquired by Adobe Systems in 2005.
Adobe Dreamweaver is available for macOS and for Windows.
Following Adobe's acquisition of the Macromedia product suite, releases of Dreamweaver subsequent to version 8.0 have been more compliant with W3C standards. Recent versions have improved support for Web technologies such as CSS, JavaScript, and various server-side scripting languages and frameworks including ASP (ASP JavaScript, ASP VBScript, ASP.NET C#, ASP.NET VB), ColdFusion, Scriptlet, and PHP.


Motivation
We decided to take a look in a big and competetive market that is the private transportation services provided by axis and ubers in New York City.Uber has received heavy criticism from multiple sources. A lot of the opposition is from taxi companies feeling unable to compete. But is Uber actually stealing customers from taxi companies or are they creating a new market?
There's definitely many exicting questions to ask regarding transportation services in NYC, and that is the biggest reason why we chose this data.
Our preprocessed data consists of 2 subdatasets, one for taxis and ubers. They consist of every single pickup with a timestamp and a taxizone location in a half-year period from January 1, 2015 to July 1, 2015.
The main goal for the end user's experience was to make a simple and understandable visualization of a massive dataset. We want the user to be able to overview a complex and very large dataset. The preprocessed data consists on average of more than 440,000 and 80,000 observations for taxis and ubers respectively each day! It is a huge amount. Therefore we reduced the time period to a half year, and aggregated each observation occuring on the same day and taxi zone. We quickly realised a geographical plot was not possible with exact pick up coordinates, and opted for a heatmap based on the 263 taxi zones instead. We also deleted any other column as payment options etc. were not relevant for our visualization
The preprocessed data of size 538mb and 45 mb for taxi and uber respectively is reduced to two csv. file of size approximately 150kb each for both the taxi and uber dataset. As a part of our exploratory data analysis we found that in the entire half year period taxis dominate the market with 84% of all rides. This fact will become relevant our visualization.
Genre
The genre we chose is Annotated Map. It works the best here as we have access to geographical data and because the story we want to tell has location as one of its starting points.The tools we chose as a part of our Visual Narrative is
- Consistent visual platform
- Timebar
- Feature distinction
- Motion
- Object continuity
- Animated transistions
The tools we chose as a part of our Narrative Structure is
- Linear ordering
- Filtering
- Headlines
Visualizations
We have chosen to map New York City divided into 263 officiel taxi zones. A user can select a time period in a halfyear interval and see the percentage of uber pickups out of the total number of rides (uber and taxi) in that given time period in each taxizone. As a neutral color a taxizone with an average distribution that matches the overall average of 16% is colored white. Everything below is colored yellow for taxi dominance and everything above as colored blue as uber rules there.Behind the visualization is an algorithm that takes the time interval as input and returns the uber percentage in every of the 263 taxizones. That is the algorithm aggregates the dataset each time a new time interval is selected. Even then the visualization is fairly smooth.
This visualisation is the best for our data story, since it gives the user opportunity to understand the pickup frequency and location of ubers and taxis on a variable time scale. No other solution would have worked, since you cannot possibly plot over half a million dots for each day.
Discussion
As can be seen in our video our initial aspirations of this project was slighty modified upon taking a deep dive in the dataset. The dataset seemed far more massive than initially expected. Our visualization completes the task of getting a geographical aspect into the data story.Since our dataset is very large a lot of things could be added to make this data story more streamlined and well rounded. An interesting aspect is the distribution of rides on an average day. One could also investigate the tendency of growth for uber vs. taxi. How much rapidly does uber grow, and does the taxi industry decline? There are a lot of visualization that could have been added to make the data story more complete.
Contributions
Aksel's main responsibilities:- Data search
- Algorithm design (aggregation on the fly)
- Webpage design and explainer page
- Data preprocessing and aggregation
- D3 code and main visualization
Get the data
Preprocessed Uber dataPreprocessed Taxi data
Processed Uber data
Processed Yellow Taxi data
Github page


{% load static %}
Test
College Tab
Test:
{{test.topic}}
Go Back
Logout
General instructions:
Switching of tab is not allowed.
Please make sure that your face is visible to the camera at all times.
Any unusual activity will be recorded and checked for potential malpractices.
Test will be automatically submitted after the alloted time i.e
{{test.date}}
{{test.starttime}}-{{test.endtime}}
Start Test!
{{test.link|safe}}


--- layout: post title: Setting up github for a static developer journal categories: [web development, code-snippets] tags: [github, github-pages, repository, terminal] ---
To create a new repository on Github, you can click on the '+' button next to your profile image on the top right hand side of the screen.
Then you can click the 'New repository' button which will bring you to the page where you configure your new repository with a name and privacy details etc.
Name your repository like this: 'username.github.io' Your username must exactly match the username associated with your Github account for this to work, case sensitive.
Your repo can be private, but the Github pages website itself will be publicly accessible to anyone who knows the link, which is easy to find out because it's just your username followed by github.io.
inish creating your project. After creating your repository, you will be brought to your repositories home page. This page includes instructions for setting up your repository on your local machine.
The instructions in the following instruction shows you how to set up a static webpage with version control. These instructions provide reasons for why you may or may not want to do something, as well as a few tips that should help make your life easier should you decide they could work for you.
I use the terminal, but you can also use the Github Desktop client if you prefer. Here are instructions for both cases.
I use the terminal, but you can also use the Github Desktop client if you prefer. here are instructions for both cases.
I store my project folders in the home directory. When you open up a fresh terminal, you are automatically in the home directory so you don't need to navigate anywhere else like the Desktop to find your folder.
If your are in any other folder, you can navigate directly to the home
directory by running the cd
command.
git clone
https://github.com/username/username.github.io
cd username.github.io
Instead of typing out the full name of the folder you want to go inside, you can enter the first few characters and hit the 'Tab' key to autocomplete it.
touch index.html
The index file is the home page of your website. We call it an 'index' file because it contains an index that people can use to look up places in your website that they want to visit.
Your title can be anything. I wrote a standard 'Hello World!' message. You can add the boilerplate setup later. We just want to see that the Github pages site can display the webpage you have just created.
git add index.html
You could also have used `git add .` to add all of your files (in this case there is only one) to be committed. Though I would advise against doing this for two reasons:
git commit -m "home page available to start sharing
dev journal entries"
Most tutorials instruct you to write your first commit message as 'first commit'. The same tutorials tell you that the best commit messages explain why you have done something instead of how you did it, which is contradictory considering the first commit message does not explain why you are making the first commit.
The first commit message is an ideal place to start explaining why you are starting your project. Again this is a personal preference, but one that makes my commit messages read like an interesting story that evolves over time with a meaningful narrative.
You can stage files and commit them in one step by combining the commands with the '&&' operator like this:
git add file.html && git commit -m "commit
message"
git push origin master
NOT git push -u origin master
One of the reasons I document everything I learn as I learn it is to make sure that other self-taught devs have access to the same information that I am priviledged to have access to. Hence the detailed explanations about 'why' we do things and what could go wrong with them.
At this point, most tutorials tell you to use `git push -u origin master` to push your changes to the upstream repository, but this command can cause unintended consequences that have been outlined below.
Before we look at the consequences, I'll explain what the `git push -u origin master` command does. This explanation requires an understanding of the difference between a downstream and an upstream repository.
In the 'git push -u origin' command, we are saying:
Push all of the changes we have made in our downstream repository (local copy) to our default upstream repository (that we are about to set). We want our default upstream repository to be the origin of our master branch, or in other words the location where we cloned our repository from.
The '-u' flag sets the default upstream repository to whatever location (branch) is specified.
After we have set our default repository, we no longer need to specify the repository that we want to push/pull our changes to/from. We can just use `git push/pull` instead of `git push/pull origin [branch]`.
While setting the upstream repository seems convenient, it can cause problems depending on what version of Git you are using (especially versions < 2.0), and depending on how Git is configured in the git config file/s.
You can check how Git is configured you can run `git config -l`. To find out what version of Git you are using, you can run `git --version`.
In Git versions before git 2.0, the default settings for 'git push' is to push all branches locally that have the same name on the upstream repository.
You are on the master branch and you make a few changes only to realise that you meant to be on a different branch. So you switch to a different branch, make a few changes and push your changes.  As the master branch is known to the upstream repository, you have accidentally pushed changes. This is pretty difficult to undo.
The good news is that in Git versions 2.0 and after, the default settings for 'git push' is to only push the branch you are currently working on (if it has the same name on the upstream), which is much better.
That being said, even if the version is current, the Git config settings may have set the default push settings to match an earlier version's way of doing things (possibly because `git push/pull` appears to be more convenient and most tutorials don't teach the problems).
Chances are, you are not going to remember to check the version of Git being used or the config file settings for all of the repositories you are working on.
The safe option then is to push your changes using the 'git push origin [branch]' command.
Using this command means that you are always being explicit (and intentional) about the changes you are pushing to your upstream repository.
You have now pushed your markdown homepage to your Github Pages repository.
Open your browser and type in `https//username.github.io`
If you try to access your Github Pages website straight away, you are likely to get a 404 error page. This is because it can take up to 10 minutes for your site to be 'built' and made live by Github.


-
Quick and free sign-up
Enter your email address to create an account
-
Access our network
Get early access to our growing network
-
DNA file storage
Securely store and encrypt your files in DNA
Create your account now
Already have an account? Sign in.
© 2019
Evera Labs LLC.


Manchester United
Cristiano Ronaldo scored two goals during his first game back at Manchester United on Saturday against Newcastle United in the Premier League.
The Portuguese superstar rejoined the club from Juventus this summer.He scored 118 goals in 292 games during his previous six-year stint with Manchester United before leaving for Real Madrid in 2009 for what was then a world record fee. read more about this


|
SideCar
|
Status collector for Runner StatusEmitter objects. More...
#include </Users/howes/src/sidecar/GUI/Master/StatusCollector.h>
Public Types | |
| using | ZCPublisherRef = boost::shared_ptr< Zeroconf::Publisher > |
Signals | |
| void | statusUpdates (const QList< QByteArray > &statusUpdates) |
| Signal sent out whenever a new status message is received. | |
Public Member Functions | |
| StatusCollector () | |
| Constructor. More... | |
| bool | open () |
| Creates a UDP socket to use to receive status data, and then publishes the UDP port number for StatusEmitters to use to when sending status data. More... | |
| void | close () |
| Shutdown the Zeroconf publisher, and close the UDP socket. | |
Static Public Member Functions | |
| static Logger::Log & | Log () |
| Log device for all StatusCollector objects. More... | |
| static const char * | GetCollectorType () |
| Obtain the Zeroconf type for all Runner StatusEmitter objects associated with this StatusCollector class. More... | |
Status collector for Runner StatusEmitter objects.
Accepts XML status information from a StatusEmitter that details the status of the IO::Stream and IO::Task objects owned by the Runner. Hands off incoming status data to a ServiceModel object via ServicesModel::updateStatus() method.
Definition at line 26 of file StatusCollector.h.
| StatusCollector::StatusCollector | ( | ) |
Constructor.
| model | the object to notify when new status arrives. |
Definition at line 23 of file StatusCollector.cc.
References GetCollectorType(), Log(), and LOGINFO.
|
inlinestatic |
Obtain the Zeroconf type for all Runner StatusEmitter objects associated with this StatusCollector class.
Definition at line 44 of file StatusCollector.h.
Referenced by SideCar::GUI::Master::MainWindow::MainWindow(), and StatusCollector().
|
static |
Log device for all StatusCollector objects.
Definition at line 17 of file StatusCollector.cc.
References Logger::Log::Find().
Referenced by close(), open(), and StatusCollector().
| bool StatusCollector::open | ( | ) |
Creates a UDP socket to use to receive status data, and then publishes the UDP port number for StatusEmitters to use to when sending status data.
Definition at line 34 of file StatusCollector.cc.


What to Pack?
- Pack light; only pack what you need
- Snacks for plane/layover so you dont have to purchase any
- Suncreen
- Passport if needed
- Know airlines baggage fee (For how many bags to take)
Where to Stay?
- There are really amazing hotels everywhere you just have to know when to book them
- Airbnb is another website where you can book places to stay (Real homes)
- Stay close to attractions (walking distance)
- There are all inclusive hotel deals (food is included)
When to Book?
- Flights are cheap between midnight and 1 am
- Tuesdays are days when flights are cheap
- Book flight and hotel at least 1-2 months ahead of time
- Use third party sites for booking accommodations


Whoops! We didn’t recognise your email or password. Please try again or contact administrator.
You've been logged out successfully.


US vice president visits troops in Iraq
BAGHDAD, Nov 23 — US Vice President Mike Pence flew in to Iraq on Saturday to meet American troops stationed in the country’s western desert, a security source told AFP.
Pence’s unannounced landing at Ain al-Asad base — his first visit to Iraq as vice president — came nearly a year after President Donald Trump made his own surprise trip to the sprawling complex.
Trump drew criticism for the lightning-fast visit, in which he briefly met with troops but did not see any Iraqi officials.
That visit was veiled in such secrecy there was speculation that most Iraqi authorities had not been informed the president was coming.
No schedule has been announced for Pence’s visit, and the US embassy in Baghdad told AFP it had no details to share on the trip.
The US has 5,200 troops stationed in Iraqi bases across the country.
Washington led the 2003 invasion of Iraq that toppled then-dictator Saddam Hussein, dismantled its security forces and then attempted to rebuild the country’s institutions.
After years of working closely together, ties between the two countries are currently at their “coldest”, US and Iraqi officials have told AFP.
Prime Minister Adel Abdel Mahdi, in office for the past year, has yet to visit Washington, and Trump has not met top officials in Baghdad. — AFP


Powershell Qualys Authentication Part 1
I always mean to post more on my blog, but as life gets in the way and work keeps me busy, I always seem to push it to the back-burner. This time, I am hoping to make it stick as a regular routine.
To kick off my new-found motivation to blog more, I am starting a series of posts surrounding PowerShell and Qualys Vulnerability Management API.
To start this off, first I’m going to share some my basic steps with regards to authentication to Qualys VM API v1. This is really basic, but I see a lot of posts around that seem to try to create some “advanced” way of authenticating to Qualys API. You don’t need to do anything fancy.
As with all scripts/modules/etc., I suggest that you get into the habit of using PowerShell ISE and it’s many great keyboard shortcuts to help you get on the right path.
First, open PowerShell ISE and enter the following keyboard shortcut: [code ]
CRT + J
[/code ]
Once the “Show Snippets” context menu shows up, select “Advanced Function (Complete)”. I always recommend that you start with a ‘Complete’ Advanced FUnction. This makes your script look much better, and it’s all around a good idea.
Once you have the Snippet loaded, I would begin by coming up with a name; following Microsoft’s approved Verb-Noun naming convention:
Approved Verbs - https://technet.microsoft.com/en-us/library/ms714428(v=vs.85).aspx Get-Verb Documentation: https://technet.microsoft.com/en-us/library/hh852690.aspx
Next, start adding a “Credential” object parameter to your code. Qualys uses “Basic” authentication, so using Invoke-RestMethod in combination with a “Credential” object is extremely easy.
To capture your credentials into a Credential Object used by Invoke-RestMethod, you simply need the following before you run your function or within your function: [code ]
$cred = Get-Credential
[/code ]
Enter your Qualys API username and password.
*NOTE: Do not try to save this credential object to disk or to a file. It’s NOT hard to enter your username and password every time you connect to Qualys API.
Next, you should have the following code in your function: [code ]
[xml ]$hostinfo = Invoke-RestMethod -Uri "https: //qualysapi.qualys.com/msp/get_host_info.php?host_netbios=$netbios&general_info=1"-Credential $credential [/code ]
I recommend that your $credential object should be passed into your function as a parameter. This will help when you move into more advanced interaction and multiple calls to Qualys VM API.
Now that you have your XML (Type cast) $hostinfo variable, you can then parse the data very, very, very easily.
In my next post I will share with you how to do this to gather some very important data for any Qualys Vulnerability Management Administrator.
If you have any questions, then please leave a comment.
[code ]
function Test-QualysAuthentication () { [cmdletbinding() ] param ( [parameter(Mandatory=$true, ValueFromPipelineByPropertyName=$true, HelpMessage="Please provide a credential obejct") ] [ValidateNotNullOrEmpty() ] [System.Management.Automation.CredentialAttribute() ]$credential )
<# .SYNOPSIS This function tests your Qualys VM API Credentials .PARAMETER Credential Specifices a set of credentials used to query the QualysGuard API .EXAMPLE C:\PS> $cred = Get-Credential C:\PS> Test-QualysAuthentication -credential $cred
#>
[xml ]$hostinfo = Invoke-RestMethod -Uri "https: //qualysapi.qualys.com/msp/get_host_info.php?host_netbios=$netbios&general_info=1" -Credential $credential
return $hostinfo }
[/code ]


Id: 263
Name: Pibbles Bodyguard
Status: Alive
Species: Alien
Type: Hairy alien
Gender: Male
OriginName: unknown
OriginUrl:
LocationName: St. Gloopy Noops Hospital
LocationUrl: https://rickandmortyapi.com/api/location/16
Image: https://rickandmortyapi.com/api/character/avatar/263.jpeg
Episode: ['https://rickandmortyapi.com/api/episode/19']
Url: https://rickandmortyapi.com/api/character/263
Created: 2017-12-31T13:43:30.513Z


HippoTime and PorkiBall: Human-Computer-Interaction Technology
Winner: UCI Multidisciplinary Design Program Research Grant (2014, 2015, 2016)
Featured in Interface Magazine — Spring 2015
HippoTime is an animated video game which uses biofeedback from the user to play and navigate the game (Levels of the game pictured above). The goal of this product is to equip children with ASD with the proper tools for emotion regulation. Use cases of this game include tantrum intervention, breathing therapy training, and effectiveness in clinical and home setting.
Similarly, PorkiBall is aimed at helping increase social interactions between parents and children with ASD through the innovative toy. PorkiBall is aimed at being cost-effective, effective for home setting, and requires no special training for intervention.


This section is About where you live
{% if thirdparty %}You can't apply online for {{firstname}} yet
{% else %}You can't apply online yet
{% endif %}This service is being developed
You need to apply using a paper form called an HC1.
You can download an HC1 or get one from Jobcentres, GP practices, pharmacies and Citizens Advice centres.


There are four example programs, which are described shortly below.
The point example (point_example.cpp) is a short example giving the first idea of how to use the library. It shows
The "other point" example illustrates how derived classes can be used as well as the default implemented classes in the Geometry Library.
The linestring example (linestring_example.cpp) shows how linestrings can be declared and used and shows some more algorithms. One of the important concepts of the geometry library is that it is totally built upon the standard library, using the standard containers such as std::vector.
A linestring is, as explained elsewhere in this documentation, nothing more than a vector of points. Therefore the first line of the main function of this example lists:
// Define a linestring, which is a
vector of points, and add some points
geometry::linestring<geometry::point<double>
> ls;
ls.push_back(geometry::point<double>(1.1, 1.1));
Besides this, and besides that all algorithms on std::vector can be used on geometry::linestring, the sample elucidates the library showing some algorithms:
This documentation illustrates the simplify algorithm and the intersection algorithm with some pictures.
The simplify algorithm simplifies a linestring. Simplification means that the less important points are removed from the line and that the points that are most important for the shape of a line are kept. Simplification is done using the well known Douglas Peucker algorithm. The library user can specify the distance or tolerance, which indicates how much the linestring should be simplified.
The image below shows the linestring used in the example:
The red line is the original linestring; the blue
line is the simplified line which has one point less. In geographical
applications simplification can reduce a linestring to its basic form
containing only 10% of its original points.
The intersection algorithm intersects two geometries which each other,
delivering a third geometry. In the case of the example a linestring is
intersected with a box. Intersection with a box is often called a clip. The image
below illustrates the intersection.
The red line is intersected with the blue box. The intersection result, painted in black, is a multi_linestring containing three linestrings.
The polygon example (polygon_example.cpp) shows some examples of what can be done with polygons in the Geometry Library:
The illustrations below show the usage of the within algorithm
and the intersection
algorithm.
The within algorithm results in true
if a point lies completly within a polygon. If it lies exactly on a
border it is not considered
as within and if it is inside a hole it is also not within the polygon.
This is illustrated below, where only the point in the middle is within the
polygon.
The clipping algorithm, called intersection, is illustrated below:
The yellow polygon, containing a hole, is clipped with the blue rectangle, resulting in a multi_polygon of three polygons, drawn in red. The hole is vanished.
|
February 1, 2008 |
Copyright © 1995-2008 Barend Gehrels, Geodan Holding B.V. Amsterdam, the Netherlands |


This is a Jekyll template I use for my GitHub projects documentations. It is heavily based on official Bootstrap documentation and is designed to be quickly deployed.
Follow the GitHub guide to install Jekyll on your computer. The big steps are:
{% highlight bash %} $ apt-get install ruby ruby-dev $ gem install bundler $ git clone git://github.com/mistic100/jekyll-bootstrap-doc $ bundle install $ bundle exec jekyll serve {% endhighlight %}Adapt the _config.yml
file to your project.
| Name | description |
|---|---|
| name | Name of the project. |
| version | Current version of the project |
| license | License of the project |
| licenseUrl | URL of the license text |
| favicon | Extension of the favicon |
| download | Configuration of the download button (see comment in the file) |
| headerLinks |
List of links to display on the right of the top menu. Each item must contain
title and url keys
|
| footerLinks |
List of links to display on the bottom of the page. Each item must contain
title and url keys
|
| header | Configuration of the header, two colors gradient and boolean to activate or deactivate Trianglify generator |
| analytics |
Google analytics identifiers. Provide account and domain or leave empty to
deactivate
|
| Name | description |
|---|---|
| githubButton |
Data used to generate GitHub Buttons.
Provide user and repo
|
| twitter.enabled | Enable or disable Twitter "Tweet" button |
| twitter.via | Account linked to "Tweet" button |
| twitter.hash | Default hashtags for the "Tweet" button |
| twitter.account | Account for Twitter "Follow" button. Leave empty to deactivate |
| facebook.enabled | Enable or disable Facebook "Like" & "Share" buttons |
| facebook.profileUrl | Profile for Facebook "Follow" button. Leave empty to deactivate |
The main page is the index.html
file. You can also add additional pages by creating .html
files in the root folder or in any sub-folder. Each page file must begins with a template declaration:
Set isHome
to true
on the main page file, the homepage will have a bigger header with a
central download button.
Set hide
to true
to hide a page from the main menu, the page will still be accessible
with direct link. Example.
In order to get the right menu automatically generated you must respect some conventions.
{% highlight html %}
If you want an <h1-3>
with an id
but not visible in the menu, add a
data-no-menu
attribute to it.
A paragraph (§) link is added next to every <h1-5>
with an id
attribute in order
to easily right-click and copy the link to a particular section. The link is visible when hovering the title.
The powerful Pygments highlighter is activated on the template, just wrap your unescaped source code with the
{{ "{% highlight ... " }}%}
directive.
If you need to create internal links between your pages, or include resources (JS & CSS), always start your
URLs with {{ "{{site.github.url" }}}}
.
Bootbox is installed with a syntax sugar to easily create pop-in content.
To use this sugar you must create a clickable element with a data-bootbox
attribute and an hidden
content holder with a corresponding id
attribute.
All available Jekyll plugins are installed by default, you can remove them by modifying the gems
parameter in _config.yml
. See the documentation on
GitHub Help pages.
Feel free to use the bower.json
to manage your front dependencies. Bower packages are added the
dist
directory and MUST be pushed to the repository. jQuery and Bootstrap are ignored by
.gitignore
as already loaded from a CDN.


“Litmus test” comes from Chemistry. It’s basically (get it) a piece of paper with a dye on it that reacts at a certain pH. If it changes color you know the minimum value of the pH. In general the term “litmus test” is used as a really simple question to get a very simple result and use that as a way to make decisions going forward.
Stake
If you own stake it’s yours. You can do as you want with it. It’s your power and within your scope to do so. The rest of this community will act accordingly. They may support what you are doing, flag you, and/or start trolling based on what you’re doing. My guideline presented below is intended for whales. Dolphins should be doing their best to follow this, and minnows too, but the consequences of doing a shitty job at this as a dolphin or minnow are slim. The consequences of large stake holders acting against a very simple litmus will have a perceptible impact on the rewards pool and culture of this place.
Culture is king
You can try to enforce whatever you want as an individual, but you’re gonna have a hard time. The only way to really police this place is through a community effort and we need some alignment with a bare bones “what is considered abuse?” In order to enforce this culture we need whales to have some restraint and we need community leaders to exemplify good behavior that we should all attempt to emulate. With a healthy culture the general amount of abuse should go down making it easier to fight.
A good guideline
Simply ask yourself before you vote: “does this post/comment add value to this platform.”
 If you have a funny comment on a friends post and want to make sure they see it I don’t think that’s a big deal if you’re dropping small votes for visability. The ones I’m concerned with are $20 or more self votes (because that’s roughly the 50k SP 100% vote level), especially in comments, where the goal is to use your stake to leach from the reward pool. So, before you add some huge self-votes that the community will find reprehensible and encourage others to act in bad faith just ask yourself “Does this add value to the platform.”
It’s important that you follow these guidelines. You’re an investor. Maybe you got your investment through mining and stake-weighted inflation, maybe you got it posting, and maybe you got it through buying in. No matter how you got it please treat this place well with respect. If the investor’s can’t control themselves how can we expect anyone else. You guys set the tone. Please set a good one.
Some bad examples
If you’d like to see some bad examples of behavior just check out: https://steemit.com/payout_comments
It will show you the highest paid comments. These are almost always whales self voting.
At the top of the list is @ned causing on-platform drama with his former co-founder @dan. Rather than trying to constructively resolve a conflict he’s using Steemit’s stake, which is supposed to be non-voting according to threads in bitcointalk that discuss how that stake will operate going into the future to argue the need for the stake at the time the mining occurred. @ned’s comment is also highly ironic in that it’s a self-aggrandizing complaint on a self-aggrandizing comment.
I like Ned. I think he has a hard job, and while things have been slower than many would like he’s keeping the wheels on and continues to grow his team. I’m looking forward to a good 2018.
 Does that add value to the platform? No. @ned please find a way to peacefully resolved your conflicts off the block and don’t use the stake Steemit leadership committed to not use for personal drama, especially with @dan.
- How about @transisto?
I like transisto too. I know he gets in some hot water politically for flagging, but good abuse flagging is one of the most noble things a person can do. He’s spoken to me about his hatred of corruption on the platform and how he wants to root it out. A lot of that is fantastic and I support the effort.
How about his random self-votes on comments? NOPE! They provide no value. He says he’s doing it to support a project that will support the platform. Well that sounds interesting… But I don’t see an update. If he created an update on a project that was supporting the platform would that show evidence of providing value to the platform? Absolutely! I’d love to read that post, and I’d welcome him to upvote it himself. but a 3 word “I’m doing good stuff behind the scenes” comment isn’t a good use of community rewards pool. I see no value there.
@transisto I have two suggestions for you. Make posts describing the work or delegate some Steem Power to @msp-bidbot and get a daily payout from a bidbot (more on this later). I highly doubt another whale would complain if you self upvote on a project update about something that helps the block. I know it’s 30 more minutes of work, but please make the effort to build a real post rather than just soaking in self-votes through non-productive comments.
This one is especially ironic to me because my litmus test is straight out of @transisto’s mouth. He was the one harping on this, and I ultimately think he’s right. It’s tragic to me that he’s now abandoning that principle because sbd is high (that’s his own words). The term for that is “selling out.” I think highly of @transisto and hope the behavior changes.
- Grumpycat
I like Grumpycat too. Actually I really like all these guys.  That’s actually really noble too. I know it pissed some people off, but he’s literally saving the reward pool from bot abuse and giving people more time to catch that kind of shitty abuse. Good work!!!
Then @grumpcat goes and starts self-voting on comments. Are those comments providing sweet sweet value to the platform? It doesn’t look like it to me. It mostly looks like a hypocritical cat on a self-voting binge.
Cat.  You get to use your stake. You can make those choices; however, if you use it in a selfish manner this community won’t respond well. Please stop dropping $100 votes on practically meaningless comments.
Bidbots
There’s still some frustration around bid bots, but here’s the thing. They are open, transparent, have rules that everyone can view, and they are public. @transisto if you need money for a project put some Steem aside and use a bid bot. It’s ok. These aren’t killing the platform. They are an incredibly unique approach to marketing that rewards the investor and the user. Where else can you spend money, get advertising, and then get your money back. It’s a service and one that’s pretty highly valued on the platform.
It’s ok to use. Frankly if you don’t use them you make it easier for the shitposters to use them. Then the terrorists win.
 Again, delegate to msp-bidbot and get a daily return.
Are some of the bot votes used for abuse? Absolutely, but the bot owners are working with @patrice and @steemcleaners to cut down on abuse. As the owners get better about stopping abuse they’ll only get better over time. It’s a process and a game of cat and mouse.
Guys, if you need the extra money for some reason and you’re looking to get a return on your investment above and beyond the rising price of Steem then please choose this publicly available option rather than upvote your own comments that don’t provide value.
Well, I upvote myself more than most whales, but it’s practically never on comments. I write 1-2 posts a day on average and will continue to do so. I may have more posts than half of the top 20 witnesses combined. I like to write, and I think the writing I do adds value to the platform. I’m not ashamed to self upvote it because it meets my litmus test. Do my posts add value to the platform? YES! They help build communities on this platform.
On top of that I delegate nearly all of the stake I earn from this place to projects and people that grow this platform. When I self vote on a post I take somewhere between $2-8 USD for my work. I don’t think that’s out of line and then when I get it back I put almost all of it back into projects that help the community.
I use my bidbot to help me cover some of my life costs while simultaneously giving minnows a chance to earn. I have a fairly steady passive income from it and I can use that and my post rewards to lead a pretty good life while being able to build a community that’s going to change the world. I think I found a decent balance that didn’t include self-voting on 3-word comments. So, I pass my own litmus test. If I sell out at some point I hope there’s someone here to call me out on it and help reign me back in.
Whales. I like you and this platform needs you, but please vote responsibly and lead by good example.
Namaste,
Aggroed
1
This page is synchronized from the post: ‘Aggroed’’s simple litmus test for self-voting: Does the content provide value to the platform?’


Collection
The Department for Education's advice and information on health and safety.
Information and guidance for schools on health, safety and emergency planning.
Published: 17 April 2014
From: Department for Education
Part of: Running a school or college


(Note: This is Part 3 of my GBA by Example series. A list of my other GBA tutorials can be found here)
It’s Tuesday, which means it’s the arbitrary day of the week I chose to post GBA stuff!
Last week we got a sprite on the screen and moving around in a tiled video mode, but it still left our screen looking a little bit bare. This week we’re going to rectify that, and figure out how to work with Backgrounds! You can make really great looking stuff with backgrounds, or you can do what I did, and make something that looks like this:
This is two backgrounds (one gradient, and one checkerboard), overlapping one another, and moving in opposite directions. Snazzy eh? Today we’re going to cover the absolute minimum you need to know to make something like that.
To kick things off, let’s take a look at what a background actually is on the GBA:
Like Sprites, Backgrounds are rectangular collections of tiles. Unlike Sprites, they can be really, really big (relatively speaking). If you recall from last week, the largest sprite we can make is 64x64 pixels. Backgrounds can be up to 1024x1024 if we want them to. Since we only have 96k of VRAM on the GBA (and 32k of that is for Sprites), it stands to reason that to fit all our background data in, they look a bit different from Sprites in memory.
Just like with Sprites, all colours in a Background come from a Palette, which is a collection of up to 256 different colours, each stored as a 16 bit unsigned integer. Colours on the GBA are stored with 5 bits per channel, with the highest bit ignored, like this:
inline uint16 MakeCol(uint32 red, uint32 green, uint32 blue)
{
return red | (green<<5) | (blue<<10);
}
In code, a Palette might be defined like so:
const unsigned short bgPal[4] __attribute__((aligned(4)))=
{
0x4DA0,0x0000,0xFFFF,0x001F
};
One thing that hasn’t been mentioned in previous articles is that pixels that use the colour at index 0 are treated as transparent, so you only see the index 0 colour if nothing else gets drawn on top of that pixel. This will be important for us today because we’re going to overlap two backgrounds on top of each other.
A Background’s tiles are the same as a Sprite’s: 8x8 rectangular collections of indices, with each of these storing an index from the palette array. Backgrounds use a separate colour palette from sprites, so you can use an entirely different set of colours for your backgrounds than you do for other stuff in your game. This palette memory, just like with sprites, is large enough to store 256 colours. Since we can only have 256 possible values, tiles store each pixel as an 8 bit index. Tiles are laid out row by row, from top to bottom.
In code, that might look like this:
const unsigned short bgTiles[64] __attribute__((aligned(4)))=
{
0x0101,0x0202,0x0101,0x0202,0x0101,0x0202,0x0101,0x0202,
...
};
If you store your tile data in values larger than uint8s, like I did above, remember that the lowest byte in a value is the leftmost pixel.
All of that should be familiar to you if you read last week’s post, but unlike with Sprites, the order of the tiles doesn’t matter when we’re working with backgrounds. This is because backgrounds want to re-use tiles as much as possible. To accomplish this, backgrounds use a third data structure, called a Screen Block, which is a collection of indices into tile memory: One 16 bit value for every 8x8 tile that the background uses.
Screen Blocks are always 32x32 in size, but each of these values represents an 8x8 tile, meaning that backgrounds are made up of one or more blocks of 256x256 pixels.
In code, a Screen Block might look something like this:
const unsigned short checkerBg[1024] =
{
0x0001,0x0001,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x000A,0x001D,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
//continue for another 30 rows
As seen here, Screen Blocks are defined row by row, top to bottom, each value representing the index of a tile. When you’re working with 8bpp tiles, this is all there is to it. There’s more to think about in 4bpp mode, but since this is the first time we’re doing anything with bacgkrounds, let’s keep it simple and continue working in 8bpp mode.
The last thing to know is that we can only have between 0 and 4 backgrounds working at the same time. Yay hardware limitations!
This was a lot of theory, and I want to switch gears now and start to build some stuff, but just to recap:
Alright, let’s start putting this into practice!
Because Screen Blocks are so large, I’ve uploaded the data (including tiles and palette) that I’m going to use today to github instead of just including it here.
That gist contains all the information needed to get our first background (the checkerboard) onto the screen. We’ll generate the gradient background in code below.
We know what our data is going to look like, but we haven’t yet covered where it’s going to go. Let’s start with Palette memory, since it’s going to be the most like what we’ve done before.
As mentioned above, Backgrounds use a different palette than Sprites, which naturally means that the background palette is located at a different place in memory:
#include "tiles.h"
#define MEM_BG_PALETTE ((uint16*)(0x05000000))
#define MEM_OBJ_PALETTE ((uint16*)(0x05000200))
void UploadPaletteMem()
{
memcpy(MEM_BG_PALETTE, bgPal, bgPalLen);
}
Perfect, the palette data was easy! Next we need to get our tiles into memory. You may recall from last week that the data for sprite tiles starts at the fifth tile-block in tile memory. This is because the first 4 of those blocks are reserved for backgrounds. So let’s put our tile data into the first one:
typedef uint16 Tile[32];
typedef Tile TileBlock[256];
#define MEM_VRAM ((volatile uint32*)0x6000000)
#define MEM_TILE ((TileBlock*)0x6000000)
void UploadTileMem()
{
memcpy(&MEM_TILE[0][0], bgTiles, bgTilesLen);
}
All of this is almost identical to last week, so let’s start doing something different and get our Screen Block data into memory. Screen blocks share memory with Tile memory. A Screen Block is 2048 bytes, which means that we can fit 8 of them into a single tile-block. It’s up to us to make sure that we don’t try to put a Screen Block and tile data into the same spot in memory.
If you’re using the example data, you’ll notice that we only have 2 tiles to upload into memory (a checkerboard tile, and a transparent tile), so it’s safe for us to just go 1 Screen Block away from the start of VRAM:
typedef uint16 ScreenBlock[1024];
#define MEM_SCREENBLOCKS ((ScreenBlock*)0x6000000)
void UploadScreenBlock()
{
//checkerBg is the ScreenBlock data from the gist
memcpy(&MEM_SCREENBLOCKS[1], checkerBg, checkerBgLen);
}
That should about do it for uploading the data we have for our tiles, but I also mentioned that I generated the gradient background in code. Here’s the code for that:
inline uint16 MakeCol(uint32 red, uint32 green, uint32 blue)
{
return red | (green<<5) | (blue<<10);
}
void GenerateGradient()
{
//we've uploaded 4 colours to palette memory
//so make sure we don't overwrite those
for (uint16 i = 0; i < 32; i++)
{
*((uint16*)(MEM_BG_PALETTE+(4+i))) = MakeCol(i,i,i);
}
//every tile is 64 palette indices
//we have 32 grayscale values from above
uint8 tile[64];
for (uint16 i = 0; i < 32; ++i)
{
for (int j = 0; j < 64; j++)
{
tile[j] = 4 + (i);
}
memcpy(MEM_TILE[1][i], tile, 64);
}
//generate 2 screen blocks,
//each gray value getting two tiles of width
for (int block = 0; block < 2; ++block)
{
uint16 screenBlock[1024];
//screen block data is row by row, top to bottom
for (uint16 i = 0; i < 32; ++i)
{
for (uint16 j = 0; j < 32; ++j)
{
//each block gets 16 colours, 2 tiles wide for each
screenBlock[i * 32 + j] = (j/2) + (block*16);
}
}
memcpy(MEM_SCREENBLOCKS[block+2], &screenBlock[0], 2048);
}
}
I was torn on whether or not to include this in the post, but I think it’s a good example of another way of working with all the types of memory we’re wrangling to get data on the screen. It also gives us an opportunity to work with a background that uses more than 1 Screen Block, since the gradient is 2 Screen Blocks wide.
If the above code is unclear, that’s ok! I don’t think it was particularly common to generate background data like this anyway. If you want to follow along, just copy and paste the above code and pretend we uploaded that data the same way we did the other data, since it has nothing to do with understanding how the GBA handles backgrounds.
The hard part is officially over! All that’s left now is to tell the hardware to use the data we’re feeding it, and glue all the snippets we have together.
Let’s talk about our friend the display control register (0x04000000), in addition to doing things like setting a video mode, or enabling objects, this value is also used to enable or disable backgrounds.
We get to work with up to four backgrounds at a time on the GBA, and you can enable them like so:
#define VIDEOMODE_0 0x0000
#define BACKGROUND_0 0x0100
#define BACKGROUND_1 0x0200
#define BACKGROUND_3 0x0400
#define BACKGROUND_4 0x0800
#define REG_DISPLAYCONTROL *((volatile uint16*)(0x04000000))
int main()
{
REG_DISPLAYCONTROL = VIDEOMODE_0 | BACKGROUND_0 | BACKGROUND_1;
return 0;
}
We’re only going to use the first two backgrounds today, but you can turn on all four backgrounds, or only 1 and 3, or any other combination that you want to use.
Also, we’re still in VideoMode_0, this is because it’s the easiest tiled mode to understand, and we (I) still don’t know enough to actually use any of the features in the other tiled modes.
If you’re in a bitmap mode, you need to enable Background 2 in order for anything to appear on the screen, but as far as I know, you can’t actually do anything with it, it’s just a flag needed to make bitmap modes work.
Just like with Sprites (err.. Objects that is), we need to set up a few values to define how the hardware should use our background data. Mercifully, backgrounds are actually much easier to work with than Sprites. They only need a single 16 bit value set.
Since there are only 4 backgrounds, these bits are at constant memory locations:
#define REG_BG0_CONTROL *((volatile uint16*)(0x04000008))
#define REG_BG1_CONTROL *((volatile uint16*)(0x0400000A))
#define REG_BG2_CONTROL *((volatile uint16*)(0x0400000C))
#define REG_BG3_CONTROL *((volatile uint16*)(0x0400000E))
What each bit in these values means is as follows:
| BG | 0x FEDC BA98 7654 3210 |
|---|---|
| FE | Size (defined below) |
| D | Ignored today (see Tonc for info) |
| CBA98 | What Screen Block to start at |
| 7 | Color mode: (1 for 8bpp, 0 for 4bpp) |
| 6 | Ignored today (see Tonc for info) |
| 54 | Nothing, empty bits |
| 32 | Tile Block to use |
| 10 | Z Depth |
Just like with Sprites, the sizes for backgrounds use the bits above to select a value from another table, for backgrounds, this table is as follows:
| Bits | Size (in Tiles) |
|---|---|
| 00 | 32x32 |
| 01 | 64x32 |
| 10 | 32x64 |
| 11 | 64x64 |
Using the above tables, if we wanted to define our first background (the checkerboard), as a 32x32 tile background which uses tiles starting at the first tile block, and uses the second Screen Block (since it’s offset from the start of VRAM to make space for tile memory), we would do the following:
//Size 00, Screen Block 1, Color Mode 1, Tile Block 0, Depth 0
//0000 0001 1000 0000
REG_BG0_CONTROL = 0x0180;
Notice that we want our Z Depth to be 0 as well. The higher this value, the farther back in the drawing order a background is, so a BG at depth 0 will draw on top of backgrounds with any higher values. Since our checkerboard background has the transparent pixels in it, we want it to be drawn on top of whatever will fill in those transparent pixels.
If we put all this together (leaving out the code for the second background), we get:
#include <string.h>
#include "tiles.h"
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
typedef uint16 ScreenBlock[1024];
typedef uint16 Tile[32];
typedef Tile TileBlock[256];
#define VIDEOMODE_0 0x0000
#define BACKGROUND_0 0x0100
#define REG_DISPLAYCONTROL *((volatile uint16*)(0x04000000))
#define REG_BG0_CONTROL *((volatile uint32*)(0x04000008))
#define MEM_VRAM ((volatile uint32*)0x6000000)
#define MEM_TILE ((TileBlock*)0x6000000)
#define MEM_SCREENBLOCKS ((ScreenBlock*)0x6000000)
#define MEM_BG_PALETTE ((uint16*)(0x05000000))
int main()
{
//load data
memcpy(MEM_BG_PALETTE, bgPal, bgPalLen );
memcpy(&MEM_TILE[0][0], bgTiles, bgTilesLen);
memcpy(&MEM_SCREENBLOCKS[1], checkerBg, checkerBgLen);
REG_BG0_CONTROL = 0x0180;// 0000 0001 1000 0000;
REG_DISPLAYCONTROL = VIDEOMODE_0 | BACKGROUND_0;
while(1)
{
}
return 0;
}
And if you run that, you should see:
Which is excellent! We officially have our first background on the screen. Let’s add our second one now. Remember that we used 2 Screen Blocks to hold all the values for this background, and we want them laid out horizontally, so we’ll have a 64x32 background. We want it to be at priority 0, and use the data we populated with the gradient generating code above.
// Size 01, Screen Block 2, Color Mode 1, Tile Block 1, Priority 1
// 0100 0010 1000 0101
REG_BG1_CONTROL = 0x4285;
If we add the above line, and the required #defines and gradient code to what we have, we get the following (I’ve omitted GenerateGradient() function body for brevity). I promise after this to not paste any more large code blocks into the article :)
#include <string.h>
#include "tiles.h"
#include "bg.h"
typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
typedef uint16 ScreenBlock[1024];
typedef uint16 Tile[32];
typedef Tile TileBlock[256];
#define VIDEOMODE_0 0x0000
#define BACKGROUND_0 0x0100
#define BACKGROUND_1 0x0200
#define REG_DISPLAYCONTROL *((volatile uint16*)(0x04000000))
#define REG_BG0_CONTROL *((volatile uint16*)(0x04000008))
#define REG_BG1_CONTROL *((volatile uint16*)(0x0400000A))
#define MEM_VRAM ((volatile uint32*)0x6000000)
#define MEM_TILE ((TileBlock*)0x6000000)
#define MEM_SCREENBLOCKS ((ScreenBlock*)0x6000000)
#define MEM_BG_PALETTE ((uint16*)(0x05000000))
#define MEM_PALETTE ((uint16*)(0x05000200))
inline uint16 MakeCol(uint32 red, uint32 green, uint32 blue)
{
return red | (green<<5) | (blue<<10);
}
void GenerateGradient();
int main()
{
//load data
memcpy(MEM_BG_PALETTE, bgPal, bgPalLen );
memcpy(&MEM_TILE[0][0], bgTiles, bgTilesLen);
memcpy(&MEM_SCREENBLOCKS[1], checkerBg, checkerBgLen);
GenerateGradient();
REG_BG0_CONTROL = 0x0180;// 0000 0001 1000 0000;
REG_BG1_CONTROL = 0x4285; // 0100 0010 1000 0101
REG_DISPLAYCONTROL = VIDEOMODE_0 | BACKGROUND_0 | BACKGROUND_1;
while(1)
{
}
return 0;
}
If you compile and run the above (filling in the GenerateGradient function), you should end up with this:
Which is almost exactly what we wanted to end up with when we started! All that’s left is to add some movement, and this is pretty easy to do:
In truth, backgrounds don’t really move, your viewport moves over top of the background. This makes sense with 1 background, but it gets a bit abstract when you think about multiple backgrounds moving at once. In essence, all you have to keep in mind is that increasing the X value of the background scrolling register is going to move it to the left, because what you’re doing is actually moving where your screen is to the right. The same is true for the vertical scrolling register.
As you may have guessed from that explanation, each background on the GBA has two additional registers, one for X offset, and one for Y offset. All backgrounds will repeat infinitely as you scroll them, so you can keep incrementing these values at will, without worrying about resetting them when you get to the edge of a background image. These registers are defined as follows:
#define REG_BG0_SCROLL_H *((volatile uint16*)(0x04000010))
#define REG_BG0_SCROLL_V *((volatile uint16*)(0x04000012))
#define REG_BG1_SCROLL_H *((volatile uint16*)(0x04000014))
#define REG_BG1_SCROLL_V *((volatile uint16*)(0x04000016))
#define REG_BG2_SCROLL_H *((volatile uint16*)(0x04000018))
#define REG_BG2_SCROLL_V *((volatile uint16*)(0x0400001A))
#define REG_BG2_SCROLL_H *((volatile uint16*)(0x0400001C))
#define REG_BG2_SCROLL_V *((volatile uint16*)(0x0400001E))
These are pretty self explanatory, assign numbers to them to make the corresponding background move. The only weird part about them is that they are Write-Only, so you can’t simply increment the value in one of the registers, nor can you ever read the value in the register, you can just write to it.
Using these registers, it’s trivial to modify our code from earlier to make things scroll. For brevity’s sake, I’m just going to show how to modify the while(1){} section from the above code, rather than paste the whole thing again:
int hScroll = 0;
int h2Scroll = 0;
while(1)
{
vsync();
REG_BG0_SCROLL_H = -hScroll;
REG_BG1_SCROLL_H = h2Scroll;
h2Scroll +=2;
hScroll = h2Scroll/3;
}
This is pretty much what you’d expect, background 0 is being assigned a value that is decreasing, which means it should appear to be moving right on the screen (since our viewport is moving left), and vice versa with the gradient background. This matches up with the scroll directions we had at the top of the post. Which is perfect, because that means we’re done!
I suppose I should link you to some tools that can be used to create backgrounds, but I do so only grudgingly, because I don’t think they’re great. Tonc suggests Mappy and MapEd. To be fair, I haven’t written a tile mapping tool so I don’t really have much of a leg to stand on when criticizing these, but I found them rather fiddly to use, which is why I ended up just hand building some really simple ones for this post.
I’d love to hear about better tools for doing this sort of work. I think Tiled might be better, but I don’t know how set up it is for GBA style stuff. In any case, I’d love to hear about what tools might be better on Twitter. See you next week!


Skills
Languages
Ruby |
JavaScript |
HTML |
CSS |
C# |
Visual Basic |
SQL |
Frameworks and Libraries
Rails / Sinatra / ActiveRecord |
Node.js / Express |
jQuery |
AJAX |
Materialize |
Bootstrap |
PostgreSQL |
MS SQL |
Sqlite3 |
Platforms and Softwares
Web |
RSpec |
JSON |
JIRA |
Heroku |
OSX |
Windows |
Networks |
Computer support |
Practices
Agile Development |
Test Driven Development |
Object-oriented design and systems architecture |
Pair Programming |
Currently Learning
React |
React Native |


Windows 10 x64 (19041.388)
_KINTERRUPT_POLARITY
InterruptPolarityUnknown = 0n0
InterruptActiveHigh = 0n1
InterruptRisingEdge = 0n1
InterruptActiveLow = 0n2
InterruptFallingEdge = 0n2
InterruptActiveBoth = 0n3
InterruptActiveBothTriggerLow = 0n3
InterruptActiveBothTriggerHigh = 0n4


Note: The Nested Teams API is currently available for developers to preview. See the blog post for full details. To access the API, you must provide a custom media type in the Accept
header:
application/vnd.github.hellcat-preview+json
Warning: The API may change without advance notice during the preview period. Preview features are not supported for production use. If you experience any issues, contact your GitHub Enterprise site administrator.
To add a repository to a team or update the team's permission on a repository, the authenticated user must have admin access to the repository, and must be able to see the team. The repository must be owned by the organization, or a direct fork of a repository owned by the organization. You will get a 422 Unprocessable Entity
status if you attempt to add a repository to a team that is not owned by the organization.
PUT /teams/:team_id/repos/:owner/:repo
| Name | Type | Description |
|---|---|---|
permission |
string |
The permission to grant the team on this repository. Can be one of: * pull - team members can pull, but not push to or administer this repository.* push - team members can pull and push, but not administer this repository.* admin - team members can pull, push and administer this repository.If no permission is specified, the team's permission attribute will be used to determine what permission to grant the team on this repository. Note: If you pass the hellcat-preview media type, you can promote—but not demote—a permission attribute inherited through a parent team. |
Note that, if you choose not to pass any parameters, you'll need to set Content-Length
to zero when calling out to this endpoint. For more information, see "HTTP verbs."
Status: 204 No Content


This is a developing full stack application that allows users to bookmark products onto wishlists. It was created using HTML5, CSS3, Bootstrap, Handlebars, Node JS, Express, MongoDB, Mongoose, Passport [authentication].
Check it out!Bamazon is a CLI app that will take in orders from customers and deplete stock from the store's inventory. The user will be prompted to select an item ID and the quantity of units they wish to purchase. This was created using a mySQL database.
Check it out!This is a simple application that uses the GIPHY API to populate the web page with gifs based on the user's input. Click on the gif to animate or pause. Created using Bootstrap and JQuery.
Check it out!Simple game where a random number is generated and the user must attempt to reach that score by clicking on crystals that have a random hidden value. Created using Bootstrap and JQuery.
Check it out!


This demo is to explain what OData, WebDAV are like. These two REST-based protocols are international standards widely used in various area other than personium also. More than 90% of personium API are based on these two standardized protocols. So application development using personium means application development against OData, WebDAV.
Before everything, just take a look at this simple demo application. app
The simple app above is operating only two APIs below.
| Data Name | Type | URL | Demo Request |
|---|---|---|---|
| Country Info | OData | https://baas-demo.demo.personium.io/1/odata/country_info | click |
| Country Name | OData | https://baas-demo.demo.personium.io/1/odata/country_name | click |
| Flag Images | WebDAV | https://baas-demo.demo.personium.io/1/flags/ | click |
OData provides RESTful interface for manipulating a relational data model. It enables various search like below.
| Senario | Description | Demo Request |
|---|---|---|
| Single value retrieval | retrieve a single record by specifying a key (__id value) | click |
| $orderby: sorting | sorting in the inverse order of Area_sqkm | click |
| $top: limiting the returned records | First 50 records in the search result are returned. Default value for $top is 25 in personium | click |
| $skip: pagenation | Skipping the first 50 records and return following 50 records from the search result. This is typically used for pagenation UI. | click |
| $filter: search condition | Like SQL "where" clause, various search condition with comparison, bool calculation etc. can be written in $filter. Example: records whose Goverment values match (eq) 'republic' | click |
| $inlinecount: hit count | You can let the response to linclude the hit count, the number of records that matches the condition, Hit count is returned with "__count" key. | click |
| Fulltext search | Example: "republic" (url encoding needed for non-ascii query) | click |
| Schema View | Schema information can be retrieved in EDMX format | click |
WebDAV is HTTP-based extended protocol. File operations are WebDAV Since WebDAV is entended HTTP, you can embed WebDAV endpoint URL in HTML files.
| Senario | Desciption | Demo Request |
|---|---|---|
| Upload | PUT Method for file upload. You can either create new resource or update existing one. Content-Type header value sent while uploading will be returned when downloading. | click |
| Download | GET Method for file download. Content-Type header value | click |
| List in a directory | PROPFIND method together with Depth header. The list of the | click |
| Delete | by sending DELETE method to the resource URL | click |
| Collision Detection | Optimal locking using ETag. Everytime you update a record, its ETag value changes. On updating or deleting a record, you may send ETag value of a file with If-Match request header and operation fails if the ETag value does not match. It happens when somebody else changes the record, so you can detect the collision of multile update or delete. | click |
| Create a folder | use special MKCOL method to create a collection (folder / directory in WebDAV terminology) | click |
| Delete a folder | DELETE method for deleting a collection (folder, directory).It fails if it has contents, ie. files or subdirectories. | click |


--- layout: page title: "About Me" ---
👋 I'm a computer engineer based in Turkey. I started Pardinus Software Company in 2010. Currently, I build software at Pardinus with my team.
Some of my main interest areas are Machine Learning, Web Scraping, Operating System Design and Web Servers.
Publications
Links
Follow me on twitter: @onepase, for more information about my professional career visit my Linkedin Profile


The Nanook::Block
class contains methods to discover
publicly-available information about blocks on the nano network.
A block is represented by a unique hash
Initialize this class through the convenient Nanook#block method:
nanook = Nanook.new
account = nanook.block("991CF19...")
Or compose the longhand way like this:
rpc_conn = Nanook::Rpc.new
block = Nanook::Block.new(rpc_conn, "991CF19...")
- A
- C
- G
- H
- I
- N
- P
- R
- S
Source: show
# File lib/nanook/block.rb, line 19 def initialize(rpc, block) @rpc = rpc @block = block block_required! # All methods expect a block end
Source: show
# File lib/nanook/block.rb, line 25 def account rpc(:block_account, :hash)[:account] end
Source: show
# File lib/nanook/block.rb, line 29 def cancel_work rpc(:work_cancel, :hash).empty? end
Source: show
# File lib/nanook/block.rb, line 33 def chain(limit: 1000) response = rpc(:chain, :block, count: limit)[:blocks] Nanook::Util.coerce_empty_string_to_type(response, Array) end
Source: show
# File lib/nanook/block.rb, line 38 def generate_work rpc(:work_generate, :hash)[:work] end
Source: show
# File lib/nanook/block.rb, line 42 def history(limit: 1000) rpc(:history, :hash, count: limit)[:history] end
Source: show
# File lib/nanook/block.rb, line 50 def info(allow_unchecked: false) if allow_unchecked # TODO not actually sure what this response looks like when it's not an unchecked block, assuming its blank response = rpc(:unchecked_get, :hash) if response[:error] != "Block not found" return _parse_info_response(response ) end # Continue on falling backto checked block end response = rpc(:block, :hash) _parse_info_response(response) end
Source: show
# File lib/nanook/block.rb, line 64 def is_valid_work?(work) response = rpc(:work_validate, :hash, work: work) !response.empty? && response[:valid] == 1 end
Source: show
# File lib/nanook/block.rb, line 83 def pending? response = rpc(:pending_exists, :hash) !response.empty? && response[:exists] == 1 end
Source: show
# File lib/nanook/block.rb, line 88 def process rpc(:process, :block)[:hash] end
Source: show
# File lib/nanook/block.rb, line 69 def republish(destinations:nil, sources:nil) if !destinations.nil? && !sources.nil? raise ArgumentError.new("You must provide either destinations or sources but not both") end # Add in optional arguments params = {} params[:destinations] = destinations unless destinations.nil? params[:sources] = sources unless sources.nil? params[:count] = 1 unless params.empty? rpc(:republish, :hash, params)[:blocks] end


--- layout: default title: tutorials permalink: /tutorial/ navpos: 3 nav: true ---
These tutorials are full in-depth step-by-step guides to learn things about statistics and how to use R. Some of them are part of a whole series of tutorials.


|
iDreamSky Game Engine
v1.0.0
|
#include <CameraComponent.h>
公開型態 | |
| enum | ClearFlag { CLEAR_NONE = 0x00, CLEAR_COLOR = 0x01, CLEAR_DEPTH = 0x02, CLEAR_STENCIL = 0x04, CLEAR_SKYBOX = 0x08 } |
公開方法(Public Methods) | |
| CameraComponent (Component::Owner &owner_) | |
| CameraComponent Constructor. 更多... | |
| virtual | ~CameraComponent () |
| CameraComponent Destructor. 更多... | |
| PROPERTY (int, Order) | |
| Set the Rendering Order of this Camera. 更多... | |
| PROPERTY (unsigned int, TargetLayer) | |
| Set the value of the TargetLayer of this Camera. 更多... | |
| PROPERTY (int, ClearFlags) | |
| Set the Clearing Flags of this Camera. 更多... | |
| PROPERTY (ColorRGBA, ClearColor) | |
| Set the Clear Color of this Camera. 更多... | |
| PROPERTY (float, ClearDepth) | |
| Set the Clear Depth of this Camera. 更多... | |
| PROPERTY (unsigned int, ClearStencil) | |
| Set the Clear Stencil of this Camera. 更多... | |
| PROPERTY (Vector4, Viewport) | |
| Set the Viewport of this Camera. 更多... | |
| void | setProjectionPlanes (float left_, float right_, float bottom_, float top_, float nearPlane_, float farPlane_) |
| Set the coordinate of project plane of at the near plane of camera. 更多... | |
| void | getProjectionPlanes (float &left_, float &right_, float &bottom_, float &top_, float &nearPlane_, float &farPlane_) const |
| Get the coordinate of project plane of at the near plane of camera. 更多... | |
| const Matrix4 & | getProjectionTransform () |
| Get the project transform of this camera. 更多... | |
| bool | isLayerMatched (unsigned int layer) const |
| Check if the parameter layer matches TargetLayer to this camera. 更多... | |
| 公開方法(Public Methods) 繼承自 IDreamSky::Component | |
| Component (Component::Owner &owner_) | |
| CLASS (Component, agm::reflection::NullClass) | |
| PROPERTY (bool, Enabled) | |
| Set the Enabled State of Owner, if the component is not active, it become non functional. 更多... | |
| PROPERTY (String, Name) | |
| Set the Name of Owner. 更多... | |
| Component::Owner & | getOwner () |
| const Component::Owner & | getOwner () const |
| virtual bool | isEditorModeActive () const =0 |
靜態公開方法(Static Public Methods) | |
| static int | compare (const void *left, const void *right) |
保護方法(Protected Methods) | |
| virtual bool | onConstruct () |
| Handle Construct Event of the Component. 更多... | |
| virtual void | onStart () |
| Handle Start Event of the Component. | |
| virtual void | onUpdate (float dt) |
| Handle Update Event of the Component. 更多... | |
| virtual void | onPause () |
| Handle Pause Event of the Component. | |
| virtual void | onResume () |
| Handle Resume Event of the Component. | |
| virtual void | onStop () |
| Handle Stop Event of the Component. | |
| virtual void | onDestruct () |
| Handle Destruct Event of the Component. | |
| virtual void | onDebugRender (IComponentDebugRenderer &debugRenderer)=0 |
| Handle Debuger Rendering Event of the Component. | |
| void | inValidateProjectionTransform () |
| mark the member variable projectTransformValid is invalide and should be update before next render | |
| virtual void | onValidateProjectionTransform (Matrix4 &projectTransform) const =0 |
| This is a pure virtual function. 更多... | |
類別朋友(Friends) | |
| class | Video::Manager |
| CameraComponent::CameraComponent | ( | Component::Owner & | owner_ | ) |
CameraComponent Constructor.
To Construct the CameraComponent for the owner.
| owner_,the | Component::Owner which owns this component. |
|
virtual |
CameraComponent Destructor.
To Destruct CameraComponent and remove from its owner.
| void CameraComponent::getProjectionPlanes | ( | float & | left_, |
| float & | right_, | ||
| float & | bottom_, | ||
| float & | top_, | ||
| float & | nearPlane_, | ||
| float & | farPlane_ | ||
| ) | const |
Get the coordinate of project plane of at the near plane of camera.
| left_,float,the | left side frustum x coordinate in this camera space is returned thru this parameter |
| right_,float,the | right side frustum x coordinate in this camera space is returned thru this parameter |
| bottom_,float,the | bottom side frustum y coordinate in this camera space is returned thru this parameter |
| top_,float,the | top side frustum y coordinate in this camera space is returned thru this parameter |
| nearPlane_,float,the | near side frustum z coordinate in this camera space is returned thru this parameter |
| farPlane_,float,the | far side frustum z coordinate in this camera space is returned thru this parameter |
| const Matrix4 & CameraComponent::getProjectionTransform | ( | ) |
| bool CameraComponent::isLayerMatched | ( | unsigned int | layer | ) | const |
Check if the parameter layer matches TargetLayer to this camera.
| layer,unsigned | int, the layer to be check |
|
protectedvirtual |
Handle Construct Event of the Component.
依據IDreamSky::Component重新實作.
|
protectedvirtual |
|
protectedpure virtual |
This is a pure virtual function.
all sub class should implement this function for their own version of project transform.
| projectTransform,Matrix4,the | layer to be check. |
| IDreamSky::CameraComponent::PROPERTY | ( | int | , |
| Order | |||
| ) |
Set the Rendering Order of this Camera.
| value_,int,the | Rendering Order of this Camera Get the Rendering Order of this Camera |
| IDreamSky::CameraComponent::PROPERTY | ( | unsigned | int, |
| TargetLayer | |||
| ) |
Set the value of the TargetLayer of this Camera.
This camera will only render those Entities with the Layer equal to camera's TargetLayer.
| value_,unsigned | int, the value of the TargetLayer of this Camera Get the TargetLayer of this Camera |
| IDreamSky::CameraComponent::PROPERTY | ( | int | , |
| ClearFlags | |||
| ) |
Set the Clearing Flags of this Camera.
ClearFlag can be any one of those specified in CameraComponent::Clearing Flags
| value_,int,the | Clearing Flags of this Camera. Get the Clearing Flags of this Camera. ClearFlag can be any one of those specified in CameraComponent::Clearing Flags |
| IDreamSky::CameraComponent::PROPERTY | ( | ColorRGBA | , |
| ClearColor | |||
| ) |
| IDreamSky::CameraComponent::PROPERTY | ( | float | , |
| ClearDepth | |||
| ) |
Set the Clear Depth of this Camera.
| value_,float,the | Clear Depth of this Camera. Get the Clear Depth of this Camera. |
| IDreamSky::CameraComponent::PROPERTY | ( | unsigned | int, |
| ClearStencil | |||
| ) |
Set the Clear Stencil of this Camera.
| value_,unsigned | int, the Clear Stencil of this Camera. Get the Clear Stencil of this Camera. |
| IDreamSky::CameraComponent::PROPERTY | ( | Vector4 | , |
| Viewport | |||
| ) |
| void CameraComponent::setProjectionPlanes | ( | float | left_, |
| float | right_, | ||
| float | bottom_, | ||
| float | top_, | ||
| float | nearPlane_, | ||
| float | farPlane_ | ||
| ) |
Set the coordinate of project plane of at the near plane of camera.
| left_,float,the | left side frustum x coordinate in this camera space |
| right_,float,the | right side frustum x coordinate in this camera space |
| bottom_,float,the | bottom side frustum y coordinate in this camera space |
| top_,float,the | top side frustum y coordinate in this camera space |
| nearPlane_,float,the | near side frustum z coordinate in this camera space |
| farPlane_,float,the | far side frustum z coordinate in this camera space |


Ezekiel 34:24
And I the LORD will be their God, and my servant David a prince among them; I the LORD have spoken it.


{% load static %}
Django Demo App
Poll Details - {{ employee_name }}
Employee Id: {{ employee_id }}
Employee Name: {{ employee_name }}
Job Title: {{ job_title }}
Hire Date: {{ hire_date }}


Before Change
status = "UNKNOWN"
if self._rs_codes is not None:
statuscode = str(statuscode).strip()
for i in self._rs_codes:
val = str(self._rs_codes[i]).strip()
if "," in val:
splitted = val.split(",")
for code in splitted:
code = str(code).strip()
if statuscode == code:
status = i.upper()
break
elif statuscode == val:
status = i.upper()
break
return status
def parsestatus(self, status):
Parse the status.
After Change
def lookupstatusfromcode(self, statuscode):
Look at the rs_codes and returns the status from the code.
status = next((
status_group.upper() for status_group, codes
in self._rs_codes.items() for code in codes
if statuscode == code), "UNKNOWN")
return status


Moss: No. What do you mean? Have I talked to him about this... [pause]
Aaronow: Yes. I mean are you actually talking about this, or are we just...
Moss: No, we're just...
Aaronow: We're just "talking" about it.
Moss: We're just speaking about it. [pause] As an idea.
Aaronow: As an idea.
Moss: Yes.
Aaronow: We're not actually talking about it.
Moss: No.
Aaronow: Talking about it as a...
Moss: No.
Aaronow: As a robbery.
Moss: As a "robbery"? No.
Aaronow: Yes. I mean are you actually talking about this, or are we just...
Moss: No, we're just...
Aaronow: We're just "talking" about it.
Moss: We're just speaking about it. [pause] As an idea.
Aaronow: As an idea.
Moss: Yes.
Aaronow: We're not actually talking about it.
Moss: No.
Aaronow: Talking about it as a...
Moss: No.
Aaronow: As a robbery.
Moss: As a "robbery"? No.
American writer David Mamet is probably most famous for his distinctive style of writing fast, clever, edgy dialogue. When a playwright wins a Pulitzer Prize, his style does not often go without imitation. Mamet's often-imitated dialogue style is called Mamet Speak.
Mamet Speak has the following qualities:
- It is fast. Characters speak in quick succession, frequently cutting each other off, finishing each other's sentences, and repeating themselves whilst the other speaks.
- It is loaded with jargon. If two characters work in the same field, expect them to use words and concepts specific to that field without stopping or even slowing down to make sure the non-professional audience can follow along. Consequently, expect as little Exposition as possible.
- It is frequently focused on semantics. Mamet's characters are known for manipulating language itself to get what they want, or at least discussing the importance of their particular language.
- It is almost always "vulgar". In keeping with Mamet's general domain of tough-talking characters, Cluster F-Bomb is the name of the game. (Roger Ebert once titled a Movie Glossary entry the "Mamet Dammit" while noting that the swears in question usually weren't that mild.)
Compare Rapid-Fire Interrupting, where the interrupting is one-sided. Also related to World of Snark.
Examples:
open/close all folders
Comic Books
- Brian Michael Bendis does this in all of his works and with most characters (as seen in the image), some even call him the "Mamet of Comics". He variously refers to Mamet as his god, his hero and his go-to source of inspiration.
Films — Live-Action
- Quentin Tarantino has listed David Mamet as one of the key inspirations for his own style of dialogue.
- Iron Man 2 ramped this up immensely from the first one, in that other characters aside from Tony Stark started doing it.
- Some of the dialogue in Primer is like this, with characters talking over each other and answering with quick, short lines.
- 40's film director Howard Hawks favored a style of dialog similar to Mamet's, especially in terms of speed and overlap. He had to do without the cussing, of course.
- Possibly referenced in a couple lines of dialogue from The Toxic Avenger Part II, of all places:
Apocalypse Inc. Chairman: "Neither a borrower, nor a lender be"... Shakespeare.
Homeless Woman: "Fuck You"... David Mamet.
Literature
- Invoked in Peter Benchley's Q Clearance. The protagonist, who is normally very erudite and a devotee of Samuel Johnson, is being given a "The Reason You Suck" Speech by his soon-to-be-estranged wife. The narration notes that, as Johnson had nothing to say about this kind of situation, the protagonist falls back on Mamet:
"Fuck you, Joan of Arc!"
- Elmore Leonard was doing this years before Mamet.
Live-Action TV
- Aaron Sorkin's distinctive dialogue style (as heard in The West Wing, Studio 60, and The Newsroom) is similar, though with less cursing and less of characters talking over each other. And arguably more Author Filibusters.
- The Thick of It uses this, although it has indulgent fun with particularly surreal swearing.
Theater
- Naturally, the works of David Mamet himself.
- Adjusted somewhat in Boston Marriage, which is set in the 19th century instead of contemporary times. It's relatively restrained when it comes to vulgar language, for one thing, leaning more toward the Precision F-Strike than the Cluster F-Bomb (but the f-bomb does indeed get dropped).
- Joyce Carol Oates' Tone Clusters, while scant on the swearing, contains a great deal of the Gulicks rapidly talking over one another at great length, and constantly repeating one another.
- The first scene between Roy and Joe in Angels in America contains a lot of this, with Joe's attempts to get a word in edgewise between Roy's onslaughts of speech.
- Neil La Bute uses a lot of this, particularly in reasons to be pretty and In a Dark, Dark House.
- Extra Pulp is completely built around this trope. All of the characters speak in short, profanity-ridden sentences that overlap and repeat each other.
- Parodied in "Speed-the-Play" by David Ives.
- Ensemble numbers in Stephen Sondheim musicals sometimes approach this, with characters quickly interjecting comments with sixteenth-note precision. In "Another National Anthem" from Assassins, the following lines are sung in quick succession:
Byck: Yeah, it's never gonna happen, is it? No, sir.
Czogolsz: Never.
Byck: No, we're never gonna get the prize—
Fromme: No one listens.
Byck: Are we?
Zangara: Never!
Byck: No, it doesn't make a bit of difference, does it?

Others: Spread the word...
Web Videos
- Each episode being only a few minutes long at most, Hey Ash, Whatcha Playin'? is rife with constant dialogue back and forths, snappy sentences and a fair amount of cursing.
- A delicious send-up of a possible dialogue from the upcoming Anne Frank movie is here.
Western Animation
- Archer is a great example, with every character getting in on the fun.
- Similarly, BobsBurgers fits this as well.
Real Life
- Tiger Woods' proclivity for profanity after an awry golf shot led Sports Illustrated writer Joe Posnanski to write, "When he hits a shot that's only 90% perfect, Woods rants like he's in a David Mamet production."
- Frequent Mamet collaborator William H. Macy was once asked in an interview if David Mamet could finish a sentence without a Cluster F-Bomb. His response? "Absofuckinglutely!"


Toggle navigation
Forecasting Tomatoes
Existing Movie
New Movie
About
Director
Predicted Rating:
N/A
Writer
Actor


Only one page in each package acts as the "index page" for that package. The index page is used for breadcrumb links.
The index page is located by capitalising the package name and appending ".html". If no index page is found for a package then no breadcrumb for that package is displayed.
For non-index pages within a package, the index page of the package is included as a breadcrumb link in addition to parent package breadcrumb links.
Given the following source files:
| Filename | Remarks |
|---|---|
/spec/admin/Admin.html |
|
/spec/admin/user/user.html |
Not capitalised, so is not an index page despite the same wording. |
/spec/admin/user/AnotherPage.html |
|
/spec/admin/user/deletingUsers/DeletingUsers.html |
|
/spec/admin/user/deletingUsers/SecurityIssues.html |
We expect these breadcrumbs to be generated:
| Resource Name | Breadcrumb Text |
|---|---|
/spec/admin/Admin.html |
|
/spec/admin/user/user.html |
Admin > |
/spec/admin/user/AnotherPage.html |
Admin > |
/spec/admin/user/deletingUsers/DeletingUsers.html |
Admin > |
/spec/admin/user/deletingUsers/SecurityIssues.html |
Admin > Deleting Users > |


"Hello traveler", says the hooded man. "I see you are a brave traveler for daring to try this maze, but why go through the trouble? If you will but accept my hand, I will transport you to the treasure that hides within these walls, easy as that! What do you say?"