Created by Jiří Balatý
“style of building the structure and elements of computer programs — that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data”
Wikipedia
// any imperative / procedural language
x = x + 1
0 = 1?
// odd numbers
var results = [];
for(var num of array)
{
if (num % 2 != 0) {
results.push(num);
}
}
// odd numbers
var results = array.filter( num => num % 2 != 0);
what vs how
function add(a,b){
return a+b;
}
function add(a,b){
console.log('Dude, I have got two arguments', a, b);
}
function add(x){
var t = Date.now();
return x + (t % 5);
}
[1, 2, 3].map(function(v){return v+1})
function adder(what){
return function(to){
return to+what;
}
}
var addFive = adder(5);
addFive(10); // returns 15
// pseudo code
function factorial(number){
return number * factorial(number-1);
}
(list 1 2 (quote foo))
(defun -reverse (list)
(let ((return-value '()))
(dolist (e list) (push e return-value))
return-value))
(defun find-pole (f start length precision)
(when (> (* precision 10) length)
(return-from find-pole (pole-p f start length precision)))
(let ((h (float (/ length 2))))
(flet ((check-pole (start)
(when (pole-p f start h precision)
(find-pole f start h precision))))
(or (check-pole start)
(check-pole (+ start (complex 0 h)))
(check-pole (+ start (complex h 0)))
(check-pole (+ start (complex h h)))))))>
(sum 1 2 3)
sum(1 2 3)
(defn make-adder [x]
(fn [y] (+ x y)))
(def add2 (make-adder 2))
It makes your programs simpler!
“Simplicity is prerequisite for reliability”
Edsger W. Dijkstra
“The person who has a genuinely simpler system - a system made out of genuinely simple parts, is going to be able to affect the greatest change with the least work.”
“We can make the exact same programs out of radically simpler components”
Rich Hickey
Rich Hickey (Cognitec)
industry veteran
2½ year before publicly releasing (JavaScript 10 days)
Datomic - immutable database
dotLisp, jfli, Lisplets
and others ...
complex |
simple |
| variables, time | values |
| state, objects | data |
| methods | functions, namespaces |
| inheritance, switch statements | inheritance a la carte |
| conditionals | rule based systems |
| syntax | data |
| ORM | declarative data manipulation |
request
.post('/api/pet')
.send({ name: 'Manny', species: 'cat' })
.set('X-API-Key', 'foobar')
.set('Accept', 'application/json')
.end(function(err, res){
// Calling the end function will send the request
});
How to repeat the request?
var r = request
.post('/api/pet')
.send({ name: 'Manny', species: 'cat' })
.set('X-API-Key', 'foobar')
.set('Accept', 'application/json');
r.end(callbackFirst);
r.end(callbackSecond);
// react JSX
var App = (
);


This page is still unfinished. For details on configuring the VelocityViewTag, you can follow most of the instructions for the VelocityViewServlet and of course on the configuration pages. Help finishing this is welcome!
This is a JSP tag that allows you to use Velocity and VelocityTools from within a JSP page or tag. There are many ways to use this tag. This simplest is to have it process an external template using the current page context. Assuming you have a template called "foo.vm" that can be found by your resource loader(s) that looks like this:
Hello $!bodyContent World!
This tag can process that template by doing:
<%@taglib prefix="velocity" uri="http://velocity.apache.org/velocity-view" %> <velocity:view template="foo.vm"/>
VTL in the body of the tag:
<%@taglib prefix="velocity" uri="http://velocity.apache.org/velocity-view" %> <velocity:view> #if( $date.E eq 'Friday' ) Happy #else Sad #end </velocity:view>
or combine both by first processing the body of the tag, then inserting the results of that into the context for the separate template as $bodyContent:
<%@taglib prefix="velocity" uri="http://velocity.apache.org/velocity-view" %> <velocity:view template="foo.vm"> #if( $date.E eq 'Friday' ) Happy #else Sad #end </velocity:view>
You can also store the results of any of the options above into a variable of any name and scope (default scope is "page"):
<%@taglib prefix="velocity" uri="http://velocity.apache.org/velocity-view" %> <velocity:view var="foo" scope="request" template="foo.vm"> #if( $date.E eq 'Friday' ) Happy #else Sad #end </velocity:view>


For Customers
Purchase order number
Technician work description
Customer name
customer email
customer Signature


--- layout: post title: Episode 082 | Erik Hatcher - Principled Priorities link: http://traffic.libsyn.com/developeronfire/DeveloperOnFire-82-ErikHatcher.mp3 length: 34603008 speaker: Dave Rael duration: '36:49' subtitle: 'Developer On Fire: Erik Hatcher' guest_name: Erik Hatcher image: /assets/images/ErikHatcher.jpg guest_blog: https://lucidworks.com/blog/author/erik/ guest_twitter: erikhatcher disqus_url: http://developeronfire.com/Podcast/Episodes/erik-hatcher-principled-priorities episode_number: 82 book_recommendations: - { url: "http://www.amazon.com/dp/020161622X/?tag=devonfir-20", title: "The Pragmatic Programmer: From Journeyman to Master", author: "Andrew Hunt and David Thomas"} - { url: "http://www.amazon.com/dp/0060248025/?tag=devonfir-20", title: "Falling Up", author: "Shel Silverstein"} - { url: "http://www.amazon.com/dp/0140139966/?tag=devonfir-20", title: "How Buildings Learn: What Happens After They're Built", author: "Stewart Brand"} - { url: "http://www.amazon.com/dp/B000FBFNY2/?tag=devonfir-20", title: "Half Asleep in Frog Pajamas", author: "Tom Robbins"} - { url: "http://www.amazon.com/dp/B00ESF285S/?tag=devonfir-20", title: "Oh, the Places You'll Go!", author: "Dr. Seuss"} - { url: "http://www.amazon.com/dp/0521777682/?tag=devonfir-20", title: "The Elements of Java Style", author: "Allan Vermeulen, Scott W. Ambler, Greg Bumgardner, Eldon Metz, Trevor Misfeldt, Jim Shur"} tags: - { url: "http://www.amazon.com/dp/020161622X/?tag=devonfir-20", title: "The Pragmatic Programmer: From Journeyman to Master", author: "Andrew Hunt and David Thomas"} - { url: "http://www.amazon.com/dp/0060248025/?tag=devonfir-20", title: "Falling Up", author: "Shel Silverstein"} - { url: "http://www.amazon.com/dp/0140139966/?tag=devonfir-20", title: "How Buildings Learn: What Happens After They're Built", author: "Stewart Brand"} - { url: "http://www.amazon.com/dp/B000FBFNY2/?tag=devonfir-20", title: "Half Asleep in Frog Pajamas", author: "Tom Robbins"} - { url: "http://www.amazon.com/dp/B00ESF285S/?tag=devonfir-20", title: "Oh, the Places You'll Go!", author: "Dr. Seuss"} - { url: "http://www.amazon.com/dp/0521777682/?tag=devonfir-20", title: "The Elements of Java Style", author: "Allan Vermeulen, Scott W. Ambler, Greg Bumgardner, Eldon Metz, Trevor Misfeldt, Jim Shur"} redirect_from: - "/82/" - "/082/" - "/0082/" - "/erik-hatcher-principled-priorities/" - "/Erik-Hatcher/" - "/ErikHatcher/" - "/Podcast/Episodes/82/" - "/Podcast/Episodes/082/" - "/Podcast/Episodes/0082/" - "/Podcast/Episodes/erik-hatcher-principled-priorities/" - "/Podcast/Episodes/Erik-Hatcher/" - "/Podcast/Episodes/ErikHatcher/" guid: http://developeronfire.com:80/Podcast/Episodes/erik-hatcher-principled-priorities ---
Erik Hatcher is the co-author of “Lucene in Action” as well as co-author of “Java Development with Ant”. Erik has been an active member of the Lucene community - a leading Lucene and Solr committer, member of the Lucene Project Management Committee, member of the Apache Software Foundation as well as a frequent invited speaker at various industry events. Erik co-founded and works as a Senior Solutions Architect at LucidWorks.
1. Practice, practice, practice
2. Be fit to survive
3. Continually strive for quality


System.(out|err).print is used, consider using a logger.
This rule is deprecated, use {rule:squid:S106} instead.


Binary Trees, Graphs, and Network Knowledge (Week 8) - Learning Objectives
Assessment Structure
- 1 hour, 40 minutes
- Mixture of multiple choice (15-20), free response (1-3) and VSCode (1-3) problems, each with multiple specs.
- Free response just requires enough detail to answer the question, 1-3 sentences. As long as you are able to explain the concept and answer all aspects that it asks, you are good.
- Coding problems will have specs to run (
npm test
) and check your work against
- Standard assessment procedures
- You will be in an individual breakout room
- Use a single monitor and share your screen
- Only have open those resources needed to complete the assessment:
- Zoom
- VSCode
- Browser with AAO and Progress Tracker (to ask questions)
- Approved Resources for this assessment:
- MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript
Binary Trees (W8D2) - Learning Objectives
Binary Trees
- Explain and implement a Binary Tree.
- Identify the three types of tree traversals: pre-order, in-order, and post-order.
- Pre-order: Values are accessed as soon as the node is reached.
- In-order: Values are accessed after we have fully explored the left but before we explore the right branch.
- Post-order: Values are accessed after all of our children have been accessed.
- *Breadth First: The previous three are types of Depth First Traversals. Breadth first accesses values of nodes by level, left to right, top to bottom.
- Given a tree, be able to determine the order of each traversal type:
- Breadth First: 20, 9, 24, 7, 11, 23, 27, 3, 10, 17, 36, 30
- Pre-order: 20, 9, 7, 3, 11, 10, 17, 24, 23, 27, 36, 30
- In-order: 3, 7, 9, 10, 11, 17, 20, 23, 24, 27, 30, 36
- Post-order: 3, 7, 10, 17, 11, 9, 23, 30, 36, 27, 24, 20
- Explain and implement a Binary Search Tree.
Graphs (W8D3) - Learning Objectives
Graphs
- Explain and implement a Graph.
- A good place to start with explaining a graph is comparing to a tree:
- A graph can:
- Consist of any collection of nodes and edges (no limits on connections)
- Have cycles
- Have disconnected portions (a forest, with multiple trees, for example)
- Be missing a root node (don’t have to have one node that connects to everything)
- In a tree, we had an idea of children and parents, in a graph we have neighbors (no hierarchy)
- Just like how we could represent trees in multiple ways, we can represent graphs many ways as well, with advantages/disadvantages to each:
- Adjacency Matrix - 2D Array
- Visually clear what’s going on
- One axis (outside array) has an entry (inner array) for each node in the graph. If one node is connected to another node in the graph, our entry in the inner array is set to true. Otherwise the entry is false.
let matrix = [
/* A B C D E F */
/*A*/ [true, true, true, false, true, false],
/*B*/ [false, true, false, false, false, false],
/*C*/ [false, true, true, true, false, false],
/*D*/ [false, false, false, true, false, false],
/*E*/ [true, false, false, false, true, false],
/*F*/ [false, false, false, false, true, true]
];
- Adjacency List - POJO
- Object where every value in the graph has a key
- Value for the key is an array with each other node that it is connected to (neighbors)
- Easy to iterate through
- Doesn’t take up as much space as an Adjacency Matrix or Node
- Can refer to the entire graph by referencing the object
- Nodes
- Similar to our linked list or tree implementations
- Track the value and the neighbors array as instance variables on the node
- We don’t have a reference to the overall graph with this implementation
- Traverse a graph.
- Using a NODE implementation with ITERATION:
- Using an ADJACENCY LIST with RECURSION:
- One advantage of an adjacency list is that, since we have a reference to the whole graph, we can access nodes that aren’t connected to our starting point. This may or may not be desired, so we can implement our functions differently to account for this feature.
- Using an ADJACENCY LIST with ITERATION:
NOTE: The breadth-first solution to the Adjacency List problem to consider can be found from refactoring the above function. How?
- With all of thes implementations, we should be able to make conclusions from these traversals as well instead of just console logging.
- Is it possible to get from node A to node B?
- Here we’re really implementing a search, like the breadthFirstSearch problem.
- What is the maximum/minimum value we can encounter if we start at node X?
- Instead of returning a boolean, we want to compare values of nodes and return the appropriate value
- If we do this recursively we can compare this node and to each of its neighbors values and return the maximum up the call stack.
- If we do this iteratively, we can keep a currentMax variable as we traverse and update it if we find a new max value.
- etc.
Network Knowledge (W8D4) - Learning Objectives
Network Models
NOTE: USE THE ANKI FLASHCARDS TO STUDY FOR THIS PORTION OF THE ASSESSMENT
- Describe the structure and function of network models from the perspective of a developer.
- Recognize a given model as the TCP/IP model
- Give a brief description of each layer (What is its major concern and an example)
- Application: User-facing data, such as HTTP or FTP (file transfer)
- Transport: Connectivity between clients and servers, such as TCP or UDP
- Internet: Routing between separate networks, such as IP
- Link: Low-level communication between local resources on a network, such as Ethernet
- Recognize a given model as the OSI model
- Give a brief description of each layer (What is its major concern and an example)
- Application (Layer 7)
- Example: HTTP
- Information used by client-side software
- Presentation (Layer 6)
- Example: JPEG, GIF
- Data gets translated into a presentable format
- Often called the syntax layer since it translates machine-readable syntax into human-readable syntax
- Session (Layer 5)
- Example: RPC (Remote Procedure Call)
- Authentication and data continuity
- Authorize actions, reestablish session from dropped connections
- Transport (Layer 4)
- Example: TCP, UDP
- Mirrors TCP/IP’s Transport Layer
- Focused on data integrity and connectivity
- Network (Layer 3)
- Example: IP
- Mirrors TCP/IP’s Internet Layer
- Manages connections between different remote networks
- Data Link (Layer 2)
- Example: Ethernet
- Connections between one network interface to another
- Primarily used by machines in a local network (ie targeting different MAC addresses)
- Physical (Layer 1)
- Example: DSL, 802.11 (Wi-Fi)
- Translating from electrical signals to bits of data
IP Suite
- Identify the correct fields of an IPv6 header.
- Compared to IPv4’s 14 (yikes!) header fields, we now only use 8 fields. They are all listed here, but the main things to be familiar with are the version to indicate IPv4 vs IPv6, as well as the source and destination IP address fields:
- Version: Just like IPv4, the first four bits of our packet header represent our version number, which is
0110
, representing our decimal 6.
- Traffic Class: Identifies the type of packet data
- Flow Label: Adds packet sequencing to IP, but is experimental
- Payload Length: Specifiies the size of this packet
- Next Header: Typically identifies the Transport Layer protocol (TCP, UDP, etc.). It can also indicate an extension header is present, where extra options for the packet are specified (similar concept to the Options field of IPv4, but a different, chainable implementation)
- Hop Limit: Decremented by one each time this packet passes through an intermediary. Prevents the packet from being passed around forever.
- Source IP Address
- Destination IP Address
- Distinguish an IPv4 packet from an IPv6.
- The easiest way to distinguish between an IPv4 and IPv6 packet is the “Version” field of the header.
- The first four bits of any packet’s header indicate which IP version is being used
- For IPv4, we use the binary
0100
and for IPv6 we use 0110
(4 and 6 respectively in decimal)
- (This is a great opportunity to review binary and hexadecimal notation!)
- In additional to the “Version” field itself, if we know where the header ends, we would also generally be able to tell based on the size.
- IPv6 headers have a fixed length of 320 bits, whereas an IPv4 header will generally be much smaller at 160 bits (plus any optional headers).
- This is obviously not the most reliable, so we should always just refer to those first four bits that indicate the version.
- Describe the following subjects and how they relate to one another: IP Addresses, Domain Names, and DNS.
- An IP address is how we specify a location on the internet. When we send out a request, the IP address in the header is what guides our request to its final destination. Just like an address we would use to signify a unique house, the IP address signifies a unique location on the internet that we want to handle our request.
- A Domain Name is our solution to solving the issue of long, seemingly random numbers being difficult for humans to memorize. They are the friendly name for a website’s host.
- When we look at a website, such as https://open.appacademy.io/learn/js-py–aug-2020-online/, we can break it down into components:
https://
is the protocol that we are making the request with
open.appacademy.io
is the domain. The domain can be composed of any number of subdomains.
- The right-most domain is the top-level domain (TLD), which is maintained by domain registries. Common TLDs would be .com, .org, .gov, etc
- Each preceding domain can be referred to as a second-level, third-level, fourth-level, etc., domain. In our example,
appacademy
is the second-level and open
is the third-level domain.
- We often combine a second-level and top-level domain to refer to a generic ‘domain’ term, such as
google.com
, amazon.com
, usa.gov
, appacademy.io
, etc.
- DNS is the Domain Name System. It’s what allows us to utilize our friendly domain names and have them converted into the IP addresses that we actually intended to connect to.
- Zone files are maintained by name servers that contains host names, IP addresses, and resource types. These files are what allow us to bounce around between servers that know more specifics about our desired resource, ultimately getting to the server that has the exact IP address that our domain name maps to.
- There are multile types of records included in the zone file that we should be familiar with:
- SOA: Start of Authority. Points to a name server that is the primary authority for the domain. This record is present on every name server. For example, if I’m looking for
appacademy.io
, the name server will know where more information about io
domains is located and send me along in that direction.
- NS: Name Servers. Points to name servers for the zone. There will always be at least two name servers per zone for redundancy.
- A / AAAA: Map a resource directly to an IP address. These are the ultimate records that our queries are looking for.
A
records are used for IPv4 addresses and AAAA
records are used for IPv6 addresses.
- CNAME: Acts as an alias, indicating what resource this domain should also point to. (We often see this with the www subdomain, where a CNAME record for www would exist for google.com, indicating we can request
www.google.com
and get the same response as google.com
)
- MX: Mail Exchanger. Used to direct messages to a mail server instead of an IP address (allows us to use
@gmail.com
instead of @<IP_ADDRESS>
- which is obviously not the actual address)
- Identify use cases for the TCP and UDP protocols.
- Comparing TCP (Transmission Control Protocol) to UDP (User Datagram Protocol):
- TCP:
- A reliable transport protocol. As packets are sent between locations, their integrity is double-checked to ensure nothing was lost.
- A persistent and consistent connection. When a connection is established between two sources, it is maintained until both sides send the signal that the connection will be terminated.
- Use cases: HTTP (for a webpage, ensure we get all parts of the HTML so that the browser can piece it together and parse it, for example), file transfers, media streaming (YouTube), etc.
- UDP:
- Unreliable transport protocol. There is no confirmation that anything that is sent out is received. “Yelling into the void”
- Prioritizes speed! We don’t have to confirm every packet that is sent. We may lose some pieces of data, but we are prioritizing that we are receiving that information in real-time.
- Use cases: real-time communication like live video and VoIP (if we had to confirm every packet of a zoom transmission, we would end up very out of sync, since we would wait on those dropped frames instead of skipping to the live ones coming in), DNS resolution (prioritizing speed here, getting the user to the appropriate URL quickly - they can always refresh if needed)
- Describe the following subjects and how they relate to one another: MAC Address, IP Address, and a port.
- MAC Addresses are associated with a physical device. It stays with the device as an identifier. Even if we connect to a different network, our MAC address stays the same.
- If we ever run into collisions with other devices with the same address, we can alias this to another value, but in general it would never need to change. The chances of a collision are exceedingly rare.
- IP Addresses are how we are referring to a specific location within or across networks. We can have a local address (<IP_ADDRESS> to <IP_ADDRESS> is a common range to refer to local addresses), which is how we can reference something within our private network, and we can have a public address (something more like <IP_ADDRESS>), which would allow a connection from outside of our local network. The IP address can change, it is not tied directly to a specific machine. It can be mapped to a domain name so that others can reference a user-friendly name such as google.com instead of having to memorize a number.
- Ports are how we can route information to a specific application once we’ve made it to the computer itself. In general, it is a virtual address that we assign that an application is then listening for traffic on. When a request comes in to a specific port, an application (like a server that we create with Express, or our Postgres database - concepts we’ll be exploring soon!) is then able to be given that information directly.
- (Optional) Identify the fields of a TCP segment.
- This is optional additional information! I’ve still included it here since it is listed on the AAO platform, but know that this material is more in depth than you need to know.
- The TCP segment has many different header fields, similar to the fields on an IP packet:
- Source Port: The port that the request originated from
- Destination Port: The port that the request is intended for (determines which socket to use). Our most recognizable example may be when we think about localhost. If we set up a server on port 3000, the packets being sent need a destination port of 3000 for our server to receive them.
- Sequence Number: Extablishes ordering of data. A starting number is created (Initial Sequence Number, or ISN), then each subsequent segment’s number is incremented based on the size of the previous segment.
- Acknowledgement Number: The number that corresponds to the sequence number we are responding to. The acknowledgement number is the sequence number that we received plus the length of the data that was transferred, plus 1. This allows us to determine if we’ve received all of the data. If there is a discrepency in numbers, we have to retransmit data.
- Data Offset: The length of the segment header, allowing us to determine where our options field ends (or if an options field even exists)
- Reserved: 3 bits that are always 0. Available for future flags.
- Control Flags: 9 (currently) bits that are used for congestion monitoring and to indicate the connection lifecycle
- Window Size: Indicates how much data should be sent, allowing for throttling if a receiver is getting overloaded.
- Checksum: Error-checking mechanism for an individual segment
- Urgent Pointer: Marks data as urgent, which will be processed right away. Commonly used to terminate a transfer instead of having to wait until it finishes.
- Options: Similar to packets’ options fields, extra headers that indicate other extra details about the segment.
- (Optional) Describe how a TCP connection is negotiated.
- This is optional additional information! I’ve still included it here since it is listed on the AAO platform, but know that this material is more in depth than you need to know.
- Starting a Connection
- Our first segment header has a synchronize flag, indicating we are opening a connection.
- Our sequence number should be used by the response in their acknowledgement.
- The receiver responds with a synchronize flag of their own as well as an acknowledgement flag.
- The acknowledgement number sent back is the sequence number we are responding to, plus the length of data sent (0), plus 1. This shows the sender that we received their initial request.
- We also send our own sequence number in order to check that the other side of this connection is responding appropriately.
- We send back an acknowledgment based on the sequence number sent by the server.
- After this acknowledgement, both sides now know that a connection is established.
- Dropped Data
- If a segment doesn’t reach the server, there will be a discrepency between the sequence number that it receives and what it expects based on the previous segment.
- The server resends its most recent acknowledgement in order to indicate that we need to resend the segment that comes next in the series.
- This acknowledgement is what makes TCP reliable. If we ever miss data, we know that it has occurred and we can request it to be sent again.
- Closing a Connection
- When we want to indicate that we are done with the transmission, we send a finished flag to the server.
- The server sends an acknowledgement response, then waits a brief period to make sure there are no more segments are coming in.
- The server then sends its own finished flag, indicating that it is closing the connection.
- When we receive the finished flag from the server, we also wait a brief period to make sure we’ve received all segments, then send a final acknowledgment flag. Both sides of the connection are now closed.
- Explaining the difference between network devices like a router and a switch.
- We talked about three main categories of network devices: hubs, switches, and routers.
- A hub is simply taking message and sending it out to everything connected to it. It works on a local network of machines in order to duplicate a message it receives and send it to everything else that connects to it. There is not filtering or directing of messages, it is simply repeating that message to everyone.
- A switch is similar to a hub but has some additional functionality. It is able to look at the MAC address that the message is intended for and send it specifically to the appropriate device (it keeps a MAC address table that maps these addresses to the local IP addresses of the network). If it doesn’t know which IP address it needs to send to specifically, it can also perform the same flooding that a hub can, repeating the message to everyone until it gets a device that it is looking for.
- A router is how we are connecting our local network to other networks, including the internet. It acts as an entry/exit point from the local network to other resources. It implements Network Address Translation (NAT), which assigns the router one IP address for all external communication. The ports associated with incoming requests can then be mapped to the appropriate local network device based on a a routing table that it maintains, similar to the switch’s table.
These will not be on your assessment
- These are tools to be able to see some of the above topics presented on your own machine. Their use, as in commands that you would run or how to read the output, are not assessable material, they are simply included to provide an opportunity to see the some of the above concepts in action.
- Use
traceroute
to show routes between your computer and other computers.
- Passing the
traceroute
utility a URL or IP address argument will allow us to see the connections that were made in order to get from your machine to its destination.
- For example, when I run
traceroute appacademy.io
, I get the following output:
traceroute to appacademy.io (<IP_ADDRESS>), 30 hops max, 60 byte packets
1 _gateway (<IP_ADDRESS>) 0.828 ms 0.990 ms 1.163 ms
2 <IP_ADDRESS> (<IP_ADDRESS>) 18.138 ms 26.191 ms 24.144 ms
3 <IP_ADDRESS> (<IP_ADDRESS>) 27.812 ms 27.976 ms 27.969 ms
4 ae-2-ar01.sacramento.ca.ccal.comcast.net (<IP_ADDRESS>) 27.957 ms 27.735 ms 27.472 ms
5 be-36441-cs04.sunnyvale.ca.ibone.comcast.net (<IP_ADDRESS>) 28.062 ms be-36421-cs02.sunnyvale.ca.ibone.comcast.net (<IP_ADDRESS>) 29.186 ms be-36431-cs03.sunnyvale.ca.ibone.comcast.net (<IP_ADDRESS>) 28.958 ms
6 * * *
7 be-301-cr01.9greatoaks.ca.ibone.comcast.net (<IP_ADDRESS>) 25.456 ms be-304-cr01.9greatoaks.ca.ibone.comcast.net (<IP_ADDRESS>) 25.619 ms be-303-cr01.9greatoaks.ca.ibone.comcast.net (<IP_ADDRESS>) 25.428 ms
8 be-12578-pe04.9greatoaks.ca.ibone.comcast.net (<IP_ADDRESS>) 25.207 ms 23.485 ms 25.393 ms
9 <IP_ADDRESS> (<IP_ADDRESS>) 28.015 ms 26.484 ms 26.271 ms
10 <IP_ADDRESS> (<IP_ADDRESS>) 23.235 ms 21.448 ms 21.641 ms
- The output shows the number of hops that I have taken, “friendly”/DNS name of the hop if applicable with the IP address in parentheses, and the amount of time it took to get a response from that leg of the route.
- There are three times listed because the
traceroute
utility attempts the connection three times in order to get some results to compare.
- If we don’t get a response for any of our attempts, an asterisk (
*
) is shown instead of a time.
- One thing to note with this utility is that Windows firewall will generally block the pings that
traceroute
attempts to make from a WSL implementation. If on WSL, try using the very similar tracert
utility directly within the Windows cmd prompt. This utility is generally not blocked by the Windows firewall.
- There are ways that we can go about allowing specific types of traffic through the firewall to get
traceroute
to work as expected from within WSL, but for our purposes I wouldn’t go through the trouble just for this exercise.
- Issue: https://github.com/microsoft/WSL/issues/1930
- Allowing through the firewall (references Vista, but the same concepts still apply to modern Windows): https://www.howtogeek.com/howto/windows-vista/allow-pings-icmp-echo-request-through-your-windows-vista-firewall/
- Use Wireshark to show/inspect network traffic.
- Wireshark is a tool that allows us to inspect any packets that are coming through our network.
- It allows us to see the content of those packets so that we can see things like how the IP header fields are laid out, the Transport protocol used (TCP, UDP, etc.), and the application content.
- Wireshark is often blocked from use on networks because it allow the user to inspect traffic, including other computers that are on the network. It’s used here just to see examples of what doing different activities on our computers looks like in terms of the packets that are sent.


This test application showcases the XHTML Validator integration with Apache Wicket. This project contains GPL licensed code, and is licensed under the Gnu Public License.
This page uses a font tag, while specifying xhtml1-strict, which is invalid.
bla
Inside font


title=Spring Boot M6's new Security features date=2013-11-12 type=post tags=blog status=published ~~~~~~
Spring Boot
is a super impressive way to get started.
Check out the various Getting Started guides for more on Spring Boot itself.
Spring Boot exposes great metadata about the application from HTTP when you depend on the spring-boot-starter-actuator
.
Now, with M6, you can access that same information (and more!) from SSH! Here's a screencast I created demonstrating the feature. To enable it, you must also add the spring-boot-starter-shell-remote
and
spring-boot-starter-security
.
Here's the code for the Groovy class that you can run by using the spring
command line tool incantation: spring run foo.groovy
:
@Grab("spring-boot-starter-shell-remote")
@Grab("spring-boot-starter-security")
@Grab("spring-boot-starter-actuator")
@RestController
class RemoteShellFriendlyController {
@RequestMapping("/users/{id}")
Object someData( @PathVariable int id){
[ someId : id ]
}
}
In the screencast, I just use the default user and password. If you want use the same user and password from both SSH and HTTP, create a file application.properties
and put it in the same directory as the Groovy script and put the following properties inside it:
security.user.name=youruser
security.user.password=yourpassword
shell.auth=spring


Home
Submit
(current)
History
(current)
Sort By
Porject Name
Old to New
New to Old
Submit My Work
Go to Weekly Update
History
A collection of your previous submissions
{%for person in users%}
{{person.group.group_name}}
{{person.group.submission}}
{{person.group.submission_Time}}
{{person.group.notes}}
View Uploaded File Here
{%endfor%}


Since 2008, we have been experimenting with various open submission and publication models where papers, code and data are publicly shared and then discussed directly by the community via social networking websites such as Slashdot and Reddit (see our motivation paper for more details).
After receiving positive feedback about our submission model at our last workshops and events, we decided to use it exclusively at ADAPT. The authors submit their articles directly to ArXiv while we immediately open a discussion thread at Reddit (which allows ranking of comments). This allows authors get an immediate feedback from the community, defend their techniques, fix obvious flaws, and improve their articles. It also helps Program Chairs select the most appropriate, realistic and reproducible techniques for the final review by the ADAPT PC members. Hence, we also strongly encourage authors share related code, data and experimental results along with their article to help the community validate their approach and even immediately start using it. We believe that such publication model will let authors disseminate their ideas and tools much faster while avoiding unfair reviews and plagiarism (even if submitted paper is not accepted, it is already published as a technical report with a time stamp and can be incrementally improved based on the received feedback).
You may check out the following open access papers and public discussion threads:


Middleground is a website that aims to aggregate news from all sides of the political spectrum and strives to bring you the objective truth. We leveraged NYTimes API, Bing News API and Hoaxy API to accomplish this.
This app is designed for business owners that operate in beauty industry in the Houston market. The content on this website is user-generated i.e. businesses are able to advertise the services they offer and customers can leave reviews on those businesses.


"Strength does not come from winning. Your struggles develop your strengths. When you go through hardships and decide not to surrender, that is strength." Arnold Schwarzenegger
"If you always put limits on everything you do, physical or anything else, it will spread into your work and into your life. There are no limits. There are only plateaus; and you must not stay there, you must go beyond them." Bruce Lee


黒の手番です。54 はどう動かしますか？
Unlimited
pips Black=122 White=126
(CorrectAnswer= 0/0, ErrorScore= 0)
1. 18/14 18/13 eq:+0.154 55.42% (G:4.89% B:0.15%) 44.58% (G:4.44% B:0.06%) 2. 13/9 13/8 eq:+0.103 (-0.051) 53.22% (G:7.64% B:0.19%) 46.78% (G:4.62% B:0.12%) 3. 13/4 eq:+0.059 (-0.095) 52.24% (G:7.95% B:0.20%) 47.76% (G:6.36% B:0.22%) 4. 6/2 6/1 eq:-0.024 (-0.178) 50.13% (G:6.69% B:0.11%) 49.87% (G:9.71% B:0.23%) 5. 6/1 5/1 eq:-0.026 (-0.180) 50.10% (G:7.03% B:0.12%) 49.90% (G:9.85% B:0.27%)


STS
Home
About Us
Gallery
Contact Us
Get in Touch with Us
Location:
Juan Tomas Mejia y Cotes #43
Arroyo Hondo
Santo Domingo
Dominican Republic
Phone:
(+1)<PHONE_NUMBER>
We are social
Contact Forms
Families and general info inquiry
Job openings inquiry


Posted by John Pritchett (EIS) from:<IP_ADDRESS> on October 06, 1999 at 12:18:04:
The new author of ATTAC (Zev Beckerman) has finished the version
that
is compatible with TWGS/TWv3. I offered to help get the word out about
his new helper, but I haven't had time to put anything up on my web
site.
Until that time, I figured I'd just post an announcement on the forum.
If anyone has some positive feedback or constructive criticism, bug
reports
or whatever, post them. Zev reads the forum and I'm sure he'd appreciate
anything you have to say.
I'm glad to see other helpers coming online for TWGS/TWv3.
If you're interested in checking out the new helper, you can find it
at
www.tw-attac.com.
John Pritchett


Such data is so large and complex that none of the traditional data management tools are able to store it or process it efficiently.
Big Data could be found in three forms:
Structured
Unstructured
Semi-structured
Some define Big Data using the three V’s technique:
1). Volume: Organizations collect data from a variety of sources, including business transactions, smart (IoT) devices, industrial equipment, videos, social media and more. In the past, storing it would have been a problem – but cheaper storage on platforms like data lakes and Hadoop have eased the burden.
2). Velocity: With the growth in the Internet of Things, data streams in to businesses at an unprecedented speed and must be handled in a timely manner. RFID tags, sensors and smart meters are driving the need to deal with these torrents of data in near-real time.
3). Variety: Data comes in all types of formats – from structured, numeric data in traditional databases to unstructured text documents, emails, videos, audios, stock ticker data and financial transactions.
In addition to the increasing velocities and varieties of data, data flows are unpredictable – changing often and varying greatly. It’s challenging, but businesses need to know when something is trending in social media, and how to manage daily, seasonal and event-triggered peak data loads.
Big data is a big deal for industries. The onslaught of IoT and other connected devices has created a massive uptick in the amount of information organizations collect, manage and analyse. Along with big data comes the potential to unlock big insights – for every industry, large to small.


http://bit.ly/groupmeeting-aspleaf
@nmaehler
AspLeaf GWAS
Niklas Mähler
Group meeting 2019-02-08
GWAS data
4.5 million SNPs
3 main leaf traits
Area
Circularity
Indent depth
Data preparation
Best linear unbiased predictors (BLUPs)
One trait value per genotype
Convert VCF files to plink format
Software
GEMMA for association mapping
plink for data manipulation
Working on an updated workflow
snakemake
Better structure
Better reproducibility
Top 1000 SNPs
Top 1000 genes
SNP context among top 1000 genes
Phenotype extreme DE
Enrichment of DEGs among GWAS genes
Gene set enrichment analysis
Indent depth genes significant (q = 0.0009)
Circularity genes significant (q = 0.009)
Area genes not significant
Connecting this with the eQTL paper
DEGs are often eGenes
Area: 80/182
Circularity: 78/203
Indent depth: 83/223
DEGs are more peripheral in the co-expression network
DEGs have relaxed selection constraint


io.xream.x7.reyc.internal
类
ClientParsed
ClientParser
HttpClientInvocationHandler
HttpClientProperies
HttpClientProxy
HttpClientResolver
MethodParsed
R
R4JTemplate
ReycProperties


SIMILE
Data Bundles
Data Bundles
This is the collection of
data bundles
produced by the SIMILE project.
art-public
- this data bundle is about digital libraries of artistic material and it's composed by datasets that are publicly redistributable.
art-private
- this data bundle is about digital libraries of artistic material but it's composed by datasets that are not all publicly redistributable
this bundle includes datasets that are not available to the public
tr
- this data bundle is about technical reports
people
- this data bundle is about people, their information and their relationships
glossary
- this data bundle is about glossaries of technical terms
bibliography
- this data bundle is about bibliographies
code
- this data bundle is about description and dependencies between source code files and parts
nci
- this data bundle is about the
NCI
's thesaurus of cancer terms


Segments: 7
Lines: 3
Width: 11px
Draw
Color Palettes
Random
Right click anywhere on the canvas to save the image to your computer
Press spacebar to redraw


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 2
Preheat the oven to 220C/425F/Gas 7.
Trim and peel the rhubarb. Cut the rhubarb into chunks and place into a pan over a medium heat.
Add the light muscovado sugar, orange juice and cinnamon. Bring to the boil, then reduce the heat to simmer for 8-10 minutes, until the rhubarb is tender but still holding its shape.
Meanwhile, sieve the flour and mixed spice into a bowl.
Add the butter and rub into the flour mixture with your fingers until the mixture resembles fine breadcrumbs.
Add the caster sugar and stir to combine.
Transfer the stewed rhubarb to an ovenproof dish and sprinkle over a thin, even layer of the crumble topping.
Transfer the crumble to the oven to bake for 10-12 minutes, or until the topping is cooked through and lightly golden-brown.
Heat the vanilla custard in a small pan, then transfer to a serving jug.
Serve the crumble in its dish at the table (place a thick heatproof board underneath), with a jug of the custard so that guests can help themselves.


?0
1
!
cm
6
7
8
9
10
».
VT
v
The
New
York
copyright
reserved
Botanical
Garden
NY>IMAS£D
NEW
YORK
BOTANICAL
GARDEN
llllllll
111
111
o
o
13670
•
OT
ANIG
AL
j
?&
.
wl
*1
26,7
ita*
148-R.s
TROPICAL
FOREST
HERBARIUM
B°t*v.
U
name:
TSSBnSKTB“^
.
.
^
q
i
Washington
office)
Determined
by_____________________________
Country:
fcLUAA,t
Political
division:
fixx.
U+CO
Locality:
(jL&T'-
(Ob'fif
I—i
i—i
^
Wild
|_|
Planted
I_I
Altitude_________m.
Tree
SI
Shrub
?
Vine
?
--------------?
Height.^^m.
D.
B.
Abundance,
site,
slope,
*7:f
^
-
i
L
f/n^y
i
vegetation
type,
etc.:
f
,
Uses,
and
part
used;
locally
or
commercially:
Other
notes:
jtcW-fyt
Jm*-
JVU$&-
Local
name:
JA
Collector:
Date
of
collection:
^
Collector’s
No.„_/_A____
Specimens
Collected
Under
the
Auspices
of
the
t—
i
.
S'
U®p5Tlme?,t
°r
Agriculture,
Forest
Service;
Tropical
Forest
Experiment
Station,
Rio
Piedras,
Puerto
Blco
18—26027-1
ana
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Next: set-macro-character, Previous: readtablep, Up: Reader Dictionary
get-dispatch-macro-character
disp-char sub-char &optional readtable ⇒ function
set-dispatch-macro-character
disp-char sub-char new-function &optional readtable ⇒ t
disp-char—a character.
sub-char—a character.
readtable—a readtable designator.
The default is the current readtable.
function—a function designator or nil.
new-function—a function designator.
set-dispatch-macro-character causes new-function to be called when disp-char followed by sub-char is read. If sub-char is a lowercase letter, it is converted to its uppercase equivalent. It is an error if sub-char is one of the ten decimal digits.
set-dispatch-macro-character installs a new-function to be called when a particular dispatching macro character pair is read. New-function is installed as the dispatch function to be called when readtable is in use and when disp-char is followed by sub-char.
For more information about how the new-function is invoked, see Macro Characters.
get-dispatch-macro-character retrieves the dispatch function associated with disp-char and sub-char in readtable.
get-dispatch-macro-character returns the macro-character function for sub-char under disp-char, or nil if there is no function associated with sub-char. If sub-char is a decimal digit, get-dispatch-macro-character returns nil.
(get-dispatch-macro-character #\# #\{) ⇒ NIL (set-dispatch-macro-character #\# #\{ ;dispatch on #{ #'(lambda(s c n) (let ((list (read s nil (values) t))) ;list is object after #n{ (when (consp list) ;return nth element of list (unless (and n (< 0 n (length list))) (setq n 0)) (setq list (nth n list))) list))) ⇒ T #{(1 2 3 4) ⇒ 1 #3{(0 1 2 3) ⇒ 3 #{123 ⇒ 123
If it is desired that #$foo : as if it were (dollars foo).
(defun |#$-reader| (stream subchar arg) (declare (ignore subchar arg)) (list 'dollars (read stream t nil t))) ⇒ |#$-reader| (set-dispatch-macro-character #\# #\$ #'|#$-reader|) ⇒ T
The readtable is modified.
For either function, an error is signaled if disp-char is not a dispatching macro character in readtable.
It is necessary to use make-dispatch-macro-character to set up the dispatch character before specifying its sub-characters.
Next: set-macro-character, Previous: readtablep, Up: Reader Dictionary


Releases
This document lists the changes between stable releases.
The version numbers follow semantic versioning.
lua‑mpi 0.2 (2015-04-24)
- Add datatypes for reduce of maximum/minimum location.
- Support in-place collective communication.
- Add Cartesian process topology.
- Add user-defined datatypes.
- Support compilation with GCC 5.
Thanks to Lesley De Cruz for contributing to this release.
lua‑mpi 0.1 (2014-12-01)
- Initial release of MPI for Lua.


{% extends 'base.html' %} {% import 'macros.html' as macro %} {%block styles%} {{ super() }} {%endblock%} {%block content%}
create interview pitch.
create product pitch.
create a promotion pitch


You wont need 8 hands to create surveys using our app. Create, manage, and view surveys by logging in. Survey results will be displayed in your profile page in an easy to read bar graph. Share your survey by sending a link.


Man found murdered in Sunrise home
by Cristina AlexanderSUNRISE, FLA. (WSVN) - Sunrise Police need help investigating the murder of Johnnie Ridgeway, who was found deceased in his own home.
Ridgeway was found dead in his residence at 5861 NW 12th Court, at around 4 p.m., Tuesday.
He was shot multiple times.
If you have any information that could lead to the arrest of the perpetrator, you’re urged to call the Sunrise Police Department or Broward County Crime Stoppers at 954-493-TIPS. Remember, you can always remain anonymous, and you may be eligible for a $3,000 reward.


I took a pill of Ambien (10mg) about 20 minutes ago, and it already seems like time has rushed past to the state I'm in now. I took the pill then headed to the bathroom to brush and clean and so on. By the time I was done I could definite feel some wooziness creeping in at a cognitive level, and deja vu, a very common returning feature, about things I would have no reason to experience deja-vu about...this sentence for example. I believe the drug makes the mind run in very circuitous patterns.
My gross motor sensations are very effected. Sitting up in a chair feels like a much greater movement than it is. There is an 'ideal movement' I sense which brings my body along with it but the body is slow in coming.
My visual perception at this very minute is pretty clear, but it takes on shapes and characters very foreign to simply reading a 2 dimensional screen. One of them asking me to create a new email address, became a decline into a profound pit which I had to work my way in and out of. A warning page about the email address thing became very hard to read with the ends of some lines curling back before I could read them. The vividness of different areas in my room is variable but tends to light up when I attend to them. But off the computer screen there are no hallucinations, just different perceptions of things that pretty much look and act normal.
My mindset is fuzzy. In clearing off my bed I had to make some decisions of where to put things and some of it, I did haphazardly. I am not in a state to understand any complicated instructions or reading. It is accompanied by word synesthesia - the words themselves seem to clunk in the way like spilled piano keys. My mood is somewhat flat affect. I am pretty perpetually surprised by the strange changes I'm witnessing but I'm not especially euphoric nor terrified or anxious. I am having 'hallucinations in my mind's eye' - I see things, as you'd see them if I asked you to say, 'picture a house', but they are hallucinations in that I am not consciously evoking these images.
My mindset is probably quite reduced in cognitive and emotional capacities but I still am able to type, with some trouble with word selection, and motor slowness.
If watching TV shows on the computer, they often begin to seem quite hilarious, although I cannot usually remember most of the subject matter. Sometimes I will talk to housemates or type messages to friends via AIM and both forms of communication tend to produce nonsense. Once I have a topic of discussion other than focusing on this I tend to expound a great deal of information about that topic regardless of the other's interest.
I have had an experience that some websites (such as the gmail registration) gave me the feeling that other entities were down there with me as part of the process. I didn't perceive them as friendly or hostile, just there. I didn't really perceive them either, just felt their presence.
In bed I generally get closed eye visuals to the extreme, sometimes seeming to be small worlds composed of connecting tunnels to other worlds, which I explore and plunge deeper and deeper into.
Right now, T+20 minutes, I'm writing this and wondering what the point is, as well as being convinced I wrote something exactly like it before. The cognitive impairment caused by Ambien is powerful. In other ambien experiences I have found that a friend's screen saver could entrance for any amount of time (until I got kicked out of the room and that I can babble ceaselessly about ephemera for quite a time when I have an audience. Because of this I am not planning to leave my room right now.
Body movements feel slowed and dragged as if the ethereal 'superbody' were leading all the movements and dragging my shape along in its tracks. I notice that my face looks haggard and zombie like in the mirror, as usual with ambien. I am thirsty and drink some water, The rim of the cup seems unusually thick.
There are no effects I would describe as 'tripping' except for the way certain things on the computer screen (often web pages) take on a shockingly different character than just blank text. The text may seem to grow into a location I've seen in life, or the entire page may seem to become a bottomless shaft at which I am at the bottom, the walls lined with check boxes and lines to type answers into. Once while communicating with a friend over AIM I felt there was a version of myself somehow manifest in the world that our IMs inhabited; this other self was in a version of Philadlphia's Chinatown. My friend told me to 'come to his house' which is walking distance from Chinatown and I tried to make the avatar do that but the situation fell apart before I could make it happen.
I am now thinking about the addictive character of these pills, which i have been using as prescribed as a sleep aid. They produce euphoria and tripping sometimes, other times just cognitive distortions and stoned apathy, which is what I have now. It will make me fall asleep soon, I can feel the drowsiness. It also removes all worries, about school, work, girls and the future. All of these combined seem to have quite a potential for abuse. I ration mine however, trying to use them only on night when I have to get up early.
When not on the pills, I look back at some of my stoned writings or antics and am appalled at what a jackass I acted like, not to mention taking my problems serious again. Still, every night there is a powerful urge to take the ambien again and a fear that I won't be able to sleep if I don't. So I usually do.
The drowsiness hits pretty hard now. Also the thirst - always have a full glass of water by the bed all night and be ready to get up and pee a few times before I fall asleep.
Exploring the rest of the apartment mostly indicates that my gross motor skills are very inhibited - I feel that I walk roboticaly and shuffle and bump into things a lot. Seeing things that require comment, my inner speech goes from being articulate (man, my roommates really need to clean these dirty dishes) to partial sentences (dirty...disgusting habits...dirty roommates..got to clean)
This ambien experience is probably going to end now as I'm going to bed. Usually there I experience more vivid closed eye hallucinations, again of a neutral variety (not especially stunning or beautiful, though interesting, and not frightening or disturbing. Definitely weird though.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


To render the UI, you must provide a renderer that will receive data from the Otter API and present it on screen. The Otter API, at render-time, collects the drawing information of all the on-screen elements and organizes them into batches. These batches are then sent the user-provided renderer to be drawn.
In addition to sending vertices and draw batches, the renderer is also responsible for loading and unloading textures.
Creating a Renderer
In order to implement your own renderer, create a new class that inherits from Otter::IRenderer and implements the following methods:
class SampleRenderer : public Otter::IRenderer { /* Loads a texture with the specified id and path */ virtual void OnLoadTexture(int textureID, const char* szPath); /* Unloads a texture with the specified id */ virtual void OnUnloadTexture(int textureID); /* Called when a drawing pass has begun */ virtual void OnDrawBegin(); /* Called when a drawing pass has ended */ virtual void OnDrawEnd(); /* Commits a vertex buffer for rendering */ virtual void OnCommitVertexBuffer(const Otter::GUIVertex* pVertices, uint32 numVertices); /* Draws primitives on screen */ virtual void OnDrawBatch(const Otter::DrawBatch& batch); }; |
These methods will be called by the Otter API during render-time, and it is up to you to ensure they are implemented correctly in your application. A quick overview of the methods are as follows:
OnLoadTexture
This method is called when the Otter API requires a texture to be loaded. The path of the texture is provided as well as its internal ID. After this function completes, the texture will always be referenced by its ID. It is recommended to create a fast mapping between the internal texture ID and the actual texture reference.
OnUnloadTexture
This method is called when the Otter API no longer requires the texture, as specified by the provided texture ID.
OnDrawBegin
This method is called once per frame, and indicates that the Otter API is about to send render information. In this function you would set up the appropriate render states, projection matrices, and so on.
OnDrawEnd
This method is called once all the render information has been sent, and thus concludes rendering for the current frame.
OnCommitVertexBuffer
This method provides a linear vertex buffer that will be used for incoming draw batches. In this function you would update your internal vertex buffers appropriately.
OnDrawBatch
This method may be called multiple times a frame. It draws elements in batches, sorted by texture, transform, and render flags.
Using the new Renderer
Once the new renderer has been implemented, instantiate it and assign it to the Otter System
gRenderer = new D3DRenderer(); gSystem->SetRenderer(gRenderer); |
Created with the Personal Edition of HelpNDoc: Single source CHM, PDF, DOC and HTML Help creation


PWNy Bracelet Configuration
connecting...
Gesture name
Command
{{gesture.name}}
Train
{{gesture.command}}


The Boundary Service API provides a restful interface to a wealth of data about official geographic boundaries within Illinois. Data is retrieved from the API as JSON (optionally JSONP) with nested GeoJSON for describing the boundary shapes.
There are two resources described by the API: Boundary Sets and Boundaries.
Boundary Sets describe the extent and provenance of a group of Boundaries as well how recently they were last updated. Here, for example, is the Boundary Set for census tracts:
{ authority: "U.S. Census Bureau", boundaries: [ "/1.0/boundary/census-tract-1-7/", "/1.0/boundary/census-tract-1-9/", "/1.0/boundary/census-tract-1/", "/1.0/boundary/census-tract-1-8/", ... ], count: 3123, domain: "Illinois", href: "http://www.census.gov/cgi-bin/geo/shapefiles2010/main", last_updated: "2011-01-08", metadata_fields: [ "STATEFP10", "COUNTYFP10", "TRACTCE10", "GEOID10", "NAME10", "NAMELSAD10", "MTFCC10", "FUNCSTAT10", "ALAND10", "AWATER10", "INTPTLAT10", "INTPTLON10" ], name: "Census Tracts", notes: "Shapes used for 2010 census.", resource_uri: "/1.0/boundary-set/census-tracts/", slug: "census-tracts" }
Descriptions of all the properties of a Boundary Set can be accessed at:
http://{{ settings.API_DOMAIN }}/1.0/boundary-set/schema/
To see a paginated list of available Boundary Sets access the following url:
http://{{ settings.API_DOMAIN }}/1.0/boundary-set/
A single BoundarySet may be accessed directly by its slug:
http://{{ settings.API_DOMAIN }}/1.0/boundary-set/community-areas/
Boundaries are the individual shapes within a Boundary Set. The Boundary for A-C Central Community Unit School District 262 looks like:
{ centroid: { coordinates: [ -90.084528 39.952622 ], type: "Point" } external_id: "00105", kind: "Unified School District", metadata: { ALAND: 377198165, AWATER: 1185357, FUNCSTAT: "E", HIGRADE: "12", INTPTLAT: "+39.8619840", INTPTLON: "-090.0553779", LOGRADE: "PK", LSAD: "00", MTFCC: "G5420", NAME: "A-C Central Community Unit School District 262", SDTYP: "", STATEFP: "17", STATENS: "01779784", UNSDIDFP: "1700105", UNSDLEA: "00105" }, name: "A-C Central Community Unit School District 262", resource_uri: "/1.0/boundary/a-c-central-community-unit-school-district-262-unified-school-district/", set: "/1.0/boundary-set/unified-school-districts/", simple_shape: { coordinates: [ [ [ [ -89.9756, 39.886457 ], [ -89.975954, 39.836324 ] ... ] ], type: "MultiPolygon" }, slug: "a-c-central-community-unit-school-district-262-unified-school-district" }
Resources representing individual Boundaries can be accessed at:
http://{{ settings.API_DOMAIN }}/1.0/boundary/
As with Boundary Sets a description of all properties returned with the Boundary can be retrieved from:
http://{{ settings.API_DOMAIN }}/1.0/boundary/schema/
And a single Boundary may be accessed directly by its slug:
http://{{ settings.API_DOMAIN }}/1.0/boundary/austin-community-area/
For ease of url construction a Boundary may also be referenced by appending the Boundary's external_id
property to it's parent BoundarySet's uri. Example:
http://{{ settings.API_DOMAIN }}/1.0/boundary-set/wards/22
This returns the 22nd Chicago city ward.
Note: The metadata fields returned with a Boundary are taken directly from the relevant data sources. In certain cases these are known to be out-dated. An effort has been made to capture such issues in the BoundarySet's notes property, but these values should generally not be taken at face value.
Pagination of returned resources is handled with the limit
and offset
parameters:
http://{{ settings.API_DOMAIN }}/1.0/boundary/?limit=10&offset=10
In addition, queries may (and should) be constrained by passing a comma-delimited list of BoundarySet slugs to the sets
parameter:
http://{{ settings.API_DOMAIN }}/1.0/boundary/?sets=community-areas,neighborhoods
The fundamental query exposed by the Boundary Service is a point-in-polygon search by latitude and longitude. Here is an example:
http://{{ settings.API_DOMAIN }}/1.0/boundary/?contains=41.8903239,-87.623458&sets=community-areas
This will return the community area that Tribune Tower resides in, the Near North Side.
Note: In addition to the contains
parameter we also pass the sets
parameter to constrain the query. Its important to use this parameter to limit your queries to only the data you need so your queries will be performant.
The near query finds all Boundaries that intersect a circle of a specified radius using a given point as its center:
http://{{ settings.API_DOMAIN }}/1.0/boundary/?near=41.8903239,-87.623458,1mi&sets=wards
This returns all wards within one mile of Tribune Tower. The radius parameter may be specified in any units supported by GeoDjango.
Note: This query will execute more slowly than the point query.
The intersects query finds all Boundaries which intersect a specified Boundary. For example, to find all neighborhoods which intersect the Humbolt Park Community Area, one would request:
http://{{ settings.API_DOMAIN }}/1.0/boundary/?intersects=humboldt-park-community-area&sets=neighborhoods
The Boundary Service does not currently support querying by arbitrary shapes.
For use in client-side applications the Boundary Service API may be accessed via JSONP. Simply append the format
and callback
parameters to the query string:
http://{{ settings.API_DOMAIN }}/1.0/boundary/?format=jsonp&callback=func
The Boundary Service API can be accessed anonymously up to 100 times per hour per IP address. This throttling is in place in order to ensure that it can be scaled to meet demand without extensive outages. If you intend to build an application which will query the API in bulk, please e-mail us your requested username and we will provide you with an API key that allows unlimited access. This implementation will allow us to take appropriate action in the event that a single source of the traffic is causing the service to be unstable.
An API key can be used as follows:
http://{{ settings.API_DOMAIN }}/1.0/boundary/?username=example_user&api_key=3b7b288ca1f9d90bef69c3eb4d880184f84ff740


New Mexico issues warning as vaping illnesses increase
SANTA FE, N.M. (AP) - State health officials say three more cases of severe lung injury related to the use of e-cigarettes for vaping have been confirmed, bringing the total number of cases in New Mexico to 20.
The state Health Department announced the additional cases Wednesday.
In all, more than 2,000 Americans who vape have gotten sick since March, many of them teenagers and young adults, and at least 40 people have died.
Thirteen of New Mexico’s patients have required hospitalization in intensive care units.
Of the patients interviewed by the state health department, more than three-quarters reported the use of THC, the high-inducing part of marijuana. Three patients reported only nicotine use.
New Mexico officials are discouraging the vaping of THC products and the vaping of any products containing Vitamin E acetate.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Job Title : {{job.job_title}}
{{job.company.recruiter_profile.company_name}}
{{job.company.recruiter_profile.city}},{{job.company.recruiter_profile.country}}
Computer Support Specialists: Computer support specialists/network specialists provide support
to Information Technology employees within an organisation. They help IT staff analyze,
troubleshoot and evaluate the computer network problems.
Number of Applies : {{job.applied_people.count}}


The Awwwards SOTD is an exciting collective to be amongst: it's great to be acknowledged
{%extends 'all-projects/base.html'%} {% block content %}
Every month, more than 2,000,000 unique userswho specialize in web design, development and the latest web technologies, visit our site looking for inspiration, trends and talent on the web.
Submission Only
USD/ONCE
Your website will be reviewed and voted on by our international jury, made up of some of the best designers, developers and agencies worldwide.
The best sites will be awarded Site of the Day, Honorable Mention and Site of the Month and will be in the running to win Site of the Year, the winner of which, will be announced at our prize giving ceremony in February 2020 in Amsterdam.


Tips and Advice on Go Etiquette
PT-BR: Pretendo fazer um vídeo sobre este assunto no meu canal no futuro próximo. Quando ele existir, atualizarei esta página.
I've made terrible mistakes over the years when playing Go. And the
biggest, more important ones were not moves in games or tournaments,
they were people mistakes. I've had my share of friendship-ending and
friendship-building attitudes, and it's not nice to not have control
over this topic. After all, our deepest dependency, since the
beginning of the human race, has been the same
We tend to focus too much on teaching and learning the game itself, without focusing at least a good portion of our time explicitly into the relationship topic. But, as this AI era might have taught you, without another person, the game can easily become void or much less meaningful, at least in comparison to what it can be as a social experience.
That's where Go etiquette comes into play: it is a convention, a
solution to avoiding bad human interactions and highlighting the good
ones. And the solution part should be the main point whenever teaching
one of these rules, because it's not about being pedantic or blindly
following dogmas, it's about keeping people sane, it's about filtering
nuisance, it's about avoiding probably the biggest evil of social
interaction: shame
When teaching Go etiquette, the fundamentals are not the basic or most
common rules but the explanations behind them
Recently, I've been finding a lot of inklings of improvements to myself and the Go community by examining parallels to other related communities, like Jiu Jitsu. Probably my favorite unexpected source is Nick Albin's rambles on his YouTube channel, Chewjitsu. The Jiu Jitsu community is much more socially developed than the Western Go community, there's been much more successful experimentation.
This article might have follow-ups in the future as I get feedback from it, and due to there being so many etiquette rules and good practices...
I currently have 8+ years of experience with this game (1-2 dan on
KGS
Nevertheless, more importantly, I have made a bazillion mistakes, so at least you will for sure learn a ton of the "don't"s from me.
Here go some of my most valuable tips, which you might find elsewhere, but, in my opinion, not with the same nuance, completeness or attention to pitfalls...
The numbering of the items in the next sections is purely for ease of reference, i.e., there's no hierarchy in the rule set I expose below.
-
Smiling and being open minded are probably the MVPs of etiquette and
best practices. You can basically do everything else and yet people
will probably prefer playing with an ignorant, smiling, happy
player.
-
Oftentimes we don't realize we are treating the other badly. The
best way of solving this problem is using the other's emotions
as feedback on your attitude: try to make an effort of
recognizing negative emotions on his or her face and, right then
and there ask what is bugging him or her.
- Research shows couples which try to defuse negative emotions the quickest are the happiest, not those which try to avoid discussions.
-
Oftentimes we don't realize we are treating the other badly. The
best way of solving this problem is using the other's emotions
as feedback on your attitude: try to make an effort of
recognizing negative emotions on his or her face and, right then
and there ask what is bugging him or her.
-
Don't make noises with your stone bowl while you're thinking.
-
Some people told me — hoping for an excuse —
shuffling the stones calms them down. When it comes to etiquette
your point of view is not enough for establishing a good
practice or getting absolved. If something is a good practice
for you but annoys
everyone else, please stop.
-
Some people told me — hoping for an excuse —
shuffling the stones calms them down. When it comes to etiquette
your point of view is not enough for establishing a good
practice or getting absolved. If something is a good practice
for you but annoys
-
If you feel like an attitude of yours or of someone else will or is
making you ashamed, try your best to shake it off
.  Slowly, this contagiousness will annoy other people, and you might get labeled as the root. -
Don't place-and-slide the stones, it's distracting and adds an
unnecessary visual layer to your movement.
- And some people use it to cheat, since they can gather some info about where they will ultimately move the stone while watching the other player's facial expressions.
- I've seen people get really pissed at players who do this sort of thing in tournaments. And this was eventually officially banned in the KPMC since 2017. And I really can't remember if I've ever seen an Asian pro doing it.
-
Be objective and honest when reviewing games, without offending
people.
- Practice this carefully, we could write whole books about this topic. It is great when it goes well, but terribly awful when it doesn't.
-
Gently place stones, do not use too much force.
- It's pleasant to clack the stones as loud as possible, but it's only pleasant to you.
- I don't think I have ever seen a single professional clacking stones loudly, be him or her Japanese, Korean, Chinese, American or European. That goes to show that, if you think clacking stones is the right way to go, you're probably actually wrong.
-
Respect handicaps at all costs, be disciplined about it.
-
The minute you go disregard handicaps is the minute you
implicitly disrespect the other player, be him/her weaker or
stronger. It might seem like a small thing sometimes, but it
seeps into many other contexts. For example, it poisons the
environment when you get into a review.
- Even if you feel like the handicap is inaccurate, endure it. Next time, you can politely ask to readjust it; or use the rule of 3 losses/wins in a row and it automatically changes, up or down. This discipline will dissipate the rank doubts in the long run.
-
The minute you go disregard handicaps is the minute you
implicitly disrespect the other player, be him/her weaker or
stronger. It might seem like a small thing sometimes, but it
seeps into many other contexts. For example, it poisons the
environment when you get into a review.
-
Nigiri when players have the same rank.
- Whoever wins this odds-or-even gets Black, it's not about choice actually.
-
If you're the stronger player, avoid playing more than one opponent
at the same time.
- Unless they are explicitly ok with it, they will feel as if their time is not worth your full attention.
-
If you win, wait for your opponent's — sometimes implicit
— permission before starting the review.
- That's how they do it in the KBA as far as I know. In fact, the implicit etiquette for Korean pro players is usually to let the loser speak for most of the review. Reviewing the game is seen as a way of coping with the loss apparently.
-
Sincerely thank your opponent for the game, specially if you win.
Mean it.
-
This game is essentially mental fighting, so the same respect
martial artists usually show for one another should be
replicated to Go.
- At least fighters can have their wounds on their bodies. Mental games overload the players' psyches.
-
This game is essentially mental fighting, so the same respect
martial artists usually show for one another should be
replicated to Go.
-
When commenting on the game don't use imperative sentences —
e.g. "you should", "this is better", etc. —, prefer
exposing opinions — e.g. "I think"/"I believe". Let the other
player take what he wants from it, time and experience will tell
who's right eventually.
- There's also the psychological fact that people accept orders more easily if they are posed as friendly — rhetorical — questions.
-
When the game is over, each player should count the opponent's
points.
- This way each player will extract the captured stones of their own color, which will avoid hand-bowl collisions when organizing things. Having people put stuff in your bowl feels like an overreach, since you develop a sense of property over them throughout the game. I know, I know, humans are weird...
- This one is a speculation of mine: I think that, psychologically, this reduces the likelihood of cheating as well. Most players tend to count much more often their own points than their opponent's, so cheating on the other player's counting process feels a lot shakier if you're gonna try it after the game ended and the shapes have been reorganized.
-
Preferably organize counted territories in pockets of multiples of
5.
-
Personally, I think that rectangular shapes work just as well,
if not better. And, surprisingly, I haven't had any complaints,
even from pros and high dan amateurs.
- Multiplying the sides can be easier than recognizing multiples of 5 in odd, weird shapes, though you will get accustomed to these weird but common counting shapes.
- My favorite counting technique is actually composing the whole territory into preferably only one giant rectangle. This way we have to perform only one multiplication to count the whole thing, instead of adding a ton of smaller pocket-sized territories, which also demands some memory. It's more efficient computationally actually, although it messes up the board more.
- This also goes for organizing the captured stones, both during and at the end of a game.
-
Personally, I think that rectangular shapes work just as well,
if not better. And, surprisingly, I haven't had any complaints,
even from pros and high dan amateurs.
-
If you're both using a game clock, please be more patient and nicer
than usual. An explicit clock puts even more psychological pressure
into the game.
- Online we don't even need to deal with the clock much, since it's automatic. Having to tap the clock physically is way more annoying than we might expect initially.
- Unless you're dealing with a total beginner, don't call out ataris. For those who can recognize them, it's a very annoying interruption of the silent flow of the game when this happens.
- When transitioning between sequences in the review, recollect the current sequence's stones backwards so as to make the process clearer to everyone.
-
If you're the weaker player in the review, preferably, only expose
your thoughts when the stronger player leaves a communication
opening.
- In the case of reviews, when I say stronger, I mean considerably so. Usually this means the stronger player is at least 3 stones up. Otherwise both players can come up with — relatively — valuable information quite often.
- If you're the stronger player and you're not reviewing — probably because you're hurt from losing —, you're doing a disservice to yourself, the opponent and the community as a whole.
-
AIs provide better options, not absolute answers nor explanations. A
stronger player's move might have more value than the AI's simply
because its explanation makes it more reproducible.
- A technique that is not reproducible is more like a unique painting than a technique.
-
Using Black and White instead of pronouns and names can be positive
with respect to making the review more objective. But using names
and pronouns can also help bridge the brutal winner-loser dichotomy.
- Unlike the simplistic advice people give about being objective in the review, be mindful that there is no simple solution to this problem and that it is a very relevant one.
-
When the game ends, please put the stones back into their respective
bowls — after counting and reviewing.
-
This is probably the faux pas that makes more experienced
players
the angriest, though almost always accidental. - If you want to go to the bathroom, either hold it in and quickly put everything in its place or warn the other player. Otherwise he or she will think you ran away expecting to skip organizing everything.
-
This is probably the faux pas that makes more experienced
players
-
Get away from
Hikaru no Go's
mysticism.
- This is mostly a beginner's problem, but sometimes you get a single digit kyu (SDK) still wrapped around this mindset.
-
It's just a game, mate.
- This dismissive statement doesn't defeat the purpose of this article actually. Etiquette and the game itself are basically media by which we interact; interactions which are far more important than the implementation details of the etiquette system or the game. The apparent paradox here is that we couldn't extract proper interactions without going through the less important interfaces of etiquette and the game itself.
- It can personally become something bigger, but it's a narrative you're gonna have to create for yourself, in a sane and healthy manner.
-
Maybe reading
The Myth of Sisyphus, by Albert Camus, will help you out
.
-
When playing Pair Go, don't tell your partner where to play, be it
implicitly or explicitly.
- This one seems obvious because it's the most explicitly emphasized rule in Pair Go. But I think that, out of the close to 50 pair Go games I've played, maybe only once or twice have I played the full game without this happening.

-
It's understandable — though not easily forgivable —
that you would get mad if a sequence you triggered gets
destroyed by something that's out of your control, like your
Pair Go partner. However, he or she is playing the best possible
Go they can and, so, please squash your anger before any words
come out of your mouth or any emotions pop on your face.
- Put yourself in your partner's place. How is it acceptable to be mad at them in a situation where his or her best gets demoralized by a teammate who should be actually helping?
-
This one reveals a total lack of team mentality. Being mad at
your partner's screw up because it's the sequence
you wanted to see happen is plain old selfishness,
something that's easy for people to get addicted to since Go is
individual sport.

- If you're going to lash out on your partner, please do it in private so as to not cause too much shame on everyone.
-
It's understandable — though not easily forgivable —
that you would get mad if a sequence you triggered gets
destroyed by something that's out of your control, like your
Pair Go partner. However, he or she is playing the best possible
Go they can and, so, please squash your anger before any words
come out of your mouth or any emotions pop on your face.
-
Teach beginners often.
- If you're not being nice to newcomers and helping them, you're being rude to the whole community.
- Many more experienced players try to avoid beginners because they are seen as a waste of time since there's such a colossal skill- and time-wise gap between them. However, every one of us was once a beginner; and just imagine the huge impact we could get from advice coming out of expert, black belt minds.
- And most people severely underestimate the value a beginner provides. Their minds are tabula rasa, they have none of the prejudices we might have already built, they will unconsciously teach us how to think with a truly open mind once again.
Most of what was discussed in the previous section also applies to the online context, but here go some tips which are more specific to the online context:
-
Preferably say "hello" and "have a good game" ("gg").
- It's basically the internet's — videogamey — version of onegaishimasu.
- Originally, "gg" was created with the purpose of resigning gracefully in the videogame Starcraft. However, this sort of expression is so simple and versatile that people, both in the Starcraft and Go communities, use it both at the start and beginning of games.
-
99% of internet players view it as mandatory, but most of the
more experienced players, including myself, view it as annoying
boilerplate.
- If you ask high dan players if they consider an opponent rude for not saying "hi gg" at the beginning of an online game, I bet on 9:1 most of them will say something like "I don't care".
- This might seem contradictory to what was discussed at the beginning of the previous section. But not having the other player physically in front of you changes your experience. Personally, I think a decent attitude at the end of the game is much more important. And decent enough in this context can simply be silence in my opinion.
-
Don't forcibly play fast.
- Put a lot of asterisks on this one for sure.
- Some players do play naturally fast, and I don't think there should be a problem with that. But I sometimes see online players trying too hard to play fast in order to destabilize the other player psychologically.
-
Don't escape.
- This is a niche faux pas to KGS, where the platform allows for getting away of the game without resigning. Please don't ever do this, you will regret it, word gets around.
-
Losing by time seems to make some people almost just as mad.
-
But I, again, don't get it. Specially if you've played some
chess, you will realize that winning or losing by time is
normal, you shouldn't care.
-
The argument against it revolves around the fact that
the loser wants to diminish the value of the win because
then he could excuse himself by saying that there wasn't
enough time to think. But the fact that there wasn't
enough time almost always implies that your opponent put
you in a difficult situation anyway, so all the merits
to him or her.
- And don't get me started on some other people saying that it will distort the way the game was won. For example, one player could be losing by 100+ points and the final status of the game would be "win by time". By this insane logic, we would have to always go through the very end, because simply resigning doesn't reveal any point-wise delta in the scorecard anyway.
-
The argument against it revolves around the fact that
the loser wants to diminish the value of the win because
then he could excuse himself by saying that there wasn't
enough time to think. But the fact that there wasn't
enough time almost always implies that your opponent put
you in a difficult situation anyway, so all the merits
to him or her.
-
But I, again, don't get it. Specially if you've played some
chess, you will realize that winning or losing by time is
normal, you shouldn't care.
-
Don't be mad at last minute invasions, they are part of the game,
part of life actually.
- As you get stronger, they happen less and less.
-
What is the problem with final Hail Mary's? If you have a
winning position but a portion of your territory is iffy, there
is no problem in your opponent questioning it.
- The funny thing is that almost all DDKs and SDKs are totally dumbfounded when they ask a pro to review their games and the pro finds a million different ways of destroying their moyos.
- As a personal confession, I've once managed to lose a good friend, when I started playing Go, because he had the habit of last minute invasions. After a bad verbal fight, we never spoke again... I think we were both wrong in the end, but that won't absolve me anyway.
The tips below are some pearls I've found scouring the Go etiquette page on Sensei's Library — I've also paraphrased some of the content.
-
In simultaneous games, play your move when your opponent has reached
your table, not while he is away.
- Or at least point to the move when the more experienced player comes to your table.
-
Only take the stones off the bowl when you're ready to place them.
- Please, keep your hands off the bowl 99% of the time.
-
Keep captured stones visible at all times.
- It's very annoying to count the points when this doesn't happen.
- Tidy them in multiples of 5 too, just like when counting the points at the end of the game.
-
Don't play the first move in the corner closest to the opponent's
bowl.
-
The usual take is actually for you to play the first move on the
upper right. By stretching yourself into that corner you
implicitly bow to the White player, which is historically the
stronger one, usually the master
. - However, from poking around with this rule, I realized that most people develop a sense of ownership for the corner that's closest to their own bowl, which might be to their left if the person is left-handed. To me, this unconscious tendency overrides the "play the first move in the upper right corner".
-
The usual take is actually for you to play the first move on the
upper right. By stretching yourself into that corner you
implicitly bow to the White player, which is historically the
stronger one, usually the master
I will never be able to cover all of the possible variations:
real-time interactions are too rich for me or anyone to prescribe them
all completely. Humans will always come up with something creative and
valid in the end
Don't let tradition hinder you, though. Those who choose to blindly
preserve nonsensical conventions are not in-depth contextual
thinkers
Click here for the complete post discussion on Reddit.


one world
trade center
Increasing prosperity in our lives can be accomplished by having the right frame of mind. The truth is, our thoughts are very powerful. They are capable of influencing every aspect of our daily lives, from our physical health to our social behaviors.  ”If we want to improve our lives, we must first improve our thoughts. Harnessing the power of thought in a positive way has the ability to create great change in our lives, including our financial well-being and prosperity. But how? How do we take something as intangible as thoughts, and manifest them into a physical reality? We must first understand that being prosperous is more than having a lot of money. Prosperity is a mindset, a way of interacting in our lives, and a way of thinking. Mastering this train of thought is not easy, but it is simple enough if we keep working on it consistently. Following are some ideas to help you improve your thoughts, and ultimately attract more prosperity into your life: Be grateful for the blessings in your life right now. Take a few minutes each day to express heartfelt gratitude for the good things in your life. Even more powerful, write a few of these blessings down each day. This helps to put your focus in the right direction — on abundance, not lack. Use positive affirmations to begin training yourself to think positively. Use “I am” statements such as “I am worthy of all that is good.” Write the statements down and repeat them nightly before bed. Over time, this will implant these thoughts into your subconscious mind, and you will begin to naturally believe them. Creative visualization can help you achieve prosperity by determining what it is you wish to achieve, and then thoroughly creating that image in your mind. This works in the same way affirmations do.Our subconscious will fill with images of prosperity, and eventually these subconscious “truths” will manifest in the physical. “See” yourself as being prosperous, and you will become so. Encourage yourself with the belief that you can achieve great things. This could also be one of your affirmations, but expand on it. If you know you can earn a certain salary, tell yourself you can earn more. Allow yourself to believe all things are possible, and you will gain the confidence needed to reach higher than you ever imagined you could. If you believe you can do it, you are more likely to take the risks associated with people who are highly successful.Prosperity and success go hand in hand, so take risks and aim higher. Start a savings account. As strange as it sounds, think about this: Like Attracts Like. Even if you can only afford to put a few dollars into your account every month, it will begin to build up and attract more money. Finally, believe you are already wealthy. The creative ability of our thoughts is such that we lend more power and energy to whatever we consistently focus on. Focusing on lack will create more lack.  Remember that this is a process. You likely won’t change your circumstances in one day. But over time, with consistent focus, your thoughts will begin to attract what you want. Once you master this power of thought, there are truly no limits to what you can create!
New York City, United States - 1776 feet


SUPERSTORE
Up to 50% Off
On Selected Items Online And In Stores
$25.50
$45.55
$20.99
$25.60
$70.50
$33.50
$45.30
$10.20
Our dedicated troop of employees are always on their feet and happy to help.
We offer free shipping nationally and reasonable shipping costs internationally.
Need help? Customer care is always on the line.


public abstract class FragmentManager
extends java.lang.Object
android.app.FragmentManager
.
Used to write apps that run on platforms prior to Android 3.0. When running
on Android 3.0 or above, this implementation is still used; it does not try
to switch to the framework's implementation. See the framework FragmentManager
documentation for a class overview.
Your activity must derive from FragmentActivity
to use this. From such an activity,
you can acquire the FragmentManager
by calling
FragmentActivity.getSupportFragmentManager()
.
| Modifier and Type | Class and Description |
|---|---|
static interface |
FragmentManager.BackStackEntry
Representation of an entry on the fragment back stack, as created
with
FragmentTransaction.addToBackStack() . |
static interface |
FragmentManager.OnBackStackChangedListener
Interface to watch for changes to the back stack.
|
| Modifier and Type | Field and Description |
|---|---|
static int |
POP_BACK_STACK_INCLUSIVE
Flag for
popBackStack(String, int)
and popBackStack(int, int) : If set, and the name or ID of
a back stack entry has been supplied, then all matching entries will
be consumed until one that doesn't match is found or the bottom of
the stack is reached. |
| Constructor and Description |
|---|
FragmentManager() |
| Modifier and Type | Method and Description |
|---|---|
abstract void |
addOnBackStackChangedListener(FragmentManager.OnBackStackChangedListener listener)
Add a new listener for changes to the fragment back stack.
|
abstract FragmentTransaction |
beginTransaction()
Start a series of edit operations on the Fragments associated with
this FragmentManager.
|
abstract void |
dump(java.lang.String prefix,
java.io.FileDescriptor fd,
java.io.PrintWriter writer,
java.lang.String[] args)
Print the FragmentManager's state into the given stream.
|
static void |
enableDebugLogging(boolean enabled)
Control whether the framework's internal fragment manager debugging
logs are turned on.
|
abstract boolean |
executePendingTransactions()
After a
FragmentTransaction is committed with
FragmentTransaction.commit() , it
is scheduled to be executed asynchronously on the process's main thread. |
abstract Fragment |
findFragmentById(int id)
Finds a fragment that was identified by the given id either when inflated
from XML or as the container ID when added in a transaction.
|
abstract Fragment |
findFragmentByTag(java.lang.String tag)
Finds a fragment that was identified by the given tag either when inflated
from XML or as supplied when added in a transaction.
|
abstract FragmentManager.BackStackEntry |
getBackStackEntryAt(int index)
Return the BackStackEntry at index index in the back stack;
entries start index 0 being the bottom of the stack.
|
abstract int |
getBackStackEntryCount()
Return the number of entries currently in the back stack.
|
abstract Fragment |
getFragment(Bundle bundle,
java.lang.String key)
Retrieve the current Fragment instance for a reference previously
placed with
putFragment(Bundle, String, Fragment) . |
abstract java.util.List<Fragment> |
getFragments()
Get a list of all fragments that have been added to the fragment manager.
|
abstract boolean |
isDestroyed()
Returns true if the final
Activity.onDestroy()
call has been made on the FragmentManager's Activity, so this instance is now dead. |
FragmentTransaction |
openTransaction()
Deprecated.
|
abstract void |
popBackStack()
Pop the top state off the back stack.
|
abstract void |
popBackStack(int id,
int flags)
Pop all back stack states up to the one with the given identifier.
|
abstract void |
popBackStack(java.lang.String name,
int flags)
Pop the last fragment transition from the manager's fragment
back stack.
|
abstract boolean |
popBackStackImmediate()
Like
popBackStack() , but performs the operation immediately
inside of the call. |
abstract boolean |
popBackStackImmediate(int id,
int flags)
Like
popBackStack(int, int) , but performs the operation immediately
inside of the call. |
abstract boolean |
popBackStackImmediate(java.lang.String name,
int flags)
Like
popBackStack(String, int) , but performs the operation immediately
inside of the call. |
abstract void |
putFragment(Bundle bundle,
java.lang.String key,
Fragment fragment)
Put a reference to a fragment in a Bundle.
|
abstract void |
removeOnBackStackChangedListener(FragmentManager.OnBackStackChangedListener listener)
Remove a listener that was previously added with
addOnBackStackChangedListener(OnBackStackChangedListener) . |
abstract Fragment.SavedState |
saveFragmentInstanceState(Fragment f)
Save the current instance state of the given Fragment.
|
public static final int POP_BACK_STACK_INCLUSIVE
popBackStack(String, int)
and popBackStack(int, int)
: If set, and the name or ID of
a back stack entry has been supplied, then all matching entries will
be consumed until one that doesn't match is found or the bottom of
the stack is reached. Otherwise, all entries up to but not including that entry
will be removed.public abstract FragmentTransaction beginTransaction()
Note: A fragment transaction can only be created/committed prior
to an activity saving its state. If you try to commit a transaction
after FragmentActivity.onSaveInstanceState()
(and prior to a following FragmentActivity.onStart
or FragmentActivity.onResume()
, you will get an error.
This is because the framework takes care of saving your current fragments
in the state, and if changes are made after the state is saved then they
will be lost.
@Deprecated public FragmentTransaction openTransaction()
public abstract boolean executePendingTransactions()
FragmentTransaction
is committed with
FragmentTransaction.commit()
, it
is scheduled to be executed asynchronously on the process's main thread.
If you want to immediately executing any such pending operations, you
can call this function (only from the main thread) to do so. Note that
all callbacks and other related behavior will be done from within this
call, so be careful about where this is called from.public abstract Fragment findFragmentById(int id)
public abstract Fragment findFragmentByTag(java.lang.String tag)
public abstract void popBackStack()
public abstract boolean popBackStackImmediate()
popBackStack()
, but performs the operation immediately
inside of the call. This is like calling executePendingTransactions()
afterwards.public abstract void popBackStack(java.lang.String name, int flags)
name
- If non-null, this is the name of a previous back state
to look for; if found, all states up to that state will be popped. The
POP_BACK_STACK_INCLUSIVE
flag can be used to control whether
the named state itself is popped. If null, only the top state is popped.flags
- Either 0 or POP_BACK_STACK_INCLUSIVE
.public abstract boolean popBackStackImmediate(java.lang.String name, int flags)
popBackStack(String, int)
, but performs the operation immediately
inside of the call. This is like calling executePendingTransactions()
afterwards.public abstract void popBackStack(int id, int flags)
id
- Identifier of the stated to be popped. If no identifier exists,
false is returned.
The identifier is the number returned by
FragmentTransaction.commit()
. The
POP_BACK_STACK_INCLUSIVE
flag can be used to control whether
the named state itself is popped.flags
- Either 0 or POP_BACK_STACK_INCLUSIVE
.public abstract boolean popBackStackImmediate(int id, int flags)
popBackStack(int, int)
, but performs the operation immediately
inside of the call. This is like calling executePendingTransactions()
afterwards.public abstract int getBackStackEntryCount()
public abstract FragmentManager.BackStackEntry getBackStackEntryAt(int index)
public abstract void addOnBackStackChangedListener(FragmentManager.OnBackStackChangedListener listener)
public abstract void removeOnBackStackChangedListener(FragmentManager.OnBackStackChangedListener listener)
addOnBackStackChangedListener(OnBackStackChangedListener)
.public abstract void putFragment(Bundle bundle, java.lang.String key, Fragment fragment)
getFragment(Bundle, String)
will return the current
instance of the same fragment.bundle
- The bundle in which to put the fragment reference.key
- The name of the entry in the bundle.fragment
- The Fragment whose reference is to be stored.public abstract Fragment getFragment(Bundle bundle, java.lang.String key)
putFragment(Bundle, String, Fragment)
.bundle
- The bundle from which to retrieve the fragment reference.key
- The name of the entry in the bundle.public abstract java.util.List<Fragment> getFragments()
public abstract Fragment.SavedState saveFragmentInstanceState(Fragment f)
putFragment(Bundle, String, Fragment)
to
store a fragment reference because that reference may not be valid when
this saved state is later used. Likewise the Fragment's target and
result code are not included in this state.
f
- The Fragment whose state is to be saved.public abstract boolean isDestroyed()
Activity.onDestroy()
call has been made on the FragmentManager's Activity, so this instance is now dead.public abstract void dump(java.lang.String prefix, java.io.FileDescriptor fd, java.io.PrintWriter writer, java.lang.String[] args)
prefix
- Text to print at the front of each line.fd
- The raw file descriptor that the dump is being sent to.writer
- A PrintWriter to which the dump is to be set.args
- Additional arguments to the dump request.public static void enableDebugLogging(boolean enabled)


Research Focus
Humanity finds itself in a period of uncertainty. A long-overdue rise in prosperity in the developing world is being accompanied by serious environmental challenges, as well as economic volatility in the developed world. Meanwhile, the global population continues to grow, with people choosing to settle mainly in cities. If we are to find a path to a future with reduced resource intensity, prosperity and climate-neutrality, we must do so in our urban areas.
Urban Metabolism
Cities are widely recognized as national/global economic engines, being supported through resouces drawn from their hinterlands. Energy, food, construction materials, goods, and water constantly flow into cities, transformed by the processes that provide us with nurishment, comfort, employment, and entertainment. After their use, these resources exit our cities in a multitude of waste streams - exhaust fumes, smokestack plumes, solid waste, sewage, storm water, and low-grade heat. But research shows us that these waste streams hold much value that hasn't fully been exploited; how can we improve the efficiency of these transformative processes, as well as extract the valuable resources from these waste flows to inch closer to sustainable cities?
Cities - The Problem and the Solution
In order for cities to be the future of our economic progress, they need to cease to be the dominant source of our environmental problems. We need to find ways to use energy much more efficiently in our buildings and transportation networks. We need to reduce the seemingly insatiable demand that is placed on our natural support systems. We need to work towards closing the nutrient, hydrological, and material loops, diverting their linear path through our urban systems, where they are presently transformed into "waste". Through the leaps in ingenuity that cities enable, this is all within our grasp. My research investigates problems within this realm. I invite you to examine some of the answers I've found to this point.