Web Developer from Austria
You are using Internet Explorer or any other antique browser. You might experience some malfunctions while visiting this website.
Hello, my name is David Schwarz and I am a young, (mostly) motivated and
coffee addicted programmer, searching for new adventures. Currently I am studying Smart Engineering at FH
St. Pölten and working as frontend developer at
nu-IT.
In my spare time I enjoy skiing,
hiking or going out.
Do you want to get in touch? Use the contact form and say hello ;)
Bachelor course in Smart Engineering of Production Technologies and Processes
Economic Computer Science - Bachelor course
College degree in computer science and media technology
Frontend Developer
Internship as Webdesigner and Webdeveloper
This was a website for a small coffee shop combined with a library in vienna. The website is mobile friendly and runs with wordpress.
This was one of my very first projects I made completely by myself. Starting with the concept, followed by the screendesign, coding and finalized with a lightweight custom cms written in PHP.
As part of a school project, a classmate and me developed a webbased registration and administration software for a local ski course organizer. Three years later, the tool is still in use


title Exec Client->+Server: exec ( endpoint, params ) Server->+Method: authorize ( ) Method-->-Server: authorized alt authorized == true Server->+Method: exec ( params ) Method-->-Server: results Server-->-Client: exec_results ( results ) else authorized == false Server->Client: error ( UNAUTHORIZED ) end


<% include ./layout/header.html %>
<% include ./layout/leftmenu.html %> <%- body %>
<% include ./layout/footer.html %>


We invite you to attend the 15th IEEE International Conference on Advanced Video and Signal-based Surveillance (AVSS), to be held 27-30 November 2018 in Auckland, New Zealand, hosted by Auckland University of Technology.
- AVSS 2018 General Co-Chairs, Reinhard Klette (Auckland) and Mohan Kankanhalli (Singapore)
AVSS focuses on underlying theory, methods, systems, and applications of surveillance and invites submissions in areas listed below, especially cross-disciplinary and game-changing ones. AVSS is the
premier annual international conference in the field of video and signal-based surveillance that brings together experts from academia, industry, and government to advance theories, methods,
systems, and applications related to surveillance.
AVSS is sponsored by the IEEE, in particular the IEEE Signal Processing Society (IVMSP TC) and the IEEE Computer Society (PAMI TC).
There will be a main conference as well as multiple associated workshops, and the AVSS2018 proceedings will be published by the IEEE.
Important Dates: Preliminary Abstract Submission: 1 June 2018 [Not Compulsory] Paper Submission Due: 15 June 2018 30 June 2018 (23:59:59 PST) Notification to Authors: 1 September 2018 Early-bird Registration Deadline: 15 September 2018 Workshop Papers Due: 7 September 2018 Camera Ready Papers Due: 15 September 2018 Earlybird Registration for workshop papers: 22 Oct 2018 Conference Dates: 27-30 November 2018


Mumbai Hackathon 2017 Results
Winners
{% for member in winner.team_members %} {{member}} {% if not loop.index == loop.length %} {% endif %} {% endfor %}
1st Runner-ups
2nd Runner-ups
Check out other projects made at Mumbai Hackathon


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.atm.javadoc.sample.ATM
public class ATM
An ATM that accesses a bank.
| Field Summary | |
|---|---|
static int |
ACCOUNT
|
static int |
CHECKING
|
private BankAccount |
currentAccount
|
private Customer |
currentCustomer
|
private int |
customerNumber
|
static int |
PIN
|
static int |
SAVINGS
|
static int |
START
|
private int |
state
|
private Bank |
theBank
|
static int |
TRANSACT
|
| Constructor Summary | |
|---|---|
ATM(Bank aBank)
Constructs an ATM for a given bank |
| Method Summary | |
|---|---|
void |
back()
Moves back to the previous state. |
void |
deposit(double value)
Deposits amount to current account. |
double |
getBalance()
Gets the balance of the current account. |
int |
getState()
Gets the current state of this ATM. |
void |
reset()
Resets the ATM to the initial state. |
void |
selectAccount(int account)
Sets current account to checking or savings. |
void |
selectCustomer(int pin)
Finds customer in bank. |
void |
setCustomerNumber(int number)
Sets the current customer number and sets state to PIN. |
void |
withdraw(double value)
Withdraws amount from current account. |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
public static final int CHECKING
public static final int SAVINGS
private int state
private int customerNumber
private Customer currentCustomer
private BankAccount currentAccount
private Bank theBank
public static final int START
public static final int PIN
public static final int ACCOUNT
public static final int TRANSACT
| Constructor Detail |
|---|
public ATM(Bank aBank)
aBank
- the bank to which this ATM connects| Method Detail |
|---|
public void reset()
public void setCustomerNumber(int number)
number
- the customer number.public void selectCustomer(int pin)
pin
- the PIN of the current customerpublic void selectAccount(int account)
account
- one of CHECKING or SAVINGSpublic void withdraw(double value)
value
- the amount to withdrawpublic void deposit(double value)
value
- the amount to depositpublic double getBalance()
public void back()
public int getState()
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


{% extends "layout.html" %} {% block content %}
It may take up to a minute or so.
Please wait
This is one-time operation. If it takes too long, open passhub.net in a laptop or desktop browser and scan the QR code with WWPass Key app


Structure
| Namespaces | 315 | |
| Interfaces | 239 | |
| Traits | 54 | |
| Classes | 2456 | |
| Abstract Classes | 112 | (4.56%) |
| Concrete Classes | 2344 | (95.44%) |
| Methods | 13915 | |
| Scope | ||
| Non-Static Methods | 12857 | (92.4%) |
| Static Methods | 1058 | (7.6%) |
| Visibility | ||
| Public Method | 11333 | (81.44%) |
| Non-Public Methods | 2582 | (18.56%) |
| Functions | 869 | |
| Named Functions | 445 | (51.21%) |
| Anonymous Functions | 424 | (48.79%) |
| Constants | 662 | |
| Global Constants | 31 | (4.68%) |
| Class Constants | 631 | (95.32%) |
Tests
| Classes | 0 | |
| Methods | 0 |
Size
| Lines of Code (LOC) | 291190 | |
| Comment Lines of Code (CLOC) | 93771 | (32.2%) |
| Non-Comment Lines of Code (NCLOC) | 197419 | (67.8%) |
| Logical Lines of Code (LLOC) | 49783 | (17.1%) |
| Classes | 48888 | (98.2%) |
| Average Class Length | 18 | |
| Average Method Length | 3 | |
| Functions | 769 | (1.54%) |
| Average Function Length | 1 | |
| Not in classes or functions | 126 | (0.25%) |
Complexity
| Cyclomatic Complexity / LLOC | 0.32 | |
| Cyclomatic Complexity / Number of Methods | 0 |
Dependencies
| Global Accesses | 683 | |
| Global Constants | 431 | (63.1%) |
| Global Variables | 98 | (14.35%) |
| Super-Global Variables | 154 | (22.55%) |
| Attribute Accesses | 16550 | |
| Non-Static | 15999 | (96.67%) |
| Static | 551 | (3.33%) |
| Method Calls | 32248 | |
| Non-Static | 28861 | (89.5%) |
| Static | 3387 | (10.5%) |


It’s a device I made/ programmed to display what movies I need to check out, chores I’m neglecting, what side projects I’ve ginnned up to keep myself entertained.
Glen you fiendishly handsome devil, why do you need something like this? Well my flattering reader I do occasionally find myself watching a season of Rick & Morty that I’ve seen so many times I could probably rattle off the lines easier than the pledge of allegiance while guiltily thinking “aren’t there about a million things I want to check out right now, why can’t I remember a single one of them?”. I built this machine to stop myself from aimlessly slouching around on the couch… and because it looks super fly in my living room.
Finer details can be found here in the repo
Hidden by default because it looks like the Epic of Gilgamesh when I lay it all out at once but I know some people really dig this kind of info and I don't want to disappolin them.
This is my testing ground for interesting layouts, new font usage, and seeing if I can make certain colors work together so the overall theme is “whatever looks cool”. If you refresh the list, a new theme will pop up. At the point in time I’m writing this, there are 3 different themes it cycles through on refresh.
That’s a hand-drawn, laser engraved chunk of wood covering the front so buckle up kiddo, it’s a bit of a story.
So my brother and I were chilling out (possibly watching Rick & Morty again) and he remarked that my house had good vibes out the yin-yang… well what he actually said was that my house felt like a song by Seven Lions titled “Calling You Home” which he played for me and lemme tell ya, having the apartment I’ve put together compared to that song was one of the highest compliments I’ve ever been given.
After hearing it, I knew I would have to work that song into my home somewhere and being that I was already fixated on building a cool case for my motivational gizmo, I had a good idea of where it would end up. The only question left was how to make something which felt like that song and the case design you see is my answer.
Did the engraving myself, I totally went out and got trained on how to work a big ol’ laser at a maker space called TC Maker (shout out!) in the twin cities.
The easiest way to explain is to check out the repo, in specific this file is where the party's at.
The code work was probably the easiest part of this project as most of what I consider the tricky stuff was grabbed from an earlier project of mine so most of the focus was on making the code as easy to read as possible so the main custom.js file is TRICKED OUT with comments on what each line is doing.
You asked for it...
Gotcha covered, fam!
//Wrap everything in a function because... well them's the rules! function glenToDo() { //Make a call to the mighty Google Sheets API and pray for a response /*The way this call works is really cool! You can check out the details of what each bit of the URL-thing below is doing at: https://developers.google.com/sheets/api/guides/concepts Sidenote: if you copy + paste the URL below into your browser you can see the array in a totally useless but kinda interesting way (no viruses, pinky swear!)*/ var json = $.getJSON("https://sheets.googleapis.com/v4/spreadsheets/1ZDI3TOYKbliJxHWt76d_-ay6sz0e2OpA6LB63vuKKlk/values/'To Do'/?key=AIzaSyA1T4CcA8nnxMfxShN7Blrinr9y7LL5CzY", function(json) { //Reset card values on each run of the function $('.card').remove(); //Response granted, no need to light any more incense! /*Got the whole JSON object from the API call in a single variable called 'json'. Below we are setting up some ground rules for what I'll be keen to know about going forward, in specific I'll be needing to know how many rows are in the sheet which I get from json.values.length so I hook that value to the variable 'y' */ for (var x = 0, y = json.values.length; x < y; x++) { //Now we iterate things based on the idea we should do something based on the number of rows for (var i = 0; i < y; i++) { /*Below we are setting one array "coordinate" to change each time we run this little loop (variable i is saying switch which sub-array is being looked at ever iteration but always look at the same value within the new sub-array), and another that swaps each time we do a larger loop rotation (variable x is saying to look at a new value within each sub-array we cycle through)*/ var valList = json.values[i][x]; //Loop the JSON values till you run out of stuff to spit out but don't add any HTML if you're just adding blank HTML elements if (valList != '' && valList != null && valList != ' ') { //On first loop iteration, make a new card with an unordered list in it if (i == 1) { $('.card-columns').append(''); //Make the first value an H2 header $('.card:last-of-type ul').append('' + valList + '
'); } else { //Make all values other than the first in a column basic list objects $('.card:last-of-type ul').append('
I made a super techy and slick looking to-do list


SRCCON 2016 takes place at the Pacific Northwest College of Art, a beautifully restored and renovated 1918 building near downtown Portland, Oregon. Portland offers excellent restaurants, cafés, and breweries in a walkable, transit-friendly city, and easy day-trips include hiking around Mt. Hood and the gorgeous—and often sunny—Oregon coast. Over the next six weeks, we’ll continue to publish lots of information to help you get the most out of your time at SRCCON and—for those who aren’t local—explore the surrounding areas as well.
SRCCON will run from 9am till 10pm on Thursday, July 28 (including breakfast and non-session evening activities), and from 10am till 6pm on Friday, July 29. We’ll publish a full session schedule in July!
Our discounted room block at the Marriott Courtyard Portland City Center, 550 SW Oak Street, is fully booked. There are still rooms available at the hotel, but they are regular rate (with slight discounts reported via various online booking systems). There are lots of other hotels available near the conference venue, including:
The Benson ($269)
0.4 miles away
309 Southwest Broadway
Portland, OR 97205
(503) 228-2000
Hotel Lucia ($237)
0.4 miles away
400 SW Broadway
Portland, OR 97205
(503) 225-1717
Ace Hotel ($195/$295)
0.5 miles away
1022 Southwest Stark Street
Portland, OR 97205
(503) 228-2277
The Westin Portland ($269)
0.5 miles away
750 SW Alder St
Portland, OR 97205
(503) 294-9000
Hotel Monaco ($290)
0.6 miles away
506 Southwest Washington Street
Portland, OR 97204
(503) 222-0001
Portland’s MAX Light Rail system is an easy way to get around the city. You can take the Red Line from the airport to the Oak/SW 1st Ave station for $2.50. That will drop you off about 4 blocks from the conference hotel.
Thursday night, join us for SRCCON’s evening fun: we’ll be hosting games, lightning talks, and other activities. There will be local beverages and snacks, and much more. Learn more and sign up now.
We are offering free, on-site childcare throughout the full SRCCON schedule (including Thursday evening) at the Marriott Courtyard Portland City Center via the genuinely great team at KiddieCorp. Childcare registration is now closed—if you missed the deadline and need childcare, please contact us, and we’ll add you to the wait list.
Some of you are coming to Portland with partners and have wondered if they can take part in any of our activities. We’re happy to say that they’re welcome to join us for Thursday evening’s meal and activities, with a special $45 partner ticket that you can purchase now.
We want you to be happy and well-fed at SRCCON, so we’re providing breakfast and lunch on both days, as well as a delicious dinner Thursday night. We’ll also have tea, coffee, and snacks—both healthy and sugary—throughout the day, so stick around and enjoy the company of your fellow attendees.
On Thursday night, the closest meeting to SRCCON is at 8pm at the Portland Alano Club, 909 Northwest 24th Avenue. It is an “open” meeting, meaning that you don’t have to be alcoholic to go. AA Portland also hosts a full list of area meetings.
If you’d like to let the rest of the conference know you’ll be there, you can add your name to the attendee list.


Toggle navigation
Home
Chat
My Profile
Settings
What your friends have done.
Feed
My goals
Worldwide


'Kevin Dowd's' book Measuring Market Risk is a widely read book in the area of risk measurement by students and practitioners alike. As he claims, 'MATLAB' indeed might have been the most suitable language when he originally wrote the functions, but, with growing popularity of R it is not entirely valid. As 'Dowd's' code was not intended to be error free and were mainly for reference, some functions in this package have inherited those errors. An attempt will be made in future releases to identify and correct them. 'Dowd's' original code can be downloaded from www.kevindowd.org/measuring-market-risk/. It should be noted that 'Dowd' offers both 'MMR2' and 'MMR1' toolboxes. Only 'MMR2' was ported to R. 'MMR2' is more recent version of 'MMR1' toolbox and they both have mostly similar function. The toolbox mainly contains different parametric and non parametric methods for measurement of market risk as well as backtesting risk measurement methods.
| Version: | 0.12 |
| Depends: | R (≥ 3.0.0), bootstrap, MASS, forecast |
| Suggests: | PerformanceAnalytics, testthat |
| Published: | 2016-03-11 |
| Author: | Dinesh Acharya |
| Maintainer: | Dinesh Acharya <dines.acharya at gmail.com> |
| License: | GPL-2 | GPL-3 [expanded from: GPL] |
| NeedsCompilation: | no |
| In views: | Finance |
| CRAN checks: | Dowd results |
| Reference manual: | Dowd.pdf |
| Package source: | Dowd_0.12.tar.gz |
| Windows binaries: | r-devel: Dowd_0.12.zip, r-release: Dowd_0.12.zip, r-oldrel: Dowd_0.12.zip |
| OS X binaries: | r-release: Dowd_0.12.tgz, r-oldrel: Dowd_0.12.tgz |
| Old sources: | Dowd archive |
Please use the canonical form https://CRAN.R-project.org/package=Dowd to link to this page.


Toggle navigation
Lead Source
Average MMR by Lead Source
Average MMR by Sales Rep
Average MMR by Credit Range


Set New Ensign Password
New Password
Your Password Must Contain:
Minimum of 8 characters
A lowercase letter
An uppercase letter
A number
Do Not Include:
Commonly used phrases
Your name or username
Your email address
Re-Enter New Password
*This
does not
affect your Church Account password.
Set New Password
VIEW ERROR MESSAGE


|
|
VS2008 package includes in standart nemerle distribution. VS2010 package can be compiled from sources
There is some ongoing work on the #D 3.0 addin with completion and stuff. readme.
We have several modes for various source code editors:
SciTE editor requires files from there.
A short documentation of available options:
- Tools/Compile - compilation with debug enabled and exetarget
- Tools/Build - compilation in release mode for windows (winexe target)
- Tools/Go - Compile + Run
- Tools/Console Build - compilation of console application in release mode
- Tools/Make a DLL
- Tools/Custom Build - compilation with custom parameters (set them in menu View/Parameters, in first field compiler's parameters, in second the target assembly extension, e.g. exe or dll)
- Tools/Run Last Exe
- Tools/Debbuger - fires GuiDebug from .NET SDK (choose exe file for debugging, open corresponding source file)
- F1 - run the documentation from .NET SDK
|
|
|


“Creation, Publication, and Governance of useful, usable content.”
A content strategy is the high-level vision that guides future content development to deliver against a specific business objective.
The purpose of a content strategy is to:
• ensure that the content is consistently aligned with the brand message and values.
• ensure that the content enhances brand’s credibility
• ensure that the content helps the brand to stand out from the competition
• ensure that the content delivers against the brand’s objectives


{% extends 'bridge/base.html' %} {% comment "License" %} % Copyright (c) 2019 ISP RAS (http://www.ispras.ru) % Ivannikov Institute for System Programming of the Russian Academy of Sciences % % Licensed under the Apache License, Version 2.0 (the "License"); % you may not use this file except in compliance with the License. % You may obtain a copy of the License at % % http://www.apache.org/licenses/LICENSE-2.0 % % Unless required by applicable law or agreed to in writing, software % distributed under the License is distributed on an "AS IS" BASIS, % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % See the License for the specific language governing permissions and % limitations under the License. {% endcomment %} {% load i18n %} {% load static %} {% load compress %} {% block head_block %} {% compress css file tagsmap %} {% endcompress %} {% compress js file tagsmap %} {% endcompress %} {% endblock %} {% block title %}{{ title }}{% endblock %} {% block body_block %}
{% for row in tree.table %} {% for cell in row %} {% if cell and cell.type == "tag" %} {% include 'marks/TagPopup.html' with tag=cell.value access=cell.access %} {% endif %} {% endfor %} {% endfor %}{% trans 'Parent' %}:
{% trans 'All children of the selected tag will be also removed' %}!


The Art of Pizza!!!
Our Menu
Hawaiian Pizza
Vegeterian Pizza
Chicken periperi
Pepperoni pizza
Fill in your order below please
Enter the details
Choose Pizza Size
Large @ ksh 1000
Medium @ ksh 800
Small @ ksh 600
Choose crust type
Thin Crust @ ksh 300
Fatbread Crust @ ksh 350
Cheese-Stuffed Crust @ ksh 400
Choose toppings
Brocolini
Potato
Olives
Mushrooms
Radicchio
Capsicum
Capers
Select amount of pizza
Submit
If you want your order delivered, fill in the required details.
DELIVERY IS 300 SHILLINGS
Name
Location
submit


{{ define "header" }}{{ partial "page-header.html" . }}{{ end }} {{ define "main" }} This is not the page you were looking for {{ end }}


AWS::EC2::NatGateway
The AWS::EC2::NatGateway
resource creates a network address translation (NAT)
gateway in the specified public subnet. Use a NAT gateway to allow instances in a
private subnet
to connect to the Internet or to other AWS services, but prevent the Internet from
initiating a
connection with those instances. For more information and a sample architectural diagram,
see
NAT Gateways in the
Amazon VPC User Guide.
Note
If you add a default route (AWS::EC2::Route
resource) that points to a NAT gateway, specify NAT gateway's ID for the route's
NatGatewayId
property.
Topics
Syntax
To declare this entity in your AWS CloudFormation template, use the following syntax:
JSON
{ "Type" : "AWS::EC2::NatGateway", "Properties" : { "AllocationId" :
String
, "SubnetId" :String
, "Tags" : [Resource Tag
, ... ] } }
YAML
Type: AWS::EC2::NatGateway Properties: AllocationId:
String
SubnetId:String
Tags: -Resource Tag
Properties
AllocationId
-
The allocation ID of an Elastic IP address to associate with the NAT gateway. If the Elastic IP address is associated with another resource, you must first disassociate it.
Required: Yes
Type: String
Update requires: Replacement
SubnetId
-
The public subnet in which to create the NAT gateway.
Required: Yes
Type: String
Update requires: Replacement
Tags
-
Specifies an arbitrary set of tags (key–value pairs) to associate with this resource. Use tags to manage your resources.
Required: No
Type: Resource Tag
Update requires: No interruption
Return Value
Ref
When you pass the logical ID of an AWS::EC2::NatGateway
resource to the
intrinsic Ref
function, the function returns the ID of the NAT gateway,
such as nat-0a12bc456789de0fg
.
For more information about using the Ref
function, see Ref.
Example
The following example creates a NAT gateway and a route that associates the NAT gateway with a route table. The route table must be associated with an Internet gateway so that the NAT gateway can connect to the Internet.
JSON
"NAT" : { "DependsOn" : "VPCGatewayAttach", "Type" : "AWS::EC2::NatGateway", "Properties" : { "AllocationId" : { "Fn::GetAtt" : ["EIP", "AllocationId"]}, "SubnetId" : { "Ref" : "Subnet"}, "Tags" : [ {"Key" : "foo", "Value" : "bar" } ] } }, "EIP" : { "Type" : "AWS::EC2::EIP", "Properties" : { "Domain" : "vpc" } }, "Route" : { "Type" : "AWS::EC2::Route", "Properties" : { "RouteTableId" : { "Ref" : "RouteTable" }, "DestinationCidrBlock" : "<IP_ADDRESS>/0", "NatGatewayId" : { "Ref" : "NAT" } } }
YAML
NAT: DependsOn: VPCGatewayAttach Type: AWS::EC2::NatGateway Properties: AllocationId: Fn::GetAtt: - EIP - AllocationId SubnetId: Ref: Subnet Tags: - Key: foo Value: bar EIP: Type: AWS::EC2::EIP Properties: Domain: vpc Route: Type: AWS::EC2::Route Properties: RouteTableId: Ref: RouteTable DestinationCidrBlock: <IP_ADDRESS>/0 NatGatewayId: Ref: NAT


Advanced Tips & Tricks
Using Amnesty with a subset of Dashboard widgets (Tiger only)
If you only use Amnesty with a select group of widgets, you may want to install copies of these widgets into the Amnesty widget library. Then, disable loading of the Dashboard User and Dashboard Default widget libraries in Preferences. This will keep your Amnesty menu much shorter, and free from those widgets you don't want to use (or that don't run) in Amnesty.
If you have a large widget library and your Amnesty menu is getting too long, you may want to group your widgets in the Amnesty widget library into subfolders. Each subfolder in this location will appear as a submenu under the Amnesty menu (in Tiger, this is how the Sample Widgets submenu is implemented).
Auto-installing widgets (Panther only)To automatically install widgets into the Amnesty widget library, drag and drop .wdgt files directly onto the Amnesty application icon (or double-click .wdgt files in the Finder). Note: if Amnesty is already running, you'll also need to refresh the widget list after auto-installing.
Creating multiple widget instancesAmnesty currently does not have built-in support for multiple widget instances, which means that you can't have more than one, for example, World Clock widget. You can however, work around this limitation with a little work:
2. Control-click the copy of the .wdgt file and select Show Package Contents from the submenu that appears. A Finder window will open showing the contents of the widget bundle.
3. Double-click the Info.plist file in this window. It should open in Apple's Property List Editor.
4. In the editor, click the disclosure arrow next to the word Root to reveal the contents of the file.
5. Modify the value of the CFBundleIdentifier key so that it is unique. For example, change "com.apple.widget.worldclock" to "com.apple.widget.worldclock2".
6. Close the editor and launch Amnesty. You should now have two, distinct widgets.
If you've placed widgets into the Desktop window level, you can use the Exposé Desktop mode (F11) to quickly reveal them. Similarly, you can use the Exposé All windows mode (F9) to help find widgets in the Standard window level.
Opening a Flash-based widget's popup menu (or Configuration sheet)If a widget is running and visible you cannot control-click it due to a Flash animation that is playing inside the widget, you can force the widget's popup menu to show by holding own the Control key while selecting it from the Amnesty menu. Similarly, holding down the Option key instead will force the Configuration sheet to appear.
Re-centering a widgetIf a widget is running and visible and you've lost it on your desktop (perhaps on a multiple monitor that has been disconnected), you can re-center on your main monitor by holding own the Shift key while selecting it from the Amnesty menu.
Resetting a widget's layout settingsIf a widget is closed, you can reset its layout settings (Location and Configuration) by holding down the Shift and Option keys while selecting it from the Amnesty menu. Upon opening, the widget's layout settings will be reset. This also works when selecting a layout from the Layout submenu (all closed widgets in the layout will have their layout settings reset).
Opening Amnesty in Safe ModeBy default, Amnesty remembers the last open layout and opens it the next time it is launched. If for some reason, a widget in this layout is causing Amnesty to crash or freeze, you can force Amnesty to launch with all widgets closed by holding down the Shift key at launch.
Manually resetting a widget's internal preferencesMost widgets have their own internal "back side" preferences that are used to save and restore certain settings. In some cases, you may want to remove these preferences to "reset" a widget that is not working properly:
2. Make a note of the Identifier field.
3. Close the widget.
4. In the Finder, open the Amnesty widget preferences folder (~/Library/Application Support/Amnesty/Preferences).
5. Move the file whose title matches the widget's Identifier to the Trash.
6. In Amnesty, open the widget. It should be reset.


eMarketer Daily - Best-Performing Tablet Ads; Pharma Steps to the Social Plate; Digital Buyers in Newcomer Emerging Markets


Chris Goad designed and implemented Fabl, with some code in the C kernel adapted from earlier work by Andrew Burgess. More specifically, the Fabl garbage collector and virtual machine draw on techniques used in implementing the Umbel language, an ancestor of Fabl whose C kernel was designed and coded by Andrew Burgess.


Barclays Bank Plc 65/66 St. Mary Axe London EC3A 8LE I am Mr. Gary Adams, Senior Credit Officer, Barclays Bank Plc London. I am writing following an opportunity in my office that will be of immense benefit to both of us. In my department we discovered an abandoned sum of £12.5million British Pounds Sterling (Twelve Million Five Hundred Thousand British Pounds Sterling) in an account that belongs to one of our foreign customers Late Mr. Morris Thompson an American who unfortunately lost his life in the plane crash of Alaska Airlines Flight 261, which crashed on January 31 2000, including his wife and only daughter. You shall read more about the crash on visiting this website. http://www.cnn.com/2000/US/02/01/alaska.airlines.list/ http://www.nativefederation.org/history/people/mThompson.html Since we got information about his death, we have been expecting his next of kin or relatives to come over and claim his money because the Bank cannot release the funds unless somebody applies for it as next of kin or relation to the deceased as indicated in our banking guidelines. Unfortunately I learnt that his supposed next of kin being his only daughter died along with him in the plane crash leaving nobody with the knowledge of this fund behind for the claim. It is therefore upon this discovery that I and two other officials in this department now decided to do business with you and release the money to you as the next of kin or beneficiary of the funds for safe keeping and subsequent disbursement since nobody is coming for it and we don't want this money to go back into Government treasury as unclaimed bill. We agreed that 20% of this money would be for you as foreign partner, while the balance will be for my colleagues and I. We will visit your country for the disbursement according to the percentages indicated above once this money gets into your account. Please be honest to me as trust is our watchword in this transaction. Note that this transaction is confidential and risk free. As soon as you receive this mail you should contact me by return mail whether or not you are willing to enter into this deal. In the event you are not interested, I sincerely ask that you disregard this email and tell no one about it. I am very careful on truncating my banking career should you mention this to someone else. I hope you can be trusted in this regard. Please note that all necessary arrangement for the smooth release of these funds to you has been finalized. We will discuss much in details when I do receive your response. Please in your response include your telephone and fax numbers for a better communication between us. You can reach me on the email below Best regards Gary Adams Email<EMAIL_ADDRESS>Fax: + 44 -<PHONE_NUMBER>


RT @slicknet: Dependency injection, or as it's also known, passing arguments.
8/28/2013, 8:02:21 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
RT @slicknet: Dependency injection, or as it's also known, passing arguments.
8/28/2013, 8:02:21 PM
Favs: 0
Retweets: 0
link


First things first: participating in this contest does
And if you want a programmer on you team, you can always form a team with one at our introductory meeting on January 24th!
Cutiepa2D (prounounced cutie-patootie) is javascript a framework built on top of CreateJS. It's for people with programming experience who don't want to deal with the boilerplate required to setup different scenes or give objects behavior like 8-directional movement. Games made with cutie can easily be thrown into a Windows 8 project, or can be put on pretty much any mobile platform you can think of with CocoonJS. Don't think games written in javascript will run smoothly? We've made games that have 100 sprites with physics running at 60fps.
Professor Spear used this Android framework in his ENGR 98 class. It was designed by Prof. Spear to introduce people to Java who never programmed before. In a couple of weeks, these students all went from zero programming experience to having fully functional Android games! Prof. Spear provides an excellent getting started guide on the Github wiki. No Android phone? No problem! Prof. Spear will be renting out Android phones for use during the competition at no cost.
Update: Here are the slides from the LOL workshop: Download
GameSalad is a fantastic drag-and-drop tool for developing iOS games. Their website provides an excellent set of tutorials telling you how to get starated. GameSalad also exports to Android and Windows 8, but unfortunately those options require a relatively expensive Pro account. Thankfully, iOS and HTML 5 exporting is free!
Construct 2 is another neat drag-and-drop tool that requires no programming. There's a great free version that allows you to export Windows 8 games, but you'll have to pay a significant sum to export iOS or Android games. Scirra's site has a ton of great video tutorials to help you on your way.


Namespace Adriva.Common.Core
Classes
AsyncQueueProcessor<TData>
The base class for processor classes that can process QueueMessages.
AutoStream
Represents a wrapper stream that keeps the stream in memory until the memory limit is reached then swaps it with a file stream.
Crc32
Provides methods to calculate the 32 bit CRC value for a given input.
Crc64
DynamicItem
Represents a class that can have dynamic properties and be casted to dynamic type.
GenericEqualityComparer<T>
Provides an implementation of IEqualityComparer<T> that uses the predicates for comparison operations.
HttpClientExtensions
Provides extension methods to help working with HttpClient class.
NdJsonSerializer
Provides methods to manage serialization into Newline Delimited Json format
NullDisposable
An empty object that can be disposed.
PagedResult<T>
Represents a single page of data items where there may be more pages.
ProcessWrapper
Provides functionality to start and track the status of an external process.
QueueMessage
Represents a message that can be used in a queue system.
QueueMessageFlags
SegmentedResult<T>
Utilities
Provides static utility methods to help with common and repetitive operations.
Interfaces
IAsyncQueueProcessor
Represents a processor class that is capable of processing queue messages.
IPagedResult
Represents a single page of a resultset which may have more pages.
ISegmentedResult
Represents a partial result set which may have more segments.


| Class and Description |
|---|
| DatasetDescription |
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Quad |
| QuerySolutionBase
Implementation of QuerySolution that contains the canonicalization and casting code.
|
| Transactional
Interface that encapulsated begin/abort|commit/close.
|
| Var
A SPARQL variable
|
| VarExprList |
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Quad |
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Quad |
| Class and Description |
|---|
| Quad |
| Class and Description |
|---|
| Quad |
| Class and Description |
|---|
| Quad |
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Quad |
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Quad |
| Var
A SPARQL variable
|
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Quad |
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| Quad |
| QuadPattern
A class whose purpose is to give a name to a collection of quads
|
| TriplePath
Like a triple except it can be a path or a triple.
|
| Var
A SPARQL variable
|
| VarExprList |
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| Var
A SPARQL variable
|
| VarExprList |
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| DatasetChanges
Interface for notification of changes
(adds and deletes of quads) to a DatasetGraph
|
| DatasetDescription |
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| DatasetGraphBase
DatasetGraph framework : readonly dataset need only provide find(g,s,p,o), getGraph() and getDefaultGraph()
although it may wish to override other operations and do better.
|
| DatasetGraphBaseFind
DatasetGraph framework.
|
| DatasetGraphCollection
Base class for implementations of a DatasetGraph as a set of graphs.
|
| DatasetGraphFactory.GraphMaker
Interface for making graphs when a dataset needs to add a new graph.
|
| DatasetGraphReadOnly
Read-only view of a DatasetGraph.
|
| DatasetGraphTrackActive
Check the transactional state of a DatasetGraph
|
| DatasetGraphTriplesQuads
A DatasetGraph base class for triples+quads storage.
|
| DatasetGraphWrapper |
| GraphView
Implement a Graph as a view of the DatasetGraph.
|
| PathBlock
A class whose purpose is to give a name to a collection of triple paths.
|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Quad |
| QuadAction
A
QuadAction is record of a type of change to a DatasetGraph . |
| QuadPattern
A class whose purpose is to give a name to a collection of quads
|
| QuerySolutionBase
Implementation of QuerySolution that contains the canonicalization and casting code.
|
| ResultBinding
A mapping from variable name to an RDF value.
|
| Transactional
Interface that encapulsated begin/abort|commit/close.
|
| TransactionalLock
An implementation of Tranactional that provides MRSW locking but no abort.
|
| TriplePath
Like a triple except it can be a path or a triple.
|
| Var
A SPARQL variable
|
| VarAlloc
Allocate variables
|
| VarExprList |
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| DatasetGraphBase
DatasetGraph framework : readonly dataset need only provide find(g,s,p,o), getGraph() and getDefaultGraph()
although it may wish to override other operations and do better.
|
| DatasetGraphBaseFind
DatasetGraph framework.
|
| DatasetGraphTriplesQuads
A DatasetGraph base class for triples+quads storage.
|
| DatasetPrefixStorage
Abstract of prefix storage for graphs in an RDF dataset
|
| GraphView
Implement a Graph as a view of the DatasetGraph.
|
| Quad |
| Transactional
Interface that encapulsated begin/abort|commit/close.
|
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Quad |
| Var
A SPARQL variable
|
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| Quad |
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| TriplePath
Like a triple except it can be a path or a triple.
|
| Var
A SPARQL variable
|
| VarExprList |
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| TriplePath
Like a triple except it can be a path or a triple.
|
| Var
A SPARQL variable
|
| VarExprList |
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| DatasetPrefixStorage
Abstract of prefix storage for graphs in an RDF dataset
|
| Quad |
| QuadPattern
A class whose purpose is to give a name to a collection of quads
|
| Var
A SPARQL variable
|
| VarExprList |
| Class and Description |
|---|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| QuadPattern
A class whose purpose is to give a name to a collection of quads
|
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| DatasetGraphWrapper |
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Quad |
| Transactional
Interface that encapulsated begin/abort|commit/close.
|
| Class and Description |
|---|
| Quad |
| TriplePath
Like a triple except it can be a path or a triple.
|
| Class and Description |
|---|
| PathBlock
A class whose purpose is to give a name to a collection of triple paths.
|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| TriplePath
Like a triple except it can be a path or a triple.
|
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Quad |
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Quad |
| TriplePath
Like a triple except it can be a path or a triple.
|
| Var
A SPARQL variable
|
| VarExprList |
| Class and Description |
|---|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Quad |
| TriplePath
Like a triple except it can be a path or a triple.
|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| PathBlock
A class whose purpose is to give a name to a collection of triple paths.
|
| Quad |
| TriplePath
Like a triple except it can be a path or a triple.
|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| DatasetDescription |
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Quad |
| QuadPattern
A class whose purpose is to give a name to a collection of quads
|
| TriplePath
Like a triple except it can be a path or a triple.
|
| Var
A SPARQL variable
|
| Class and Description |
|---|
| BasicPattern
A class whose purpose is to give a name to a collection of triples.
|
| Quad |
| Class and Description |
|---|
| Transactional
Interface that encapulsated begin/abort|commit/close.
|
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
| Prologue
Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
|
| Transactional
Interface that encapulsated begin/abort|commit/close.
|
| Class and Description |
|---|
| DatasetGraph
DatasetGraph: The graph representation of an RDF Dataset.
|
Licenced under the Apache License, Version 2.0


PYTHON NOTES
Table of Contents
Source: SoloLearn Python Tutorial
Functional Programming
Lambdas
Creating a function normally (using def) assigns it to a variable automatically.
This is different from the creation of other objects - such as strings and integers - which can be created on the fly, without assigning them to a variable.
The same is possible with functions, provided that they are created using lambda syntax. Functions created this way are known as anonymous.
This approach is most commonly used when passing a simple function as an argument to another function. The syntax is shown in the next example and consists of the lambda keyword followed by a list of arguments, a colon, and the expression to evaluate and return.
def my_func(f, arg):
return f(arg)
my_func(lambda x: 2*x*x, 5)
Note: Lambda functions get their name from lambda calculus, which is a model of computation invented by Alonzo Church.
Map
The built-in functions map and filter are very useful higher-order functions that operate on lists (or similar objects called iterables).
The function map takes a function and an iterable as arguments, and returns a new iterable with the function applied to each argument.
Example:
def add_five(x):
return x + 5
nums = [11, 22, 33, 44, 55]
result = list(map(add_five, nums))
print(result)
Result:
[16, 27, 38, 49, 60]
We could have achieved the same result more easily by using lambda syntax.
nums = [11, 22, 33, 44, 55]
result = list(map(lambda x: x+5, nums))
print(result)
Note: To convert the result into a list, we used list explicitly.
Filter
The function filter filters an iterable by removing items that don’t match a predicate (a function that returns a Boolean).
Example:
nums = [11, 22, 33, 44, 55]
res = list(filter(lambda x: x%2==0, nums))
print(res)
Result:
[22, 44]
Note: Like map, the result has to be explicitly converted to a list if you want to print it.
Example:
Fill in the blanks to remove all items that are greater than 4 from the list.
nums = [1, 2, 5, 8, 3, 0, 7]
res = list(filter(lambda x: x < 5, nums))
print(res)
Generators-1
Generators are a type of iterable, like lists or tuples.
Unlike lists, they don’t allow indexing with arbitrary indices, but they can still be iterated through with for loops.
They can be created using functions and the yield statement.
Example:
def countdown():
i=5
while i > 0:
yield i
i -= 1
for i in countdown():
print(i)
Result:
5
4
3
2
1
The yield statement is used to define a generator, replacing the return of a function to provide a result to its caller without destroying local variables.
Generators-2
Due to the fact that they yield one item at a time, generators don’t have the memory restrictions of lists.
In fact, they can be infinite!
def infinite_sevens():
while True:
yield 7
for i in infinite_sevens():
print(i)
Result:
7
7
7
7
7
7
7
…
Note: In short, generators allow you to declare a function that behaves like an iterator, i.e. it can be used in a for loop.
Example:
Fill in the blanks to create a prime number generator, that yields all prime numbers in a loop. (Consider having an is_prime function already defined):
def get_primes():
num = 2
while True:
if is_prime(num):
yield num
num += 1
Generators-3
Finite generators can be converted into lists by passing them as arguments to the list function.
def numbers(x):
for i in range(x):
if i % 2 == 0:
yield i
print(list(numbers(11)))
Result:
[0, 2, 4, 6, 8, 10]
Note: Using generators results in improved performance, which is the result of the lazy (on demand) generation of values, which translates to lower memory usage. Furthermore, we do not need to wait until all the elements have been generated before we start to use them.
Decorators-1
Decorators provide a way to modify functions using other functions.
This is ideal when you need to extend the functionality of functions that you don’t want to modify.
Example:
def decor(func):
def wrap():
print("============")
func()
print("============")
return wrap
def print_text():
print("Hello world!")
decorated = decor(print_text)
decorated()
We defined a function named decor that has a single parameter func. Inside decor, we defined a nested function named wrap. The wrap function will print a string, then call func(), and print another string. The decor function returns the wrap function as its result.
We could say that the variable decorated is a decorated version of print_text - it’s print_text plus something.
In fact, if we wrote a useful decorator we might want to replace print_text with the decorated version altogether so we always got our “plus something” version of print_text.
This is done by re-assigning the variable that contains our function:
print_text = decor(print_text)
print_text()
Now print_text corresponds to our decorated version.
Decorators-2
In our previous example, we decorated our function by replacing the variable containing the function with a wrapped version.
def print_text():
print("Hello world!")
print_text = decor(print_text)
This pattern can be used at any time, to wrap any function.
Python provides support to wrap a function in a decorator by pre-pending the function definition with a decorator name and the @ symbol.
If we are defining a function we can “decorate” it with the @ symbol like:
@decor
def print_text():
print("Hello world!")
Try It Yourself
This will have the same result as the above code.
Note: A single function can have multiple decorators.
Recursion-1
Recursion is a very important concept in functional programming.
The fundamental part of recursion is self-reference - functions calling themselves. It is used to solve problems that can be broken up into easier sub-problems of the same type.
A classic example of a function that is implemented recursively is the factorial function, which finds the product of all positive integers below a specified number.
For example, 5! (5 factorial) is 5 * 4 * 3 * 2 * 1 (120). To implement this recursively, notice that 5! = 5 * 4!, 4! = 4 * 3!, 3! = 3 * 2!, and so on. Generally, n! = n * (n-1)!.
Furthermore, 1! = 1. This is known as the base case, as it can be calculated without performing any more factorials.
Below is a recursive implementation of the factorial function.
def factorial(x):
if x == 1:
return 1
else:
return x * factorial(x-1)
print(factorial(5))
Result:
120
Note: The base case acts as the exit condition of the recursion.
Recursion-2
Recursive functions can be infinite, just like infinite while loops. These often occur when you forget to implement the base case.
Below is an incorrect version of the factorial function. It has no base case, so it runs until the interpreter runs out of memory and crashes.
def factorial(x):
return x * factorial(x-1)
print(factorial(5))
Result:
RuntimeError: maximum recursion depth exceeded
Recursion-3
Recursion can also be indirect. One function can call a second, which calls the first, which calls the second, and so on. This can occur with any number of functions.
Example:
def is_even(x):
if x == 0:
return True
else:
return is_odd(x-1)
def is_odd(x):
return not is_even(x)
print(is_odd(17))
print(is_even(23))
Result:
True
False
Sets-1
Sets are data structures, similar to lists or dictionaries. They are created using curly braces, or the set function. They share some functionality with lists, such as the use of in to check whether they contain a particular item.
num_set = {1, 2, 3, 4, 5}
word_set = set(["spam", "eggs", "sausage"])
print(3 in num_set)
print("spam" not in word_set)
Result:
True
False
Note: To create an empty set, you must use set(), as {} creates an empty dictionary.
Sets-2
Sets differ from lists in several ways, but share several list operations such as len.
They are unordered, which means that they can’t be indexed.
They cannot contain duplicate elements.
Due to the way they’re stored, it’s faster to check whether an item is part of a set, rather than part of a list.
Instead of using append to add to a set, use add.
The method remove removes a specific element from a set; pop removes an arbitrary element.
nums = {1, 2, 1, 3, 1, 4, 5, 6}
print(nums)
nums.add(-7)
nums.remove(3)
print(nums)
Result:
{1, 2, 3, 4, 5, 6}
{1, 2, 4, 5, 6, -7}
Note: Basic uses of sets include membership testing and the elimination of duplicate entries.
Sets-3
Sets can be combined using mathematical operations.
The union operator | combines two sets to form a new one containing items in either.
The intersection operator & gets items only in both.
The difference operator - gets items in the first set but not in the second.
The symmetric difference operator ^ gets items in either set, but not both.
first = {1, 2, 3, 4, 5, 6}
second = {4, 5, 6, 7, 8, 9}
print(first | second)
print(first & second)
print(first - second)
print(second - first)
print(first ^ second)
Result:
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{4, 5, 6}
{1, 2, 3}
{8, 9, 7}
{1, 2, 3, 7, 8, 9}
StackEdit stores your documents in your browser, which means all your documents are automatically saved locally and are accessible offline!
Data Structures
As we have seen in the previous lessons, Python supports the following data structures: lists, dictionaries, tuples, sets.
When to use a dictionary:
- When you need a logical association between a key:value pair.
- When you need fast lookup for your data, based on a custom key.
- When your data is being constantly modified. Remember, dictionaries are mutable.
When to use the other types:
- Use lists if you have a collection of data that does not need random access. Try to choose lists when you need a simple, iterable collection that is modified frequently.
- Use a set if you need uniqueness for the elements.
- Use tuples when your data cannot change.
Many times, a tuple is used in combination with a dictionary, for example, a tuple might represent a key, because it’s immutable.
itertools-1
The module itertools is a standard library that contains several functions that are useful in functional programming.
One type of function it produces is infinite iterators.
The function count counts up infinitely from a value.
The function cycle infinitely iterates through an iterable (for instance a list or string).
The function repeat repeats an object, either infinitely or a specific number of times.
Example:
from itertools import count
for i in count(3):
print(i)
if i >=11:
break
Result:
3
4
5
6
7
8
9
10
11
itertools-2
There are many functions in itertools that operate on iterables, in a similar way to map and filter.
Some examples:
takewhile - takes items from an iterable while a predicate function remains true;
chain - combines several iterables into one long one;
accumulate - returns a running total of values in an iterable.
from itertools import accumulate, takewhile
nums = list(accumulate(range(8)))
print(nums)
print(list(takewhile(lambda x: x<= 6, nums)))
Result:
[0, 1, 3, 6, 10, 15, 21, 28]
[0, 1, 3, 6]
itertools-3
There are also several combinatoric functions in itertool, such as product and permutation.
These are used when you want to accomplish a task with all possible combinations of some items.
Example:
from itertools import product, permutations
letters = ("A", "B")
print(list(product(letters, range(2))))
print(list(permutations(letters)))
Result:
[(‘A’, 0), (‘A’, 1), (‘B’, 0), (‘B’, 1)]
[(‘A’, ‘B’), (‘B’, ‘A’)]
Object-Oriented Programming
Classes-1
We have previously looked at two paradigms of programming - imperative (using statements, loops, and functions as subroutines), and functional (using pure functions, higher-order functions, and recursion).
Another very popular paradigm is object**-**oriented programming (OOP).
Objects are created using classes, which are actually the focal point of OOP.
The class describes what the object will be, but is separate from the object itself. In other words, a class can be described as an object’s blueprint, description, or definition.
You can use the same class as a blueprint for creating multiple different objects.
Classes are created using the keyword class and an indented block, which contains class methods (which are functions).
Below is an example of a simple class and its objects.
class Cat:
def __init__(self, color, legs):
self.color = color
self.legs = legs
felix = Cat("ginger", 4)
rover = Cat("dog-colored", 4)
stumpy = Cat("brown", 3)
Note: This code defines a class named Cat, which has two attributes: color and legs.
Then the class is used to create 3 separate objects of that class.
__init__
The init method is the most important method in a class.
This is called when an instance (object) of the class is created, using the class name as a function.
All methods must have self as their first parameter, although it isn’t explicitly passed, Python adds the self argument to the list for you; you do not need to include it when you call the methods. Within a method definition, self refers to the instance calling the method.
Instances of a class have attributes, which are pieces of data associated with them.
In this example, Cat instances have attributes color and legs. These can be accessed by putting a dot, and the attribute name after an instance.
In an init method, self.attribute can therefore be used to set the initial value of an instance’s attributes.
Example:
class Cat:
def __init__(self, color, legs):
self.color = color
self.legs = legs
felix = Cat("ginger", 4)
print(felix.color)
Result:
Note: ginger
Note: In the example above, the init method takes two arguments and assigns them to the object’s attributes. The init method is called the class constructor.
Methods
Classes can have other methods defined to add functionality to them.
Remember, that all methods must have self as their first parameter.
These methods are accessed using the same dot syntax as attributes.
Example:
class Dog:
def __init__(self, name, color):
self.name = name
self.color = color
def bark(self):
print("Woof!")
fido = Dog("Fido", "brown")
print(fido.name)
fido.bark()
Result:
Fido
Woof!
Classes can also have class attributes, created by assigning variables within the body of the class. These can be accessed either from instances of the class, or the class itself.
Example:
class Dog:
legs = 4
def __init__(self, name, color):
self.name = name
self.color = color
fido = Dog("Fido", "brown")
print(fido.legs)
print(Dog.legs)
Result:
4
4
NOTE: Class attributes are shared by all instances of the class.
Classes-2
Trying to access an attribute of an instance that isn’t defined causes an AttributeError. This also applies when you call an undefined method.
Example:
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
rect = Rectangle(7, 8)
print(rect.color)
Result:
AttributeError: ‘Rectangle’ object has no attribute ‘color’
Inheritance-1
Inheritance provides a way to share functionality between classes.
Imagine several classes, Cat, Dog, Rabbit and so on. Although they may differ in some ways (only Dog might have the method bark), they are likely to be similar in others (all having the attributes color and name).
This similarity can be expressed by making them all inherit from a superclass Animal, which contains the shared functionality.
To inherit a class from another class, put the superclass name in parentheses after the class name.
Example:
class Animal:
def __init__(self, name, color):
self.name = name
self.color = color
class Cat(Animal):
def purr(self):
print("Purr...")
class Dog(Animal):
def bark(self):
print("Woof!")
fido = Dog("Fido", "brown")
print(fido.color)
fido.bark()
Result:
brown
Woof!
Inheritance-2
A class that inherits from another class is called a subclass.
A class that is inherited from is called a superclass.
If a class inherits from another with the same attributes or methods, it overrides them.
class Wolf:
def __init__(self, name, color):
self.name = name
self.color = color
def bark(self):
print("Grr...")
class Dog(Wolf):
def bark(self):
print("Woof")
husky = Dog("Max", "grey")
husky.bark()
Result:
Woof
Note: In the example above, Wolf is the superclass, Dog is the subclass.
Inheritance-3
Inheritance can also be indirect. One class can inherit from another, and that class can inherit from a third class.
Example:
class A:
def method(self):
print("A method")
class B(A):
def another_method(self):
print("B method")
class C(B):
def third_method(self):
print("C method")
c = C()
c.method()
c.another_method()
c.third_method()
Result:
A method
B method
C method
Note: However, circular inheritance is not possible.
Inheritance-4
The function super is a useful inheritance-related function that refers to the parent class. It can be used to find the method with a certain name in an object’s superclass.
Example:
class A:
def spam(self):
print(1)
class B(A):
def spam(self):
print(2)
super().spam()
B().spam()
Result:
2
1
Note: super().spam() calls the spam method of the superclass.


Butterflies Are Free
7:30 Thur & Fri May 28, 29, June 4, 5
5:00 and 8:30 Sat, May 30, June 6
2:00 Sun May 31
Pleasant Trip Back to the '60s
Young Don Baker, hero of his mother's children's book series,
"Donny Dark" has been blind since birth, his overprotective mother following
his every move. Don finally decides to take his own apartment in Manhattan
and pursue his songwriting ambitions. When she meets his kooky neighbor,
sexy actress Jill, Mrs. Baker's controlling instincts go into overdrive
with hilariously touching results.


An encrypted copy of the file will be created.
Only files encrypted by this tool are accepted.
You must remember.
Enter the pass phrase that was used to encrypt this file.


Language Classifier
Predict a programming language from its source code.
Currently, the model is trained on
C C++ Go Haskell Java JavaScript Julia Lua Lua OCaml Perl Python Racket
using data sourced from Rosetta Code.
See https://github.com/kevinywlui/langclass and https://kevinlui.org/posts/langclass for the source code and more information.


This module provides several classes in support of Joyent's Best Practices for Error Handling in Node.js. If you find any of the behavior here confusing or surprising, check out that document first.
The error classes here support:
The classes here are:
First, install the package:
npm install verror
If nothing else, you can use VError as a drop-in replacement for the built-in JavaScript Error class, with the addition of printf-style messages:
var err = new VError('missing file: "%s"', '/etc/passwd');
console.log(err.message);
This prints:
missing file: "/etc/passwd"
You can also pass a cause
argument, which is any other Error object:
var fs = require('fs');
var filename = '/nonexistent';
fs.stat(filename, function (err1) {
var err2 = new VError(err1, 'stat "%s"', filename);
console.error(err2.message);
});
This prints out:
stat "/nonexistent": ENOENT, stat '/nonexistent'
which resembles how Unix programs typically report errors:
$ sort /nonexistent
sort: open failed: /nonexistent: No such file or directory
To match the Unixy feel, when you print out the error, just prepend the program's name to the VError's message
. Or just call node-cmdutil.fail(your_verror), which does this for you.
You can get the next-level Error using err.cause()
:
console.error(err2.cause().message);
prints:
ENOENT, stat '/nonexistent'
Of course, you can chain these as many times as you want, and it works with any kind of Error:
var err1 = new Error('No such file or directory');
var err2 = new VError(err1, 'failed to stat "%s"', '/junk');
var err3 = new VError(err2, 'request failed');
console.error(err3.message);
This prints:
request failed: failed to stat "/junk": No such file or directory
The idea is that each layer in the stack annotates the error with a description of what it was doing. The end result is a message that explains what happened at each level.
You can also decorate Error objects with additional information so that callers can not only handle each kind of error differently, but also construct their own error messages (e.g., to localize them, format them, group them by type, and so on). See the example below.
The two main goals for VError are:
"ip": "<IP_ADDRESS>"
and "tcpPort": 80
. This can be used for feeding into monitoring systems, analyzing large numbers of Errors (as from a log file), or localizing error messages.To really make this useful, it also needs to be easy to compose Errors: higher-level code should be able to augment the Errors reported by lower-level code to provide a more complete description of what happened. Instead of saying "connection refused", you can say "operation X failed: connection refused". That's why VError supports causes
.
In order for all this to work, programmers need to know that it's generally safe to wrap lower-level Errors with higher-level ones. If you have existing code that handles Errors produced by a library, you should be able to wrap those Errors with a VError to add information without breaking the error handling code. There are two obvious ways that this could break such consumers:
name
to determine what kind of Error they've got. To ensure compatibility, you can create VErrors with custom names, but this approach isn't great because it prevents you from representing complex failures. For this reason, VError provides findCauseByName
, which essentially asks: does this Error or any of its causes have this specific type? If error handling code uses findCauseByName
, then subsystems can construct very specific causal chains for debuggability and still let people handle simple cases easily. There's an example below.name
, message
, and stack
, but also fileName
, lineNumber
, and a few others. Plus, it's useful for some Error subclasses to have their own private properties -- and there'd be no way to know whether these should be copied. For these reasons, VError first-classes these information properties. You have to provide them in the constructor, you can only fetch them with the info()
function, and VError takes care of making sure properties from causes wind up in the info()
output.Let's put this all together with an example from the node-fast RPC library. node-fast implements a simple RPC protocol for Node programs. There's a server and client interface, and clients make RPC requests to servers. Let's say the server fails with an UnauthorizedError with message "user 'bob' is not authorized". The client wraps all server errors with a FastServerError. The client also wraps all request errors with a FastRequestError that includes the name of the RPC call being made. The result of this failed RPC might look like this:
name: FastRequestError
message: "request failed: server error: user 'bob' is not authorized"
rpcMsgid: <unique identifier for this request>
rpcMethod: GetObject
cause:
name: FastServerError
message: "server error: user 'bob' is not authorized"
cause:
name: UnauthorizedError
message: "user 'bob' is not authorized"
rpcUser: "bob"
When the caller uses VError.info()
, the information properties are collapsed so that it looks like this:
message: "request failed: server error: user 'bob' is not authorized"
rpcMsgid: <unique identifier for this request>
rpcMethod: GetObject
rpcUser: "bob"
Taking this apart:
findCauseByName('FastServerError')
rather than checking the name
field directly.It's not expected that you'd use these complex forms all the time. Despite supporting the complex case above, you can still just do:
new VError("my service isn't working");
for the simple cases.
VError, WError, and SError are convenient drop-in replacements for Error
that support printf-style arguments, first-class causes, informational properties, and other useful features.
The VError constructor has several forms:
/*
* This is the most general form. You can specify any supported options
* (including "cause" and "info") this way.
*/
new VError(options, sprintf_args...)
/*
* This is a useful shorthand when the only option you need is "cause".
*/
new VError(cause, sprintf_args...)
/*
* This is a useful shorthand when you don't need any options at all.
*/
new VError(sprintf_args...)
All of these forms construct a new VError that behaves just like the built-in JavaScript Error
class, with some additional methods described below.
In the first form, options
is a plain object with any of the following optional properties:
| Option name | Type | Meaning |
|---|---|---|
name |
string | Describes what kind of error this is. This is intended for programmatic use to distinguish between different kinds of errors. Note that in modern versions of Node.js, this name is ignored in the stack property value, but callers can still use the name property to get at it. |
cause |
any Error object | Indicates that the new error was caused by cause . See cause() below. If unspecified, the cause will be null . |
strict |
boolean | If true, then null and undefined values in sprintf_args are passed through to sprintf() . Otherwise, these are replaced with the strings 'null' , and 'undefined ', respectively. |
constructorOpt |
function | If specified, then the stack trace for this error ends at function constructorOpt . Functions called by constructorOpt will not show up in the stack. This is useful when this class is subclassed. |
info |
object | Specifies arbitrary informational properties that are available through the VError.info(err) static class method. See that method for details. |
The second form is equivalent to using the first form with the specified cause
as the error's cause. This form is distinguished from the first form because the first argument is an Error.
The third form is equivalent to using the first form with all default option values. This form is distinguished from the other forms because the first argument is not an object or an Error.
The WError
constructor is used exactly the same way as the VError
constructor. The SError
constructor is also used the same way as the VError
constructor except that in all cases, the strict
property is overriden to `true.
VError
, WError
, and SError
all provide the same public properties as JavaScript's built-in Error objects.
| Property name | Type | Meaning |
|---|---|---|
name |
string | Programmatically-usable name of the error. |
message |
string | Human-readable summary of the failure. Programmatically-accessible details are provided through VError.info(err) class method. |
stack |
string | Human-readable stack trace where the Error was constructed. |
For all of these classes, the printf-style arguments passed to the constructor are processed with sprintf()
to form a message. For WError
, this becomes the complete message
property. For SError
and VError
, this message is prepended to the message of the cause, if any (with a suitable separator), and the result becomes the message
property.
The stack
property is managed entirely by the underlying JavaScript implementation. It's generally implemented using a getter function because constructing the human-readable stack trace is somewhat expensive.
The following methods are defined on the VError
class and as exported functions on the verror
module. They're defined this way rather than using methods on VError instances so that they can be used on Errors not created with VError
.
VError.cause(err)
The cause()
function returns the next Error in the cause chain for err
, or null
if there is no next error. See the cause
argument to the constructor. Errors can have arbitrarily long cause chains. You can walk the cause
chain by invoking VError.cause(err)
on each subsequent return value. If err
is not a VError
, the cause is null
.
VError.info(err)
Returns an object with all of the extra error information that's been associated with this Error and all of its causes. These are the properties passed in using the info
option to the constructor. Properties not specified in the constructor for this Error are implicitly inherited from this error's cause.
These properties are intended to provide programmatically-accessible metadata about the error. For an error that indicates a failure to resolve a DNS name, informational properties might include the DNS name to be resolved, or even the list of resolvers used to resolve it. The values of these properties should generally be plain objects (i.e., consisting only of null, undefined, numbers, booleans, strings, and objects and arrays containing only other plain objects).
VError.fullStack(err)
Returns a string containing the full stack trace, with all nested errors recursively reported as 'caused by:' + err.stack
.
VError.findCauseByName(err, name)
The findCauseByName()
function traverses the cause chain for err
, looking for an error whose name
property matches the passed in name
value. If no match is found, null
is returned.
If all you want is to know whether there's a cause (and you don't care what it is), you can use VError.hasCauseWithName(err, name)
.
If a vanilla error or a non-VError error is passed in, then there is no cause chain to traverse. In this scenario, the function will check the name
property of only err
.
VError.hasCauseWithName(err, name)
Returns true if and only if VError.findCauseByName(err, name)
would return a non-null value. This essentially determines whether err
has any cause in its cause chain that has name name
.
VError.errorFromList(errors)
Given an array of Error objects (possibly empty), return a single error representing the whole collection of errors. If the list has:
null
This is useful for cases where an operation may produce any number of errors, and you ultimately want to implement the usual callback(err)
pattern. You can accumulate the errors in an array and then invoke callback(VError.errorFromList(errors))
when the operation is complete.
VError.errorForEach(err, func)
Convenience function for iterating an error that may itself be a MultiError.
In all cases, err
must be an Error. If err
is a MultiError, then func
is invoked as func(errorN)
for each of the underlying errors of the MultiError. If err
is any other kind of error, func
is invoked once as func(err)
. In all cases, func
is invoked synchronously.
This is useful for cases where an operation may produce any number of warnings that may be encapsulated with a MultiError -- but may not be.
This function does not iterate an error's cause chain.
The "Demo" section above covers several basic cases. Here's a more advanced case:
var err1 = new VError('something bad happened');
/* ... */
var err2 = new VError({
'name': 'ConnectionError',
'cause': err1,
'info': {
'errno': 'ECONNREFUSED',
'remote_ip': '<IP_ADDRESS>',
'port': 215
}
}, 'failed to connect to "%s:%d"', '<IP_ADDRESS>', 215);
console.log(err2.message);
console.log(err2.name);
console.log(VError.info(err2));
console.log(err2.stack);
This outputs:
failed to connect to "<IP_ADDRESS>:215": something bad happened
ConnectionError
{ errno: 'ECONNREFUSED', remote_ip: '<IP_ADDRESS>', port: 215 }
ConnectionError: failed to connect to "<IP_ADDRESS>:215": something bad happened
at Object.<anonymous> (/home/dap/node-verror/examples/info.js:5:12)
at Module._compile (module.js:456:26)
at Object.Module._extensions..js (module.js:474:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Function.Module.runMain (module.js:497:10)
at startup (node.js:119:16)
at node.js:935:3
Information properties are inherited up the cause chain, with values at the top of the chain overriding same-named values lower in the chain. To continue that example:
var err3 = new VError({
'name': 'RequestError',
'cause': err2,
'info': {
'errno': 'EBADREQUEST'
}
}, 'request failed');
console.log(err3.message);
console.log(err3.name);
console.log(VError.info(err3));
console.log(err3.stack);
This outputs:
request failed: failed to connect to "<IP_ADDRESS>:215": something bad happened
RequestError
{ errno: 'EBADREQUEST', remote_ip: '<IP_ADDRESS>', port: 215 }
RequestError: request failed: failed to connect to "<IP_ADDRESS>:215": something bad happened
at Object.<anonymous> (/home/dap/node-verror/examples/info.js:20:12)
at Module._compile (module.js:456:26)
at Object.Module._extensions..js (module.js:474:10)
at Module.load (module.js:356:32)
at Function.Module._load (module.js:312:12)
at Function.Module.runMain (module.js:497:10)
at startup (node.js:119:16)
at node.js:935:3
You can also print the complete stack trace of combined Error
s by using VError.fullStack(err).
var err1 = new VError('something bad happened');
/* ... */
var err2 = new VError(err1, 'something really bad happened here');
console.log(VError.fullStack(err2));
This outputs:
VError: something really bad happened here: something bad happened
at Object.<anonymous> (/home/dap/node-verror/examples/fullStack.js:5:12)
at Module._compile (module.js:409:26)
at Object.Module._extensions..js (module.js:416:10)
at Module.load (module.js:343:32)
at Function.Module._load (module.js:300:12)
at Function.Module.runMain (module.js:441:10)
at startup (node.js:139:18)
at node.js:968:3
caused by: VError: something bad happened
at Object.<anonymous> (/home/dap/node-verror/examples/fullStack.js:3:12)
at Module._compile (module.js:409:26)
at Object.Module._extensions..js (module.js:416:10)
at Module.load (module.js:343:32)
at Function.Module._load (module.js:300:12)
at Function.Module.runMain (module.js:441:10)
at startup (node.js:139:18)
at node.js:968:3
VError.fullStack
is also safe to use on regular Error
s, so feel free to use it whenever you need to extract the stack trace from an Error
, regardless if it's a VError
or not.
MultiError is an Error class that represents a group of Errors. This is used when you logically need to provide a single Error, but you want to preserve information about multiple underying Errors. A common case is when you execute several operations in parallel and some of them fail.
MultiErrors are constructed as:
new MultiError(error_list)
error_list
is an array of at least one Error
object.
The cause of the MultiError is the first error provided. None of the other VError
options are supported. The message
for a MultiError consists the message
from the first error, prepended with a message indicating that there were other errors.
For example:
err = new MultiError([
new Error('failed to resolve DNS name "abc.example.com"'),
new Error('failed to resolve DNS name "def.example.com"'),
]);
console.error(err.message);
outputs:
first of 2 errors: failed to resolve DNS name "abc.example.com"
See the convenience function VError.errorFromList
, which is sometimes simpler to use than this constructor.
errors()
Returns an array of the errors used to construct this MultiError.
See separate contribution guidelines.


This package contains basic data structures (e.g. map, vector, set)
and all generalized operations on them (e.g. Vector.toSet()).
Name convention:
Classes stating with T are template classes with unspesified content class type(s).
Generally I=Integer, D=Double, S=String, X=unspecified
Interfaces:
Containers can do batch operations defined in @Interface to all its elements
conventions:
Containers will not load from a column of a text table. This is handled by enumerators


PERLTRU64
Section: Perl Programmers Reference Guide (1)Updated: 2009-02-12
Index Return to Main Contents
NAME
README.tru64 - Perl version 5 on Tru64 (formerly known as Digital UNIX formerly known as DEC OSF/1) systemsDESCRIPTION
This document describes various features of HP's (formerly Compaq's, formerly Digital's) Unix operating system (Tru64) that will affect how Perl version 5 (hereafter just Perl) is configured, compiled and/or runs.Compiling Perl 5 on Tru64
The recommended compiler to use in Tru64 is the native C compiler. The native compiler produces much faster code (the speed difference is noticeable: several dozen percentages) and also more correct code: if you are considering using the GNU C compiler you should use at the very least the release of 2.95.3 since all older gcc releases are known to produce broken code when compiling Perl. One manifestation of this brokenness is the lib/sdbm test dumping core; another is many of the op/regexp and op/pat, or ext/Storable tests dumping core (the exact pattern of failures depending on the GCC release and optimization flags).gcc 3.2.1 is known to work okay with Perl 5.8.0. However, when optimizing the toke.c gcc likes to have a lot of memory, 256 megabytes seems to be enough. The default setting of the process data section in Tru64 should be one gigabyte, but some sites/setups might have lowered that. The configuration process of Perl checks for too low process limits, and lowers the optimization for the toke.c if necessary, and also gives advice on how to raise the process limits.
Also, Configure might abort with
Build a threading Perl? [n] Configure[2437]: Syntax error at line 1 : `config.sh' is not expected.
This indicates that Configure is being run with a broken Korn shell (even though you think you are using a Bourne shell by using ``sh Configure'' or ``./Configure''). The Korn shell bug has been reported to Compaq as of February 1999 but in the meanwhile, the reason ksh is being used is that you have the environment variable BIN_SH set to 'xpg4'. This causes /bin/sh to delegate its duties to /bin/posix/sh (a ksh). Unset the environment variable and rerun Configure.
Using Large Files with Perl on Tru64
In Tru64 Perl is automatically able to use large files, that is, files larger than 2 gigabytes, there is no need to use the Configure -Duselargefiles option as described in INSTALL (though using the option is harmless).Threaded Perl on Tru64
If you want to use threads, you should primarily use the Perl 5.8.0 threads model by running Configure with -Duseithreads.Perl threading is going to work only in Tru64 4.0 and newer releases, older operating releases like 3.2 aren't probably going to work properly with threads.
In Tru64 V5 (at least V5.1A, V5.1B) you cannot build threaded Perl with gcc because the system header <pthread.h> explicitly checks for supported C compilers, gcc (at least 3.2.2) not being one of them. But the system C compiler should work just fine.
Long Doubles on Tru64
You cannot Configure Perl to use long doubles unless you have at least Tru64 V5.0, the long double support simply wasn't functional enough before that. Perl's Configure will override attempts to use the long doubles (you can notice this by Configure finding out that the modfl() function does not work as it should).At the time of this writing (June 2002), there is a known bug in the Tru64 libc printing of long doubles when not using ``e'' notation. The values are correct and usable, but you only get a limited number of digits displayed unless you force the issue by using "printf "%.33e",$num" or the like. For Tru64 versions V5.0A through V5.1A, a patch is expected sometime after perl 5.8.0 is released. If your libc has not yet been patched, you'll get a warning from Configure when selecting long doubles.
DB_File tests failing on Tru64
The DB_File tests (db-btree.t, db-hash.t, db-recno.t) may fail you have installed a newer version of Berkeley DB into the system and the -I and -L compiler and linker flags introduce version conflicts with the DB 1.85 headers and libraries that came with the Tru64. For example, mixing a DB v2 library with the DB v1 headers is a bad idea. Watch out for Configure options -Dlocincpth and -Dloclibpth, and check your /usr/local/include and /usr/local/lib since they are included by default.The second option is to explicitly instruct Configure to detect the newer Berkeley DB installation, by supplying the right directories with "-Dlocincpth=/some/include" and "-Dloclibpth=/some/lib" and before running ``make test'' setting your LD_LIBRARY_PATH to /some/lib.
The third option is to work around the problem by disabling the DB_File completely when build Perl by specifying -Ui_db to Configure, and then using the BerkeleyDB module from CPAN instead of DB_File. The BerkeleyDB works with Berkeley DB versions 2.* or greater.
The Berkeley DB 4.1.25 has been tested with Tru64 V5.1A and found to work. The latest Berkeley DB can be found from http://www.sleepycat.com.
64-bit Perl on Tru64
In Tru64 Perl's integers are automatically 64-bit wide, there is no need to use the Configure -Duse64bitint option as described in INSTALL. Similarly, there is no need for -Duse64bitall since pointers are automatically 64-bit wide.Warnings about floating-point overflow when compiling Perl on Tru64
When compiling Perl in Tru64 you may (depending on the compiler release) see two warnings like this
cc: Warning: numeric.c, line 104: In this statement, floating-point overflow occurs in evaluating the expression "1.8e308". (floatoverfl) return HUGE_VAL; -----------^
and when compiling the POSIX extension
cc: Warning: const-c.inc, line 2007: In this statement, floating-point overflow occurs in evaluating the expression "1.8e308". (floatoverfl) return HUGE_VAL; -------------------^
The exact line numbers may vary between Perl releases. The warnings are benign and can be ignored: in later C compiler releases the warnings should be gone.
When the file pp_sys.c is being compiled you may (depending on the operating system release) see an additional compiler flag being used: "-DNO_EFF_ONLY_OK". This is normal and refers to a feature that is relevant only if you use the "filetest" pragma. In older releases of the operating system the feature was broken and the NO_EFF_ONLY_OK instructs Perl not to use the feature.
Testing Perl on Tru64
During ``make test'' the "comp/cpp" will be skipped because on Tru64 it cannot be tested before Perl has been installed. The test refers to the use of the "-P" option of Perl.ext/ODBM_File/odbm Test Failing With Static Builds
The ext/ODBM_File/odbm is known to fail with static builds (Configure -Uusedl) due to a known bug in Tru64's static libdbm library. The good news is that you very probably don't need to ever use the ODBM_File extension since more advanced NDBM_File works fine, not to mention the even more advanced DB_File.Perl Fails Because Of Unresolved Symbol sockatmark
If you get an error like
Can't load '.../OSF1/lib/perl5/5.8.0/alpha-dec_osf/auto/IO/IO.so' for module IO: Unresolved symbol in .../lib/perl5/5.8.0/alpha-dec_osf/auto/IO/IO.so: sockatmark at .../lib/perl5/5.8.0/alpha-dec_osf/XSLoader.pm line 75.
you need to either recompile your Perl in Tru64 4.0D or upgrade your Tru64 4.0D to at least 4.0F: the sockatmark() system call was added in Tru64 4.0F, and the IO extension refers that symbol.
AUTHOR
Jarkko Hietaniemi<EMAIL_ADDRESS>Index
- NAME
- DESCRIPTION
- Testing Perl on Tru64
- ext/ODBM_File/odbm Test Failing With Static Builds
- Perl Fails Because Of Unresolved Symbol sockatmark
- AUTHOR
This document was created by man2html, using the manual pages.
Time: 05:29:09 GMT, December 24, 2015


Release managers wanting to initiate a release of Pony Mail should follow these steps:
Assuming you wish to release version X.Y
git archive --format=tar.gz -o ~/ponymail-X.Y.tar.gz HEAD
sha256sum ponymail-X.Y.tar.gz > ponymail-X.Y.tar.gz.sha256
gpg --output ponymail-X.Y.tar.gz.asc --sign ponymail-X.Y.tar.gz
ORgpg --output ponymail-X.Y.tar.gz.sha256.asc --sign ponymail-X.Y.tar.gz.sha256
https://dist.apache.org/repos/dist/dev/incubator/ponymail/
via subversionhttps://dist.apache.org/repos/dist/release/incubator/ponymail/
via svn mv
Apache Pony Mail (Incubating) is an effort undergoing incubation at The Apache Software Foundation (ASF), sponsored by the Apache Incubator. Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making process have stabilized in a manner consistent with other successful ASF projects. While incubation status is not necessarily a reflection of the completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF.


This is a filesystem-based store for OpenID associations and
nonces. This store should be safe for use in concurrent systems on both windows and unix (excluding NFS filesystems). There are a couple race conditions in the system, but those failure cases have been set up in such a way that the worst-case behavior is someone having to try to log in a second time.
Most of the methods of this class are implementation details. People wishing to just use this store need only pay attention to the constructor.
Located in /Auth/OpenID/FileStore.php (line 39)
Auth_OpenID_OpenIDStore | --Auth_OpenID_FileStore
Initializes a new Auth_OpenID_FileStore. This initializes the nonce and association directories, which are subdirectories of the directory passed in.
Retrieve an association. If no handle is specified, return the association with the most recent issue time.
Create a unique filename for a given server url and
handle. This implementation does not assume anything about the format of the handle. The filename that is returned will contain the domain name from the server URL for ease of human inspection of the data directory.
Remove an association if it exists. Do nothing if it does not.
Store an association in the association directory.
Return whether this nonce is present. As a side effect, mark it as no longer present.
Inherited From Auth_OpenID_OpenIDStore
Auth_OpenID_OpenIDStore::cleanup()
Auth_OpenID_OpenIDStore::cleanupAssociations()
Auth_OpenID_OpenIDStore::cleanupNonces()
Auth_OpenID_OpenIDStore::getAssociation()
Auth_OpenID_OpenIDStore::removeAssociation()
Auth_OpenID_OpenIDStore::reset()
Auth_OpenID_OpenIDStore::storeAssociation()
Auth_OpenID_OpenIDStore::supportsCleanup()
Auth_OpenID_OpenIDStore::useNonce()
Documentation generated on Tue, 21 Apr 2009 11:31:31 -0700 by phpDocumentor 1.3.2


Any program that uses the CFITSIO interface must include the fitsio.h header file with the statement
#include "fitsio.h"This header file contains the prototypes for all the CFITSIO user interface routines as well as the definitions of various constants used in the interface. It also defines a C structure of type `fitsfile' that is used by CFITSIO to store the relevant parameters that define the format of a particular FITS file. Application programs must define a pointer to this structure for each FITS file that is to be opened. This structure is initialized (i.e., memory is allocated for the structure) when the FITS file is first opened or created with the fits_open_file or fits_create_file routines. This fitsfile pointer is then passed as the first argument to every other CFITSIO routine that operates on the FITS file. Application programs must not directly read or write elements in this fitsfile structure because the definition of the structure may change in future versions of CFITSIO.
A number of symbolic constants are also defined in fitsio.h for the convenience of application programmers. Use of these symbolic constants rather than the actual numeric value will help to make the source code more readable and easier for others to understand.
String Lengths, for use when allocating character arrays: #define FLEN_FILENAME 1025 /* max length of a filename */ #define FLEN_KEYWORD 72 /* max length of a keyword */ #define FLEN_CARD 81 /* max length of a FITS header card */ #define FLEN_VALUE 71 /* max length of a keyword value string */ #define FLEN_COMMENT 73 /* max length of a keyword comment string */ #define FLEN_ERRMSG 81 /* max length of a CFITSIO error message */ #define FLEN_STATUS 31 /* max length of a CFITSIO status text string */ Note that FLEN_KEYWORD is longer than the nominal 8-character keyword name length because the HIERARCH convention supports longer keyword names. Access modes when opening a FITS file: #define READONLY 0 #define READWRITE 1 BITPIX data type code values for FITS images: #define BYTE_IMG 8 /* 8-bit unsigned integers */ #define SHORT_IMG 16 /* 16-bit signed integers */ #define LONG_IMG 32 /* 32-bit signed integers */ #define LONGLONG_IMG 64 /* 64-bit signed integers */ #define FLOAT_IMG -32 /* 32-bit single precision floating point */ #define DOUBLE_IMG -64 /* 64-bit double precision floating point */ The following 4 data type codes are also supported by CFITSIO: #define SBYTE_IMG 10 /* 8-bit signed integers, equivalent to */ /* BITPIX = 8, BSCALE = 1, BZERO = -128 */ #define USHORT_IMG 20 /* 16-bit unsigned integers, equivalent to */ /* BITPIX = 16, BSCALE = 1, BZERO = 32768 */ #define ULONG_IMG 40 /* 32-bit unsigned integers, equivalent to */ /* BITPIX = 32, BSCALE = 1, BZERO =<PHONE_NUMBER> */ Codes for the data type of binary table columns and/or for the data type of variables when reading or writing keywords or data: DATATYPE TFORM CODE #define TBIT 1 /* 'X' */ #define TBYTE 11 /* 8-bit unsigned byte, 'B' */ #define TLOGICAL 14 /* logicals (int for keywords */ /* and char for table cols 'L' */ #define TSTRING 16 /* ASCII string, 'A' */ #define TSHORT 21 /* signed short, 'I' */ #define TLONG 41 /* signed long, */ #define TLONGLONG 81 /* 64-bit long signed integer 'K' */ #define TFLOAT 42 /* single precision float, 'E' */ #define TDOUBLE 82 /* double precision float, 'D' */ #define TCOMPLEX 83 /* complex (pair of floats) 'C' */ #define TDBLCOMPLEX 163 /* double complex (2 doubles) 'M' */ The following data type codes are also supported by CFITSIO: #define TINT 31 /* int */ #define TSBYTE 12 /* 8-bit signed byte, 'S' */ #define TUINT 30 /* unsigned int 'V' */ #define TUSHORT 20 /* unsigned short 'U' */ #define TULONG 40 /* unsigned long */ The following data type code is only for use with fits\_get\_coltype #define TINT32BIT 41 /* signed 32-bit int, 'J' */ HDU type code values (value returned when moving to new HDU): #define IMAGE_HDU 0 /* Primary Array or IMAGE HDU */ #define ASCII_TBL 1 /* ASCII table HDU */ #define BINARY_TBL 2 /* Binary table HDU */ #define ANY_HDU -1 /* matches any type of HDU */ Column name and string matching case-sensitivity: #define CASESEN 1 /* do case-sensitive string match */ #define CASEINSEN 0 /* do case-insensitive string match */ Logical states (if TRUE and FALSE are not already defined): #define TRUE 1 #define FALSE 0 Values to represent undefined floating point numbers: #define FLOATNULLVALUE -9.11912E-36F #define DOUBLENULLVALUE -9.1191291391491E-36 Image compression algorithm definitions #define RICE_1 11 #define GZIP_1 21 #define PLIO_1 31 #define HCOMPRESS_1 41


Open source is the foundation of modern web development. I wouldn't be here today without the many contributions of developers from all over the world.
I try to give back to this movement wherever I can. Over the years I've made contributions to React Native, React Navigation, Moment.js, Heroku, Ionic, Passport.js, SinonJS, DefinitelyTyped and others.
I've also authored a number of open source modules that are in use by others:
I'm passionate to continue contributing to the open source community, whether as part of my job or in my spare time.


Not sure if this is possible depending on what Battlelog's API exposes... is it possible for a plugin to allow deeper platoon membership management?
Currently, Founders cannot kick other founders or demote. Founders only can promote/kick Leaders and Members. If a Founder leaves, this is a well known issue where the remaining members must start a new platoon from scratch.
Perhaps a plugin to reveal the option to demote/kick a Founder as long as another Founder is doing it?
Post edited 1 x times, last by
BrainFooLong
Administrator
BrainFooLong
Administrator
Without getting in-depth i'm pretty sure that this can only be changed by DICE because the logic is on server side.


Experiment Information
You are invited to participate in a research study about how people rate and compare captions for a cartoon.
What will participation involve?
Making multiple judgments about the funniness of captions for a cartoon. Feel free to answer questions until you would like to stop. There is no right answer.
Confidentiality
All survey and judgment data are anonymous, and cannot be traced back to an individual.
Powered by NEXT. Learn more at nextml.org


steam-powered
`Prev `__
S
`Next `__
--------------
**steam-powered**: adj.
Old-fashioned or underpowered; archaic. This term does not have a strong
negative loading and may even be used semi-affectionately for something
that clanks and wheezes a lot but hangs in there doing the job.
--------------
+------------------------------------+----------------------------+---------------------------+
| `Prev `__ | `Up <../S.html>`__ | `Next `__ |
+------------------------------------+----------------------------+---------------------------+
| stealth manager | `Home <../index.html>`__ | steved |
+------------------------------------+----------------------------+---------------------------+


Home
Configure
Pebuilt Configurations
Popular
Most Used
Highly Rated
Featured
Configuration as Code + Pipeline
View Config
Featured
CASC + Pipeline + K8s
View Config
Featured
Multi-branch Pipeline（GitHub + GitLab + Bitbucket）
View Config
Featured
BlueOcean + Multi-branch Pipeline
View Config


{% extends "layout_argleton.html" %} {% block page_title %} Argleton County Council - Apply for a resident's parking permit in Argleton {% endblock %} {% block content %} You are eligible for a parking permit in Argleton The permit will allow you to park in the city centre 24 hours a day. Next {% endblock %}
The permit will allow you to park in the city centre 24 hours a day.


Plotting
Suppose we want to add some visualisations to our document? PlotLy is an extensive library with lots of options and examples. One of their examples shows how to make 3D surface plots. PlotLy loads a CSV file giving the result to a call-back function, putting the data in rows
The following snippet unpacks the data from rows
and puts it in a format that PlotLy understands:
«unpack-data»=
We can now define the data set:
And have a suitable layout:
«define-plot-layout»=
The final plot command is given the inject=
attribute, showing the result and the plotting boilerplate in a tabbed item.
To make sure PlotLy is loaded, you should add,
to the meta-data header of your markdown.
This functionality could potentially be extended to other languages that compile to Javascript.