Sort directed acyclic graphs
npm install toposort
or component install marcelklehr/toposort
then in your code:
js
toposort = require('toposort')
We want to sort the following graph.
```js // First, we define our edges. var graph = [ [‘put on your shoes’, ‘tie your shoes’] , [‘put on your shirt’, ‘put on your jacket’] , [‘put on your shorts’, ‘put on your jacket’] , [‘put on your shorts’, ‘put on your shoes’] ]
// Now, sort the vertices topologically, to reveal a legal execution order. toposort(graph) // [ ‘put on your shirt’ // , ‘put on your shorts’ // , ‘put on your jacket’ // , ‘put on your shoes’ // , ‘tie your shoes’ ] ```
(Note that there is no defined order for graph parts that are not connected – you could also put on your jacket after having tied your shoes…)
It is usually more convenient to specify dependencies instead of “sequences”. ```js // This time, edges represent dependencies. var graph = [ [‘tie your shoes’, ‘put on your shoes’] , [‘put on your jacket’, ‘put on your shirt’] , [‘put on your shoes’, ‘put on your shorts’] , [‘put on your jacket’, ‘put on your shorts’] ]
toposort(graph) // [ ‘tie your shoes’ // , ‘put on your shoes’ // , ‘put on your jacket’ // , ‘put on your shirt’ // , ‘put on your shorts’ ]
// Now, reversing the list will reveal a legal execution order. toposort(graph).reverse() // [ ‘put on your shorts’ // , ‘put on your shirt’ // , ‘put on your jacket’ // , ‘put on your shoes’ // , ‘tie your shoes’ ] ```
[node1, node2]
(vertices needn’t be strings but can be of any type).Returns: {Array} a list of vertices, sorted from “start” to “end”
nodes
here.This is a convenience method that allows you to define nodes that may or may not be connected to any other nodes. The ordering of unconnected nodes is not defined.
Returns: {Array} a list of vertices, sorted from “start” to “end”
Run the tests with node test.js
.
MIT License


Your organisation type does not match our eligibility criteria for lead applicants.
The eligibility criteria is defined in the competition brief. Please refer back to this to find out if you can join as collaborator via an invite from the lead applicant.
You can return to all competitions or go back to the Innovate UK homepage.


Output on display & menu templates¶
Patterns to make quick input on lcd¶
-
struct menu
Present custom menu data as following structure to use menu_template()
-
uint8_t
num
¶ Amount of options
-
char **
lines
¶ Names of options (up to 16 chars)
-
void (**)(struct sk_lcd *, struct kp_lock *) options
Pointers on fuinctions that realize every options. First option should be GO_BACK
-
uint8_t
-
void
kp_menu_template
(struct sk_lcd *lcd, struct kp_lock *keypad, struct menu *menu)¶ kp_menu_template() - template of menu for keypad. @struct sk_lcd *lcd: LCD for comunication with user. @struct kp_lock *keypad: keypad lock data. @struct menu *menu: the information about menu, you want to create.
Function hadle keypad menu using GLSK UP, DOWN, MENU buttons. To create own menu, firstly initialize struct menu *menu with: lines(options) you need and functions which are realizing this options. To get more info read about struct menu.
Return: void.
-
void
set_1_60
(struct sk_lcd *lcd, uint8_t *num)¶ kp_menu_template() - template of menu for keypad. @struct sk_lcd *lcd: LCD for comunication with user. @uint8_t *num: pointer on variable that need to be set.
Function hadle GLSK buttons UP, DOWN, RIGHT, LEFT, MENU to make user chose the value from 1 to 60. Then this function set chosen value to variable pointed by num.
Return: void.
-
void
kp_scroll_num
(struct sk_lcd *lcd, uint8_t *num, uint8_t *options, uint8_t size)¶ kp_menu_template() - template of menu for keypad. @struct sk_lcd *lcd: LCD for comunication with user. @uint8_t *num: pointer on variable that need to be set. @uint8_t *options: options of *num value. @uint8_t size: amount of options (size of array).
Function hadle GLSK buttons UP, DOWN, MENU to make user chose the value from given options. Then this function set chosen value to variable pointed by num.
Return: void.
-
void
kp_wait_untill_ok
()¶ kp_wait_untill_ok() - wait untill user press MENU (OK) button.
Return: void.
-
void
kp_show_active_line
(struct sk_lcd *lcd, int line1, int line2)¶ kp_show_active_line() - show point befor active line. @struct sk_lcd *lcd: LCD for comunication with user. @bool line1: true if first line is active, false if not. @bool line2: true if second line is active, false if not.
Return: void.
-
void
kp_menu_lines
(struct sk_lcd *lcd, char *line0, char *line1)¶ kp_menu_lines() - print message on screen. @struct sk_lcd *lcd: LCD for comunication with user. @char *line0: first part of mesage(first line) - up to 16 chars. @char *line1: second part of mesage(second line) - up to 16 chars.
Return: void.
Templates to create custom menu¶
-
struct menu
Present custom menu data as following structure to use menu_template()
-
uint8_t
num
Amount of options
-
char **
lines
Names of options (up to 16 chars)
-
void (**)(struct sk_lcd *, struct kp_lock *) options
Pointers on fuinctions that realize every options. First option should be GO_BACK
-
uint8_t
-
void
kp_menu_template
(struct sk_lcd *lcd, struct kp_lock *keypad, struct menu *menu) kp_menu_template() - template of menu for keypad. @struct sk_lcd *lcd: LCD for comunication with user. @struct kp_lock *keypad: keypad lock data. @struct menu *menu: the information about menu, you want to create.
Function hadle keypad menu using GLSK UP, DOWN, MENU buttons. To create own menu, firstly initialize struct menu *menu with: lines(options) you need and functions which are realizing this options. To get more info read about struct menu.
Return: void.
-
void
set_1_60
(struct sk_lcd *lcd, uint8_t *num) kp_menu_template() - template of menu for keypad. @struct sk_lcd *lcd: LCD for comunication with user. @uint8_t *num: pointer on variable that need to be set.
Function hadle GLSK buttons UP, DOWN, RIGHT, LEFT, MENU to make user chose the value from 1 to 60. Then this function set chosen value to variable pointed by num.
Return: void.
-
void
kp_scroll_num
(struct sk_lcd *lcd, uint8_t *num, uint8_t *options, uint8_t size) kp_menu_template() - template of menu for keypad. @struct sk_lcd *lcd: LCD for comunication with user. @uint8_t *num: pointer on variable that need to be set. @uint8_t *options: options of *num value. @uint8_t size: amount of options (size of array).
Function hadle GLSK buttons UP, DOWN, MENU to make user chose the value from given options. Then this function set chosen value to variable pointed by num.
Return: void.
-
void
kp_wait_untill_ok
() kp_wait_untill_ok() - wait untill user press MENU (OK) button.
Return: void.
-
void
kp_show_active_line
(struct sk_lcd *lcd, int line1, int line2) kp_show_active_line() - show point befor active line. @struct sk_lcd *lcd: LCD for comunication with user. @bool line1: true if first line is active, false if not. @bool line2: true if second line is active, false if not.
Return: void.
-
void
kp_menu_lines
(struct sk_lcd *lcd, char *line0, char *line1) kp_menu_lines() - print message on screen. @struct sk_lcd *lcd: LCD for comunication with user. @char *line0: first part of mesage(first line) - up to 16 chars. @char *line1: second part of mesage(second line) - up to 16 chars.
Return: void.


|
CS 391 - Selected Topics: Game Artificial Intelligence
Course Information |
Course Overview
Without assuming a prior introduction to Artificial Intelligence (AI), we will
be covering the dominant lines of research thought behind todays most advanced
game artificial intelligence. In doing so, we will neither be
mathematically rigorous (e.g. glossing over proofs), nor comprehensive (e.g.
covering topics preceding or related to the main lines of thought).
Rather, guided readings are designed to bring the student most rapidly to the
forefront of modern game AI practice as exemplified at the Computer Olympiad and
conferences such as the "International Conference on Computers and Games" or
"Advances in Computer Games". While a broader, more comprehensive
grounding would have greater utility, the goal of this course is to bring an
advanced undergraduate Computer Science major most rapidly to the horizon of
current research, able to comprehend key questions, implement best known
algorithms, raise new questions, and create new outstanding computer players.
Learning Objectives
- To understand some of the dominant concepts in modern game AI, including
but not limited to Monte Carlo sampling, Reinforcement Learning, Monte Carlo tree
search (MCTS), and counterfactual regret minimization (CFR),
- To gain such understanding by reading original research articles,
discussing and presenting summaries of such in class,
- To implement relevant algorithms, gaining a deep, experiential
understanding of the key tradeoffs, and
- To further the broader learning objectives of the Computer Science
major.
Text
There is no text for this selected topics course. Rather, we will be
reading from a selection of freely available research
articles and online texts. It is especially important for students to
keep up with assigned readings, as we will be tracing through lines of thought,
and the structure of the readings will reflect such cumulative dependencies.
Instructor
Todd Neller
Lecture: T,Th 10:00-11:15AM, Glatfelter 112
Office: Glatfelter 209
Office Hours: Tu, Th 1-4PM or by appointment.
Note: Generally, feel free to drop in if my office door
is open (i.e., most of the time beyond class).
Phone: 337-6643
E-mail:
Grading
80% Assignments
10% Quizzes / Exams
5% Colloquium Attendance
5%
Class Attendance / Participation
You are responsible to know the material from each lecture and reading
assignment before the start of the next class. We may have some
unannounced quizzes to maintain accountability.
Homework is due at the beginning of lecture on the due date.
Late homework will not necessarily be accepted. Code must be a legal
program in the relevant language in order to be graded. (It need
not be free from logic errors.) For compiled languages, this means
that the program must compile without error. For interpreted languages,
this means it must be interpretable without error.
You are required to attend 2 colloquia or
approved departmental events over the course of the semester. Class attendance and participation is required. If you attend
all classes and are willing to participate, you'll get 100% for this part
of your grade. Even if you know enough to give a particular lecture,
please consider the value of helping your peers during in-class exercises.
Honor Code
Honesty, Integrity, Honor. These are more important than anything we will teach
in this class. Students can and are encouraged to help each other understand
course concepts, but all graded work must be done independently unless otherwise
specified (e.g. group work). Submitted work should be created by those
submitting it. Submission of plagiarized code or design work is a violation of
the Honor Code, which I strictly enforce. For detailed information about the
Honor Code, see
http://www.gettysburg.edu/about/offices/provost/advising/honor_code/index.dot.
What is permitted:
- Discussing algorithms, syntax, and problem specifications with other
students
- Seeking assistance (as needed) from CS professors, students assistants,
and approved tutors
- Use of "starter code" supplied by your professor, or code you have
previously developed
What is not permitted:
- Sharing code: Verbal dictation of code, transference of code (e.g.
e-mail, file transfer, entry of printed output, etc.). An important
component of this experiential learning process is developing the ability to
independently devise algorithms and express them in program code.
- Viewing and/or using unauthorized code (e.g. solutions found online,
downloads from code repositories, etc.)
- Submitting work that implicitly takes credit for work that should be
credited to others
- Efforts to obscure the source of unauthorized work
- Outsourcing work
Put simply, students may discuss assignments at an abstract level (e.g.
specifications, algorithm pseudocode), but must actually implement solutions
independently or in permitted groups. Credit should be given where credit is
due. Let your conscience be your guide. Do not merely focus on the result; learn
from the process.


ROTATELOGS
Section: rotatelogs (8)Updated: 2008-05-10
Index Return to Main Contents
NAME
rotatelogs - Piped logging program to rotate Apache logsSYNOPSIS
rotatelogs [ -l ] [ -f ] logfile rotationtime|filesizeM [ offset ]
SUMMARY
rotatelogs is a simple program for use in conjunction with Apache's piped logfile feature. It supports rotation based on a time interval or maximum size of the log.
OPTIONS
- -l
- Causes the use of local time rather than GMT as the base for the interval or for strftime(3) formatting with size-based rotation. Note that using -l in an environment which changes the GMT offset (such as for BST or DST) can lead to unpredictable results!
- -f
- Causes the logfile to be opened immediately, as soon as rotatelogs starts, instead of waiting for the first logfile entry to be read (for non-busy sites, there may be a substantial delay between when the server is started and when the first request is handled, meaning that the associated logfile does not "exist" until then, which causes problems from some automated logging tools). Available in version 2.2.9 and later.
- logfile
- The path plus basename of the logfile. If logfile includes any '%' characters, it is treated as a format string for strftime(3). Otherwise, the suffix .nnnnnnnnnn is automatically added and is the time in seconds. Both formats compute the start time from the beginning of the current period. For example, if a rotation time of 86400 is specified, the hour, minute, and second fields created from the strftime(3) format will all be zero, referring to the beginning of the current 24-hour period (midnight).
- rotationtime
- The time between log file rotations in seconds. The rotation occurs at the beginning of this interval. For example, if the rotation time is 3600, the log file will be rotated at the beginning of every hour; if the rotation time is 86400, the log file will be rotated every night at midnight. (If no data is logged during an interval, no file will be created.)
- filesizeM
- The maximum file size in megabytes followed by the letter M to specify size rather than time.
- offset
-
The number of minutes offset from UTC. If omitted, zero is assumed and UTC is used. For example, to use local time in the zone UTC -5 hours, specify a value of -300 for this argument. In most cases, -l should be used instead of specifying an offset.
EXAMPLES
CustomLog "|bin/rotatelogs /var/logs/logfile 86400" common
This creates the files /var/logs/logfile.nnnn where nnnn is the system time at which the log nominally starts (this time will always be a multiple of the rotation time, so you can synchronize cron scripts with it). At the end of each rotation time (here after 24 hours) a new log is started.
CustomLog "|bin/rotatelogs -l /var/logs/logfile.%Y.%m.%d 86400" common
This creates the files /var/logs/logfile.yyyy.mm.dd where yyyy is the year, mm is the month, and dd is the day of the month. Logging will switch to a new file every day at midnight, local time.
CustomLog "|bin/rotatelogs /var/logs/logfile 5M" common
This configuration will rotate the logfile whenever it reaches a size of 5 megabytes.
ErrorLog "|bin/rotatelogs /var/logs/errorlog.%Y-%m-%d-%H_%M_%S 5M"
This configuration will rotate the error logfile whenever it reaches a size of 5 megabytes, and the suffix to the logfile name will be created of the form errorlog.YYYY-mm-dd-HH_MM_SS.
PORTABILITY
The following logfile format string substitutions should be supported by all strftime(3) implementations, see the strftime(3) man page for library-specific extensions.
- * %A - full weekday name (localized)
-
- * %a - 3-character weekday name (localized)
-
- * %B - full month name (localized)
-
- * %b - 3-character month name (localized)
-
- * %c - date and time (localized)
-
- * %d - 2-digit day of month
-
- * %H - 2-digit hour (24 hour clock)
-
- * %I - 2-digit hour (12 hour clock)
-
- * %j - 3-digit day of year
-
- * %M - 2-digit minute
-
- * %m - 2-digit month
-
- * %p - am/pm of 12 hour clock (localized)
-
- * %S - 2-digit second
-
- * %U - 2-digit week of year (Sunday first day of week)
-
- * %W - 2-digit week of year (Monday first day of week)
-
- * %w - 1-digit weekday (Sunday first day of week)
-
- * %X - time (localized)
-
- * %x - date (localized)
-
- * %Y - 4-digit year
-
- * %y - 2-digit year
-
- * %Z - time zone name
-
- * %% - literal `%'
-
Index
This document was created by man2html, using the manual pages.
Time: 05:34:29 GMT, December 24, 2015


Others wanted to burn trash. Organic waste matter is actually a good source of fuel. While most of it should be returned to the soil, a significant by-product of decomposition is methane gas. Methane can be burned to heat water into steam, turning turbines, etcetera, etcetera. Or, in a less soil-friendly way, one can just burn biomass directly as a source of fuel for steam-turbines.
The major issue here was not whether incinerators were technical feasible or economical, but were they socially desirable and sustainable? A methane extraction, or plain biomass-burning, power plant is a big capital investment. It's noisy, it's ugly, and it can be smelly. Great care has to be taken to separate out things that can be burned from things that shouldn't be, for environmental and economic reasons. Even if small, affordable "neighborhood" burners are built and installed and operated, the fact remains that burning biomass removes it from the ecosystem and converts it into atmosphere, where it may be some time before it reconverts back into organisms again.
That vote was a very close one, helped, I think, by the fact that in the vCity, there aren't any bad odors. MSE equipment hasn't progressed to the point that people can start releasing odors upon each other. Personally, I don't mind if that's an innovation that never occurs.


post(path: string, body: any, options?: RequestOptions): Observable< T | any >
The method of the generated data-service calls directly genese-angular post() method which is sending an object to backend. If the backend returns an object (which is usually a bad practice), it will be mapped with the type T (in this example, T = BookPostResponse)
Open your navigator console, click on "Add book" button and send the form in the modal. In the tab "Network", you'll find the data received from the post() request. In the tab "Console", you'll can compare these original data with the formatted object sent as Observable by genese-angular. As you can see, genese-angular formatted the returned object with "BookPostResponse" type.


- Mining: {{ partial "stat.html" (dict "feature" .Params.dist_mining) }}
- Pre-release sale (ICO): {{ partial "stat.html" (dict "feature" .Params.dist_ico) }}
- Free Distribution Event (Airdrop): {{ partial "stat.html" (dict "feature" .Params.dist_airdrop) }}
- Expected End of distribution: {{ partial "stat.html" (dict "feature" .Params.dist_end) }}


This challenge allows you to practice the concepts and techniques learned over the past Sprint and apply them in a concrete project. This Sprint explored the context API, the reducer pattern, and Redux. In your challenge for this Sprint, you will demonstrate proficiency by creating an application that uses ReactJS to consume live data retrieved from the World Wide Web.
** Read these instructions carefully. Understand exactly what is expected before starting this Sprint Challenge.**
This is an individual assessment. All work must be your own. Your challenge score is a measure of your ability to work independently using the material covered through this sprint. You need to demonstrate proficiency in the concepts and objectives introduced and practiced in preceding days.
You are not allowed to collaborate during the Sprint Challenge. However, you are encouraged to follow the twenty-minute rule and seek support from your PM and Instructor in your cohort help channel on Slack. Your work reflects your proficiency throughout State Management and your command of the concepts and techniques in the the context API, the reducer pattern, and Redux.
You have three hours to complete this challenge. Plan your time accordingly.
Commit your code regularly and meaningfully. This helps both you (in case you ever need to return to old code for any number of reasons and your project manager).
In this challenge, you are to build the Smurfs village once again, only this time, you will utilize context or Redux as your state management. Don’t use any old code from your previous Smurfs Sprint Challenge. Build this challenge from the ground up using what you have learned about state management.
Demonstrate your understanding of this Sprint’s concepts by answering the following free-form questions. Edit this document to include your answers after each question. Make sure to leave a blank line above and below your answer so it is clear and easy to read by your project manager.
actions
, reducers
and the store
and their role in Redux. What does each piece do? Why is the store known as a ‘single source of truth’ in a redux application?
redux-thunk
, what does it allow us to do? How does it change our action-creators
?
Follow these steps to set up your project:
fork & clone
this repository.
cd
into the forked copy of this repository.
yarn
to retrieve all server-side
the dependencies.
yarn start
or npm start
to get your API up and running on http://localhost:3333
. This is the URL you’re going to need to use within your React app in order to make AJAX requests for data.
http://localhost:3333/smurfs
. You should see an empty Array []
returned to you. This is an array that your API will be using to store our Smurf Data.
smurfs
directory and notice it’s just a plain ol’ React App that we’ve built using create-react-app
.
src/index.js
to make sure that your app is ready to roll with the proper middleware.
smurfs
and run yarn
to retrieve the client side dependencies.
yarn start
to fire up your React application.
LOOK at all the files you’ve been given for this project. One important file to note is server.js
. This file contains an API that you are going to be interfacing with. Below is documentation on how to interact with the API.
GET
to the endpoint /smurfs
.
name
, age
, and height
.
Example of the shape of data to be sent to the POST
endpoint:
Initially Brainey will be in the array, but it takes more than one smurf to make the village. Be sure to add a few smurfs to populate our smurf village.
HINT if you are going to be working on Stretch Problem, you’ll need to use that unique id
.
Example of object created in Smurf DB:
[
{
name: "Brainey",
age: 200,
height: "5cm",
id: 0
},
{
name: "Sleepy",
age: 200,
height: "5cm",
id: 1
}
];
The following two endpoints are here for you if you’d like to push yourselves a little further.
id
added to the URL, and at least one field to update on the Smurf object. name
age
height
.
Example:
input:
{
id: 1,
name: 'Grumpy'
}
output:
[
{
name: 'Grumpy',
age: 30,
height: '3cm',
id: 1
},
{
name: 'Sleepy',
age: 211,
height: '2cm',
id: 0
}
]
For this endpoint to work, all you need is an id sent up as part of the request url.
If your delete worked, you’ll get a an array back with all of the smurfs but with your requested smurf removed.
/smurfs/123
then you’ll remove the smurf by that id.
Example:


%include templates/parts/head.html
%include templates/parts/navBar.html
Assignment 1: Fauxtoshop
Due: Friday, Oct 7th, 12P.M.
Resources
Handout
Starter Code
Sample Output
Example of a series of interactions with user:
transcript.txt
Choose color-wheel.gif, scatter, 10:
Output
(random; will not match exactly)
Choose stanford-oval.jpg, edge detection, threshold 30:
Output
Choose kitten.jpg, green screen, cat-green.jpg, threshold 60, (100,25):
Output
Gaussian Blur extra credit option: Choose pusheen.jpg, Gaussian Blur, radius 6:
Output
Tips
Check out the
style guide
for explicit details on style.
Submit using
paperless.stanford.edu
. You may submit as many times as you like, we will grade that most recent submission. We suggest you submit early to practice with the submission process.
YEAH Assignment introduction video:
%include templates/parts/footer.html


I had a nice long 4'th of July weekend. Lots of pics here. I'm saddened to hear about the attacks on London today. My best to the people of that nation.
--- layout: post title: 4'th of July Weekend 2005 categories: [] tags: [] status: publish type: post published: true meta: _original_post_id: '' _original_import_author: John Duprey author: ---
I had a nice long 4'th of July weekend. Lots of pics here. I'm saddened to hear about the attacks on London today. My best to the people of that nation.


☰
Home
Map
About
Dinner and a Movie
Locate a movie theater and find nearby restaurants.
Click to view map and enter address
© Dinner and a Movie 2017


Wolverine Screening is a company based on reliability, trust, punctuality, and integrity. We always stay in contact with the customer and keep them updated every step of the way. All work done is to the customers satisfaction and very affordable. Call anytime for a free quote!!<PHONE_NUMBER>
CEO & Founder
Any time is a great time to start a company. My mission is to do a great job at a better price. Come to me with your screening needs, you will not be disappointed!
239-990-1650
WolverineScreening@gmail.com


My name is Robert Taylor-Anderson. I am the fourth of 5 children and the eldest boy. I am from the southside of Chicago specifically Roseland neighborhood. I went to a magnet school called Burnside Academy on the Chatham neighborhood, and Keneood Academy for highschool located in Hyde Park. Graduating in 2011 I ventured to the University of Illinois in Urbana Champaign. I joined the work froce for a few years from 2012 untill 2015. My life turned around and I moved to Chicago where I currently reside. During this time I had my "Year Up Moment". My house burned down and during this time I decided to join the year up program. It was either all or nothing and I went all in. Being in the year up program has groomed me and shaped me into a professional individual. This stepping stone will open the door to my goals in becoming an entreprenuer, business owner and property owner.


The worldwide web is a collection of HTML docs. The links between these pages is what makes the web web-like.
Major pieces of the web:HTML markup consists of opening tags, closing tags, and contents. All of that combines into an "element." Here is a link to a video that discusses this in more detail.
Elements can either be in-line or block. Block elements create an "invisible box" around the content that sits inside of them.
5 most important take-aways from this lesson1. What a web page is: A web page is a text document written in a language called HTML. Web browsers read these documents and then interpret and display them.
2. How coding works: Coding happens when programmers write text in a language that a computer can understand. The computer can then follow the instructions the programmer wrote.
3. Programmers need to write exactly the way a computer understands (also known as writing with correct “syntax”).
4.
5. Basic HTML vocabulary: A tag is always contained within angled brackets. Most tags have an opening tag and a closing tag. Some tags (called “void” tags) do not require a closing tag. An HTML element refers to everything within a set of opening and closing tags. Lastly, an attribute is a property of an HTML element.


Home
About ATL
Downloads
Gallery
Blog
Contact
Sign In/Sign Up
Dashboard
Logout
Login
Email
Password
Login
Don't have an account


AeroelasticSE¶
This python code forms a wrapper for the NWTC codes FAST and TurbSim.
Authors: P. Graf, K. Dykes and many others
The core code involved is the NWTC code FAST. The AeroelasticSE modules provide access to it in various ways, as detailed below:
- (
AeroelasticSE.runFAST
)–run FAST by parsing and modifying template file inputs. - (
AeroelasticSE.runTurbSim
)–run TurbSim by parsing and modifying template file inputs. - (
AeroelasticSE.FAST_component
)–run FAST as an openMDAO component. - (
AeroelasticSE.FusedFAST
)–run FAST via generic run cases using the fusedwind framework. - (
AeroelasticSE.FSTTemplate_runner
)–run FAST via the fused wind framework’s VariableTree based interface. - (
AeroelasticSE.iecApp
)–run and process large numbers of cases using the fusedwind framework and the template based interface
In addition, there are a couple of helper modules:
- FusedFASTrunCase.py
- PeregrineClusterAllocator.py
The tutorial section is a good place to start learning about how to use these FAST wrappers. These consist primarily of annotated sections from the test code that is part of the modules themselves.
Table of Contents


IP addresses, packets and routers are all needed to send messages between devices
An Internet Protocol (IP) address is a numerical label given to each device that uses Internet Protocol to communicate. The Internet currently uses a version of Internet Protocol called IPv4. IPv4 addresses are made up of 32 bits, allowing for 4.29 billion unique addresses. Although 4.29 billion seems like a lot, we are actually nearing this limit. A new version of the Internet Protocol is being developed, called IPv6, which will utilize 128-bit addresses, allowing for 340 undecillion unique addresses. It will be a few years before IPv6 will be ready for use.
When data is sent from one device to another, it is transmitted as a packet. A packet is a segment of data that is sent from one place to another. A packet includes the source, destination, data contents, size and other information that helps the packet arrive at its destination. When you send a large message, your message can be divided into multiple packets, which are then reassembled into one message once they reach the destination.
Before packets arrive at their destination, they need to pass through many routers, which are computers that act like traffic managers to keep the packets moving smoothly. Given how expansive the Internet network is, there are multiple paths a packet can take to get to its destination. Routers decide which path is most suitable for the packet and send it to the next router until the packet arrives at its destination. Having multiple path options means that the Internet is fault tolerant, so if one area of the network is not working, there are still other paths available to the packets. Fault tolerance makes the Internet reliable. Since more routers provide more path options, the more routers added to a network, the more reliable it becomes.


Profile
Logged in as {{ @username }}
Change Password
Current Password:
New Password:
Confirm New Password:
Change Password
Password Changed
{{@error}}


Your phone buzzes. It could be anything: your family Whatsapp group, your phone company spam, but it's a compelling request:
Your phone buzzes. It could be anything: your family Whatsapp group, your phone company spam, but it's a compelling request:
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
Send nudes!
We would dare to say the vast majority of us yearns to send and receive nudes.
Plus, we have the honor of publishing a piece by Fannie Sosa sharing her view on why selfies, nudes and other forms of self-representation can be political gestures.


My name is Theodore Baca. I was born in Victorville, CA back in 1995. I always found this city, and the surrounding ones for that matter, to be extremely boring and unfulfilling. While in Middle School, I frequently found myself bored. Sure, I had my friends and my school work, but when I wasn't hanging out or studying, I had nothing to do. It wasn't till I was hanging out with a group of friends who played guitar that I had realized my calling. That day, when we ran out of things to do, the three of them picked up instruments and just started jamming together. I sat on the couch in awe as I watched them strum on the guitars. I instantly knew what I wanted to do. What my next hobby would be.
I started actually playing the guitar at age 15. I started on a cheap $50 acoustic and quickly outgrew it. However, I had a poor family and they were not able to afford anything better at the time. Luckily, for Christmas, my Grandfather but me a much nicer acoustic for me to continue my playing. I was hooked. I wanted more and more guitars. I ended up doing what ever work I could in order to aquire them. As time went on, I got more and more guitars. I earned more money and started a collection. This collection is shown in the Collection page linked at the top!


AWS
OME
DAY
2018
Quiz#1
How many regions are in the AWS global infrastructure?
14
16
18
20
Name
Last four digits of cell phone number
Submit
Powered by Amazon
S3
,
Cognito
and
DynamoDB


Resize the screen to view the left slide menu
Angular is a framework for building client applications in HTML and either JavaScript or a language (like Dart or TypeScript) that compiles to JavaScript.
The framework consists of several libraries, some of them core and some optional. You write Angular applications by composing HTML templates with Angularized markup, writing component classes to manage those templates, adding application logic in services, and boxing components and services in modules.
Then you launch the app by bootstrapping the root module. Angular takes over, presenting your application content in a browser and responding to user interactions according to the instructions you've provided. Of course, there is more to it than this. You'll learn the details in the pages that follow. For now, focus on the big picture.


LayoutDirection
public enum LayoutDirection : Hashable
Describes the given direction / axis that a layout uses when flowing its content.
Traditional table views / lists you see use a .vertical
layout direction, however,
you may want to use .horizontal
for embedded lists that scroll
horizontally in a larger vertical list, similar to what you would see in the iOS App Store,
or for a list that users can scroll left to right.
.vertical:
┌─────────┐
│┌───────┐│
││ ││
│└───────┘│
│┌───────┐│
││ ││
│└───────┘│
│┌───────┐│
││ ││
│└───────┘│
└─────────┘
.horizontal:
┌────────────────────┐
│┌────┐ ┌────┐ ┌────┐│
││ │ │ │ │ ││
││ │ │ │ │ ││
│└────┘ └────┘ └────┘│
└────────────────────┘
When writing custom list layouts, LayoutDirection
provides many helper methods
to convert the coordinates of CGSize
, CGPoint
, CGRect
, etc, to horizontal or vertical
layout directions. See the extensions in this file for more details.
-
A list layout which lays out top to bottom.
┌─────────┐ │┌───────┐│ ││ ││ │└───────┘│ │┌───────┐│ ││ ││ │└───────┘│ │┌───────┐│ ││ ││ │└───────┘│ └─────────┘
Declaration
Swift
case vertical
-
A list layout which lays out left to right (or leading to trailing, depending on implementation).
┌────────────────────┐ │┌────┐ ┌────┐ ┌────┐│ ││ │ │ │ │ ││ ││ │ │ │ │ ││ │└────┘ └────┘ └────┘│ └────────────────────┘
Declaration
Swift
case horizontal
-
When writing a layout, use this method to return differing values based on the direction. The passed closures will only be evaluated if they are for the current direction.
Declaration
Swift
public func `switch`<Value>(vertical: () -> Value, horizontal: () -> Value) -> Value
-
When writing a layout, use this method to return differing values based on the direction. The passed autoclosures will only be evaluated if they are for the current direction.
Declaration
Swift
public func `switch`<Value>(vertical: @autoclosure () -> Value, horizontal: @autoclosure () -> Value) -> Value
-
.vertical
: Returns the height of the provided size..horizontal
: Returns the width of the provided size.Declaration
Swift
public func height(for size: CGSize) -> CGFloat
-
.vertical
: Returns the width of the provided size..horizontal
: Returns the height of the provided size.Declaration
Swift
public func width(for size: CGSize) -> CGFloat
-
.vertical
: Returns aCGPoint
made with(x, y)
..horizontal
: Returns aCGPoint
made with(y, x)
.Declaration
Swift
public func point(x: CGFloat, y: CGFloat) -> CGPoint
-
.vertical
: Returns the provided size..horizontal
: Returns a size created by swapping the width and height.Declaration
Swift
public func size(for size: CGSize) -> CGSize
-
.vertical
: Returns aCGSize
made with(width, height)
..horizontal
: Returns aCGSize
made with(height, width)
.Declaration
Swift
public func size(width: CGFloat, height: CGFloat) -> CGSize
-
.vertical
: Returns the maxY of the frame..horizontal
: Returns the maxX of the frame.Declaration
Swift
public func maxY(for frame: CGRect) -> CGFloat
-
.vertical
: Returns the maxX of the frame..horizontal
: Returns the maxY of the frame.Declaration
Swift
public func maxX(for frame: CGRect) -> CGFloat
-
.vertical
: Returns the x of the point..horizontal
: Returns the y of the point.Declaration
Swift
public func x(for point: CGPoint) -> CGFloat
-
.vertical
: Returns the y of the point..horizontal
: Returns the x of the point.Declaration
Swift
public func y(for point: CGPoint) -> CGFloat
-
.vertical
: Returns the top of the insets..horizontal
: Returns the left of the insets.Declaration
Swift
public func top(with insets: UIEdgeInsets) -> CGFloat
-
.vertical
: Returns the bottom of the insets..horizontal
: Returns the right of the insets.Declaration
Swift
public func bottom(with insets: UIEdgeInsets) -> CGFloat


Class ScriptState
Status of scripts within Sensus
Inheritance
Namespace: Sensus.Probes.User.Scripts
Assembly: Sensus.Shared.NuGet.dll
Syntax
public sealed class ScriptState : Enum
Fields
AgentAccepted
The IScriptProbeAgent accepted the IScript for delivery, making it available to the user.
Declaration
public const ScriptState AgentAccepted
Field Value
| Type | Description |
|---|---|
| ScriptState |
AgentDeclined
The IScriptProbeAgent declined the IScript for delivery, causing it to be ignored forever.
Declaration
public const ScriptState AgentDeclined
Field Value
| Type | Description |
|---|---|
| ScriptState |
AgentDeferred
The IScriptProbeAgent deferred delivery of the IScript to a later time.
Declaration
public const ScriptState AgentDeferred
Field Value
| Type | Description |
|---|---|
| ScriptState |
Cancelled
The script was Opened by the user, but the user subsequently cancelled its completion.
Declaration
public const ScriptState Cancelled
Field Value
| Type | Description |
|---|---|
| ScriptState |
Deleted
The script was deleted by the user after it was Delivered.
Declaration
public const ScriptState Deleted
Field Value
| Type | Description |
|---|---|
| ScriptState |
Delivered
The script was delivered to the user and made available for taking. On Android this will be exactly the scheduled/triggered time. On iOS, this will be exactly the triggered time, but when it comes to scheduled scripts the timing depends on whether push notifications are enabled. Without push notifications the delivery time will be when the user brings the app to the foreground. With push notifications enabled, the delivery time will correspond to the arrival of the push notification, which causes the script to run.
Declaration
public const ScriptState Delivered
Field Value
| Type | Description |
|---|---|
| ScriptState |
Expired
The script expired after it was Delivered.
Declaration
public const ScriptState Expired
Field Value
| Type | Description |
|---|---|
| ScriptState |
Opened
The script was opened by the user after it was Delivered.
Declaration
public const ScriptState Opened
Field Value
| Type | Description |
|---|---|
| ScriptState |
Submitted
The script was submitted by the user after it was Opened, though the user might not necessarily have completed all fields.
Declaration
public const ScriptState Submitted
Field Value
| Type | Description |
|---|---|
| ScriptState |
value__
Declaration
public int value__
Field Value
| Type | Description |
|---|---|
| System.Int32 |


The process section is printed after the thread section. It contains information about the whole process, including thread list and memory usage of the process.
The thread list includes the threads that the VM is aware of, as shown in Example A-12. This includes all Java threads and some VM internal threads, but does not include any native threads created by the user application that have not attached to the VM a shown in Example A-13.
Example A-12 First Line from Thread List Format
=>0x0805ac88 JavaThread "main" [_thread_in_native, id=21139] | | | | | +----- ID | | | | +------------------- state | | | | (JavaThread only) | | | +--------------------------------- name | | +------------------------------------------ type | +---------------------------------------------------- pointer +------------------------------------------------------ "=>" current thread
Example A-13 VM Internal Threads in the Error Log
Java Threads: ( => current thread ) 0x080c8da0 JavaThread "Low Memory Detector" daemon [_thread_blocked, id=21147] 0x080c7988 JavaThread "CompilerThread0" daemon [_thread_blocked, id=21146] 0x080c6a48 JavaThread "Signal Dispatcher" daemon [_thread_blocked, id=21145] 0x080bb5f8 JavaThread "Finalizer" daemon [_thread_blocked, id=21144] 0x080ba940 JavaThread "Reference Handler" daemon [_thread_blocked, id=21143] =>0x0805ac88 JavaThread "main" [_thread_in_native, id=21139] Other Threads: 0x080b6070 VMThread [id=21142] 0x080ca088 WatcherThread [id=21148]
The thread type and thread state are described in Thread Section Format.
The next information is the VM state, which indicates the overall state of the virtual machine. Table A-3 describes the general states.
Table A-3 VM States
| General VM State | Description |
|---|---|
|
|
Normal execution. |
|
|
All threads are blocked in the VM waiting for a special VM operation to complete. |
|
|
A special VM operation is required and the VM is waiting for all threads in the VM to block. |
The VM state output is a single line in the error log, as follows:
VM state:not at safepoint (normal execution)
The next information in the error log is a list of mutexes and monitors that are currently owned by a thread, as shown in Example A-14. These mutexes are VM internal locks rather than monitors associated with Java objects. Below is an example to show how the output might look when a crash happens when VM locks are held. For each lock the log contains the name of the lock, its owner, and the addresses of a VM internal mutex structure and its OS lock. In general this information is useful only to those who are very familiar with the HotSpot VM. The owner thread can be cross-referenced to the thread list.
The next information is a summary of the heap, as shown in Example A-15. The output depends on the garbage collection (GC) configuration. In this example the serial collector is used, class data sharing is disabled, and the tenured generation is empty. This probably indicates that the fatal error occurred early or during start-up and a GC has not yet promoted any objects into the tenured generation.
Example A-15 Heap Summary in the Error Log
Heap def new generation total 576K, used 161K [0x46570000, 0x46610000, 0x46a50000) eden space 512K, 31% used [0x46570000, 0x46598768, 0x465f0000) from space 64K, 0% used [0x465f0000, 0x465f0000, 0x46600000) to space 64K, 0% used [0x46600000, 0x46600000, 0x46610000) tenured generation total 1408K, used 0K [0x46a50000, 0x46bb0000, 0x4a570000) the space 1408K, 0% used [0x46a50000, 0x46a50000, 0x46a50200, 0x46bb0000) compacting perm gen total 8192K, used 1319K [0x4a570000, 0x4ad70000, 0x4e570000) the space 8192K, 16% used [0x4a570000, 0x4a6b9d48, 0x4a6b9e00, 0x4ad70000) No shared spaces configured.
The next information in the log is a list of virtual memory regions at the time of the crash. This list can be long in the case of large applications. The memory map can be very useful when debugging some crashes, as it can tell you what libraries are actually being used, their location in memory, as well as the location of heap, stack, and guard pages.
The format of the memory map is operating-system-specific. On the Oracle Solaris operating system, the base address and library name are printed. On the Linux system the process memory map (/proc/pid/maps) is printed. On the Windows system, the base and end addresses of each library are printed. Example A-16 shows the output generated on Linux/x86. Note: Most of the lines have been omitted from the example for the sake of brevity.
Example A-16 List of Virtual Memory Regions in the Error Log
Dynamic libraries: 08048000-08056000 r-xp 00000000 03:05 259171 /h/jdk6/bin/java 08056000-08058000 rw-p 0000d000 03:05 259171 /h/jdk6/bin/java 08058000-0818e000 rwxp 00000000 00:00 0 40000000-40013000 r-xp 00000000 03:0a 400046 /lib/ld-2.2.5.so 40013000-40014000 rw-p 00013000 03:0a 400046 /lib/ld-2.2.5.so 40014000-40015000 r--p 00000000 00:00 0 Lines omitted. 4123d000-4125a000 rwxp 00001000 00:00 0 4125a000-4125f000 rwxp 00000000 00:00 0 4125f000-4127b000 rwxp 00023000 00:00 0 4127b000-4127e000 ---p 00003000 00:00 0 4127e000-412fb000 rwxp 00006000 00:00 0 412fb000-412fe000 ---p 00083000 00:00 0 412fe000-4137b000 rwxp 00086000 00:00 0 Lines omitted. 44600000-46570000 rwxp 00090000 00:00 0 46570000-46610000 rwxp 00000000 00:00 0 46610000-46a50000 rwxp 020a0000 00:00 0 46a50000-46bb0000 rwxp 00000000 00:00 0 46bb0000-4a570000 rwxp 02640000 00:00 0 Lines omitted.
Example A-17 Format of Memory Map in the Error Log
40049000-4035c000 r-xp 00000000 03:05 824473 /jdk1.5/jre/lib/i386/client/libjvm.so |<------------->| ^ ^ ^ ^ |<--------------------------------->| Memory region | | | | | | | | | | Permission --- + | | | | r: read | | | | w: write | | | | x: execute | | | | p: private | | | | s: share | | | | | | | | File offset ----------+ | | | | | | Major ID and minor ID of -------+ | | the device where the file | | is located (i.e. /dev/hda5) | | | | inode number ------------------------+ | | File name --------------------------------------------------+
Example A-17 shows the memory map output, each library has two virtual memory regions: one for code and one for data. The permission for the code segment is marked with r-xp
(readable, executable, private), and the permission for the data segment is rw-p
(readable, writable, private).
The Java heap is already included in the heap summary earlier in the output, but it can be useful to verify that the actual memory regions reserved for heap match the values in the heap summary and that the attributes are set to rwxp
.
Thread stacks usually show up in the memory map as two back-to-back regions, one with permission ---p
(guard page) and one with permission rwxp
(actual stack space). In addition, it is useful to know the guard page size or stack size. For example, in this memory map, the stack is located from 4127b000 to 412fb000.
On a Windows system, the memory map output is the load and end address of each loaded module, as shown in Example A-18.
Example A-18 Memory Map on Windows
Dynamic libraries: 0x00400000 - 0x0040c000 c:\jdk6\bin\java.exe 0x77f50000 - 0x77ff7000 C:\WINDOWS\System32\ntdll.dll 0x77e60000 - 0x77f46000 C:\WINDOWS\system32\kernel32.dll 0x77dd0000 - 0x77e5d000 C:\WINDOWS\system32\ADVAPI32.dll 0x78000000 - 0x78087000 C:\WINDOWS\system32\RPCRT4.dll 0x77c10000 - 0x77c63000 C:\WINDOWS\system32\MSVCRT.dll 0x08000000 - 0x08183000 c:\jdk6\jre\bin\client\jvm.dll 0x77d40000 - 0x77dcc000 C:\WINDOWS\system32\USER32.dll 0x7e090000 - 0x7e0d1000 C:\WINDOWS\system32\GDI32.dll 0x76b40000 - 0x76b6c000 C:\WINDOWS\System32\WINMM.dll 0x6d2f0000 - 0x6d2f8000 c:\jdk6\jre\bin\hpi.dll 0x76bf0000 - 0x76bfb000 C:\WINDOWS\System32\PSAPI.DLL 0x6d680000 - 0x6d68c000 c:\jdk6\jre\bin\verify.dll 0x6d370000 - 0x6d38d000 c:\jdk6\jre\bin\java.dll 0x6d6a0000 - 0x6d6af000 c:\jdk6\jre\bin\zip.dll 0x10000000 - 0x10032000 C:\bugs\crash2\App.dll
The next information in the error log is a list of VM arguments, followed by a list of environment variables, as shown in Example A-19.
Example A-19 List of VM Arguments and Environment Variables
VM Arguments: java_command: NativeSEGV 2 Environment Variables: JAVA_HOME=/h/jdk PATH=/h/jdk/bin:.:/h/bin:/usr/bin:/usr/X11R6/bin:/usr/local/bin: /usr/dist/local/exe:/usr/dist/exe:/bin:/usr/sbin:/usr/ccs/bin: /usr/ucb:/usr/bsd:/usr/etc:/etc:/usr/dt/bin:/usr/openwin/bin: /usr/sbin:/sbin:/h:/net/prt-web/prt/bin USERNAME=user LD_LIBRARY_PATH=/h/jdk6/jre/lib/i386/client:/h/jdk6/jre/lib/i386: /h/jdk6/jre/../lib/i386:/h/bugs/NativeSEGV SHELL=/bin/tcsh DISPLAY=:0.0 HOSTTYPE=i386-linux OSTYPE=linux ARCH=Linux MACHTYPE=i386
|
Note: The list of environment variables is not the full list but rather a subset of the environment variables that are applicable to the Java VM. |
On Oracle Solaris and Linux operating systems, the next information in the error log is the list of signal handlers, as shown in Example A-20.
Example A-20 List of Signal Handlers in the Error Log
Signal Handlers: SIGSEGV: [libjvm.so+0x3aea90], sa_mask[0]=0xfffbfeff, sa_flags=0x10000004 SIGBUS: [libjvm.so+0x3aea90], sa_mask[0]=0xfffbfeff, sa_flags=0x10000004 SIGFPE: [libjvm.so+0x304e70], sa_mask[0]=0xfffbfeff, sa_flags=0x10000004 SIGPIPE: [libjvm.so+0x304e70], sa_mask[0]=0xfffbfeff, sa_flags=0x10000004 SIGILL: [libjvm.so+0x304e70], sa_mask[0]=0xfffbfeff, sa_flags=0x10000004 SIGUSR1: SIG_DFL, sa_mask[0]=0x00000000, sa_flags=0x00000000 SIGUSR2: [libjvm.so+0x306e80], sa_mask[0]=0x80000000, sa_flags=0x10000004 SIGHUP: [libjvm.so+0x3068a0], sa_mask[0]=0xfffbfeff, sa_flags=0x10000004 SIGINT: [libjvm.so+0x3068a0], sa_mask[0]=0xfffbfeff, sa_flags=0x10000004 SIGQUIT: [libjvm.so+0x3068a0], sa_mask[0]=0xfffbfeff, sa_flags=0x10000004 SIGTERM: [libjvm.so+0x3068a0], sa_mask[0]=0xfffbfeff, sa_flags=0x10000004 SIGUSR2: [libjvm.so+0x306e80], sa_mask[0]=0x80000000, sa_flags=0x10000004


WITNESS LIST Appropriations Committee August 20, 1998-9:30A Children's Health Insurance On: Archer, William (TDH) Berendt, Trey (LBB) Furgeson, Kelly (LBB) Gilbert, Don (HHSC) Priest, Paul (LBB) Schwartz, Stephen (Dental Association)


NEXT Black Kpop Idol: EXO LAY Dancer, SUPERM Choreographer, & Stage K Luciano Interview 1 or 2
by allysseTVYou may have seen him on Stage K! Learn about SUPERM's choreographer, Luciano. He's rubbing shoulders with SM Entertainment, and has toured and danced with EXO's Lay this year in China. On JTBC's Stage-K, he danced in front of kpop idols like: Sandara and members of EXO! He's the next Black Kpop Idol and choreographer! I was so excited to do this interview with Luciano! He's going to be the next BIG thing in Kpop!! You heard it here first!! This is part 1 of 2 series. I hope this series will encourage more of you to follow your dreams!! Fighting!!


Register Account
Name
Initial Deposit
Register
Current Balance
Ksh:
Withdraw/Deposit
Deposit
Deposit
Withdraw
Withdraw


David Russell
I am a first year Masters in Robotics student at CMU working with Prof. David Wettergreen. I am interested in field robotics, remote sensing, and putting tools in the hands of domain experts. My current work is on using UAVs for forest managment. Previously, I was an R&D engineer on the computer vision team at Kitware, where I worked on a variety of project which levereaged both 3D- and learning-based vision for remote sensing applications. I graduated from Clarkson University in 2020 with a degree in computer science. During my undergrad I interned twice at the CMU Robotics Institute, Kitware and Phantom AI.
A few things I'm excited about are: coupling observations across multiple scales (i.e. satellite, UAV, and proximal), active learning that gets deep learning in the hands of domain experts, and the interection of 3D and learning-based vision. I'm broadly excited about CV/ML/computing for environmentalism and sustainability. I believe that open-source tools are a key component of this ecosystem and I would like to develop useful tools in this space.
Outside my professional life, I enjoy cooking, biking, and rock climbing.


Communications and Meetings
- Active participation on discussions of project matter on the platform of Messenger for this group
- All issues related to the course or project raised in group meetings and on messaging channels, must be addressed no later than 24 hours after from the time that the issue was brought up
- Meeting times will be held during Wednesday 4 - 6 PM on a weekly basis to discuss relevant matters on the project. All members must show up to the meetings, given that there are no other pressing situations are risen
- Meetings will be held using the Messenger calling functionality where individuals can share work and speak about their accomplishments each week
- Preparation of the meeting must be done according to what was discussing during the meeting of the previous week, with the exception of meeting number 1


Simple Craps Players¶
This chapter defines a variety of player strategies. Most of this is based on strategies already defined in Roulette, making the explanations considerably simpler. Rather than cover each individual design in separate chapters, we’ll rely on the experience gained so far, and cover four variant Craps players in this chapter. We’ll mention a fifth, but leave that as a more advanced exercise.
In Simple Craps Players Analysis we’ll expand on existing definition of craps players. We’ll add a number of betting strategies. In Craps 1-3-2-6 Player, Craps Cancellation Player, and Craps Fibonacci Player we’ll look at different betting strategies and how those can be implemented for a craps player.
In CrapsPlayer Design we’ll look at the general design for these simple players. We’ll look at the superclass in CrapsSimplePlayer superclass. We’ll look at each of the strategies in Craps Martingale Player, Player1326 State, Craps1326 Player and CrapsCancellation Player.
In Simple Craps Players Deliverables we’ll detail the deliverables for this chapter.
Simple Craps Players Analysis¶
The Player
class hierarchy suggests there are a number
of betting strategies for the Pass Line Odds bet. We
use the Martingale strategy for our CrapsMartingale
player.
We could also use the 1-3-2-6 system, the Cancellation system, or the
Fibonacci system for those odds bets. In each of these cases, we are
applying the betting strategy to one of the two bets the player will use.
An additional design note for this section is the choice of the two basic bets: the Pass Line and the Pass Line Odds bet. It is interesting to compare the results of these bets with the results of the Don’t Pass Line and the Don’t Pass Odds Bet. In particular, the Don’t Pass Odds Bets involve betting large sums of money for small returns; this will be compounded by any of these betting systems which accelerate the amount of the bet to cover losses. This change should be a simple matter of changing the two base bets used by all these variant players.
All of these players have a base bet (either Pass Line or Don’t Pass)
and an odds bet (either Pass Line Odds or Don’t Pass Odds). If we create
a superclass, called SimpleCraps
, we can assure that all
these simple betting variations will work for Pass Line as well as Don’t
Pass Line bets. The responsibility of this superclass is to define a
consistent set of fields and constructor for all of the subclasses.
Craps 1-3-2-6 Player¶
This player uses the 1-3-2-6 system for managing their
odds bet. From the Roulette 1-3-2-6 player (see Player 1-3-2-6 Analysis) we can
see that this player will need to use the Player1326State
class hierarchy. The craps player will use one of these objects track
the state changes of their odds. The base bet will not change.
However, the current definitions of the Player1326State
class hierarchy specifically reference Roulette1326
.
Presenting us with an interesting design problem. How do we repair our
design so that Player1326State
can work with Roulette1326
and Craps1326
?
The only dependency is the field outcome
,
which both Roulette1326
and Craps1326
must
provide to Player1326State
objects.
Problem. Where do store the Outcome
object
used by both the player and the state?
Forces. We have some common choices:
Create a Mixin Class. We extract the field and make it part of an mixin class that is required by
Player
subclasses that use the 1-3-2-6 strategy.Create a Common Superclass. In this case, we refactor the field up to the superclass.
Delegate to The State Object. This changes the defintion of
Player1326State
to make it more self-contained.
Mixin Class.
The relationship between a subclass of the
Player
class and thePlayer1326State
class can be formalized through an mixin class definition. We can define aBet1326_Able
class, which contains theOutcome
attribute and use this for theRoulette1326
andCraps1326
classes.class Bet1326_Able: def __init__(self) -> None: self.outcome = None class CrapsPlayer(Bet1326_Able, Player): def __init__(self) -> None: super().__init__()In this case, this appears to be an example of the Very Large Hammer design pattern. We’re using a very large hammer to pound a very small nail. The problem seems too small for this complex-looknig language feature.
Common Superclass.
We can refactor the single instance variable up to the superclass. This is a relatively minor change. However, it places a feature in a superclass which all but a few subclasses must ignore. This is another example of Swiss Army Knife design, where we will be subtracting or trying to ignore a feature from a superclass.
Delegate to the State Class.
If we change the
Player1326State
class to keep its own copy of the desiredOutcome
instance we cleanly remove any dependence onPlayer
class. ThePlayer
class is still responsible for keeping track of theOutcome
instances, and has subcontracted or delegated this responsibility to an instance of thePlayer1326State
classThe down side of this is that we must provide this
Outcome
instance to each state constructor as the state changes.
Solution. The solution we embrace is changing the definition of the Player1326State
class
to include the Outcome
instance. This delegates responsibility to
the state, where it seems to belong. This will change all of the
constructors, and all of the state change methods, but will cleanly
separate the Player1326State
class hierarchy from the Player
class hierarchy.
Craps Cancellation Player¶
When we examine the Roulette Cancellation Cancellation Player Analysis player we see that this player will need to use a list of individual betting amounts. Each win for an odds bet will cancel from this list, and each loss of an odds bet will append to this list.
As with the Craps Martingale player, we will be managing a base Pass Line bet, as well as an odds bet that uses the Cancellation strategy. The Cancellation algorithm can be easily transplanted from the original Roulette version to this new Craps version.
Craps Fibonacci Player¶
We can examine the Roulette Fibonacci Fibonacci Player Analysis and see that this player will need to compute new betting amounts based on wins and losses. THis will parallel the way the cancellation player works.
We’ll can have a Fibanacci series for some bets (like pass line bets) but a flat bet for the behind the line odds bet.
CrapsPlayer Design¶
We’ll extend the CrapsPlayer
class to create a CrapsSimplePlayer
class
to place both Pass Line and Pass Line Odds bets, as well as Don’t
Pass Line and Don’t Pass Odds bets. This will allow us to drop the CrapsPlayerPass
class, and revise the existing CrapsMartingale
class.
We have to rework the original Roulette-focused Player1326State
class
hierarchy, and the Roulette1326
class to use the new
version of the state objects.
Once this rework is complete, we can add the Craps1326
and CrapsCancellation
player subclasses.
For additional exposure, the more advanced student can rework the
Roulette Fibonacci player to create a CrapsFibonacci
player.
CrapsSimplePlayer superclass¶
-
class
CrapsSimplePlayer
¶ The
CrapsSimplePlayer
is a subclass ofCrapsPlayer
class and places two bets in Craps. The simple player has a base bet and an odds bet. The base bet is one of the bets available on the come out roll (either Pass Line or Don’t Pass Line), the odds bet is the corresponding odds bet (Pass Line Odds or Don’t Pass Odds). This class implements the basic procedure for placing the line bet and the behind the line odds bet. However, the exact amount of the behind the line odds bet is left as an abstract method. This allows subclasses to use any of a variety of betting strategies, including Martingale, 1-3-2-6, Cancellation and Fibonacci.
Fields¶
Constructors¶
-
CrapsSimplePlayer.
__init__
(self, table: Table, line: Outcome, odds: Outcome) → None¶ - Parameters
Constructs the
CrapsSimplePlayer
instance with a specificTable
object for placingBet
instances. Additionally a line bet (Pass Line or Don’t Pass Line) and odds bet (Pass Line Odds or Don’t Pass Odds) are provided to this constructor. This allows us to make either Pass Line or Don’t Pass Line players.
Methods¶
-
CrapsSimplePlayer.
placeBets
(self) → None¶ Updates the
Table
instance with the variousBet
instances. There are two basic betting rules.If there is no line bet, create the line
Bet
instance from theline
Outcome
object.If there is no odds bet, create the behind the line odds
Bet
instance from theodds
Outcome
object.
It’s essentual to check the price of the
Bet
instance before placing it. Particularly, Don’t Pass Odds bets may have a price that exceeds the player’s stake. This means that theBet
object must be constructed, then the price tested against thestake
to see if the player can even afford it. If thestake
is greater than or equal to the price, subtract the price and place the bet. Otherwise, simply ignore it the unafforableBet
object.
Craps Martingale Player¶
-
class
CrapsMartingale
¶ CrapsMartingale
is a subclass ofCrapsSimplePlayer
who places bets in Craps. This player doubles their Pass Line Odds bet on every loss and resets their Pass Line Odds bet to a base amount on each win.
Fields¶
-
CrapsMartingale.
lossCount
¶ The number of losses. This is the number of times to double the pass line odds bet.
-
CrapsMartingale.
betMultiple
¶ The the bet multiplier, based on the number of losses. This starts at 1, and is reset to 1 on each win. It is doubled in each loss. This is always .
Methods¶
-
CrapsMartingale.
placeBets
(self) → None¶ Extension to the superclass
placeBets()
method. This version sets the amount based on the value ofCrapsMartingale.betMultiple
.
-
CrapsMartingale.
win
(self, bet: Bet) → None¶ - Parameters
bet (
Bet
) – The bet that was a winner
Uses the superclass
win()
method to update the stake with an amount won. This method then resetslossCount
to zero, and resetsbetMultiple
to1
.
-
CrapsMartingale.
lose
(self, bet: Bet) → None¶ - Parameters
bet (
Bet
) – The bet that was a loser
Increments
lossCount
by1
and doublesbetMultiple
.
Player1326 State¶
Player1326State
is the superclass for all of the states in
the 1-3-2-6 betting system.
Constructors¶
Methods¶
Much of the original design for this state hierarchy should remain in place. See Player 1-3-2-6 Class for more information on the original design.
-
Player1326State.
nextLost
(self) → Player1326State¶ Constructs the new
Player1326State
instance to be used when the bet was a loser. This method is the same for each subclass: it creates a new instance ofPlayer1326NoWins
class.This method is defined in the superclass to assure that it is available for each subclass. This will use the
outcome
to be sure the new state has theOutcome
object on which the owning Player will be betting.
Craps1326 Player¶
-
class
Craps1326
¶ Craps1326
is a subclass ofCrapsSimplePlayer
class who places bets in Craps. This player changes their Pass Line Odds bet on every loss and resets their Pass Line Odds bet to a base amount on each win. The sequence of bet multipliers is given by the currentPlayer1326State
object.
Fields¶
-
Player1326State.
state
¶ This is the current state of the 1-3-2-6 betting system. It will be an instance of one of the four states: No Wins, One Win, Two Wins or Three Wins.
Constructors¶
-
Player1326.
__init__
(self, table: CrapsTable, line: Outcome, odds: Outcome) → None¶ - Parameters
Uses the superclass to initialize the
Craps1326
instance with a specificTable
object for placingBet
instances, and set the line bet (Pass Line or Don’t Pass Line) and odds bet (Pass Line Odds or Don’t Pass Odds).Then the initial state is an instance of the
Player1326NoWins
class, constructed using the odds bet.
Methods¶
-
Player1326.
placeBets
(self) → None¶ Updates the
Table
instance with a bet created by the current state. This method delegates the bet creation tostate
object’scurrentBet()
method.
CrapsCancellation Player¶
-
class
CrapsCancellation
¶ CrapsCancellation
is a subclass ofCrapsSimplePlayer
who places bets in Craps. This player changes their Pass Line Odds bet on every win and loss using a budget to which losses are appended and winings are cancelled.
Fields¶
-
CrapsCancellation.
sequence
¶ This
list
keeps the bet amounts; wins are removed from this list and losses are appended to this list. THe current bet is the first value plus the last value.
Constructors¶
-
CrapsCancellation.
__init__
(self, table: CrapsTable, line: Outcome, odds: Outcome) → None¶ - Parameters
Invokes the superclass constructor to initialize this instance of
CrapsCancellation
. Then callsresetSequence()
to create the betting budget.
Methods¶
There are few real changes to the original implementation of CancellationPlayer.
See Cancellation Player Class for more information.
-
CrapsCancellation.
placeBets
(self) → None¶ Creates a bet from the sum of the first and last values of
sequence
and the preferred outcome.This uses the essential line bet and odds bet algorithm defined above. If no line bet, this is created.
If there’s a line bet and no odds bet, then the odds bet is created.
If both bets are created, there is no more betting to do.
Simple Craps Players Deliverables¶
There are eight deliverables for this exercise.
The
CrapsSimplePlayer
abstract superclass. Since this class doesn’t have a body for theoddsBet()
method, it can’t be unit tested directly.A revised
CrapsMartingale
class, that is a proper subclass ofCrapsSimplePlayer
. The existing unit test forCrapsMartingale
should continue to work correctly after these changes.A revised
Player1326State
class hierarchy. Each subclass will use theoutcome
field instead of getting this information from aPlayer1326
instance. The unit tests will have to be revised slightly to reflect the changed constructors for this class.A revised
Roulette1326
class, which reflects the changed constructors for thisPlayer1326State
. The unit tests should indicate that this change has no adverse effect.The
Craps1326
subclass ofCrapsSimplePlayer
. This will use the revisedPlayer1326State
.A unit test class for
Craps1326
. This test should synthesize a fixed list ofOutcome
instances,Throw
instances, and calls aCraps1326
instance with various sequences of craps, naturals and points to assure that the bet changes appropriately.The
CrapsCancellation
subclass ofCrapsSimplePlayer
.A unit test class for
CrapsCancellation
. This test should synthesize a fixed list ofOutcome
instances,Throw
instances, and calls aCrapsCancellation
instance with various sequences of craps, naturals and points to assure that the bet changes appropriately.
Looking Forward¶
This is a large number of alternative playing strategies. It’s important to see how the betting schemes are their own class hierarchy, separate from the overall players.
In the next chapter we’ll at some more stateful player alterives. In this case, a player that counts rolls and adds “hedge bets” to guard against losses.


Image Sub-region Identifier
Choose Image
{{img.name}}
{{ current_image_name }}
Identify Regions
Delete All Regions
Label
Probability
{{ prob[0] }}
{{ prob[1] * 100 | number:1 }}%


Good deed of the day - local charity in need of new trustees
Could you be the next trustee for the United Charities of Abel Collin?
by Sarah BrazendaleHere's a chance to use your talents to help others, the United Charities of Abel Collin are in need of a new trustee for its board.
The charity, originally founded in 1709, provides quality housing for up to 100 independent, older people of modest means in homes in Beeston in Nottingham.
The board currently has 10 trustees, these are unpaid volunteers that are hands-on in the role, ensuring proper governance, developing new policies and making decisions across a wide range of issues. The board also manages the finances, grounds, properties and two members of staff.
Interested?
So if you have a background or expertise in any of the following areas, get in touch today. Housing or property maintenance, IT, web design, human resources, law, the care sector or finance – however, applicants able to offer other skills are welcome.
The trustees usually hold eight meetings a year on a Tuesday morning, each of which lasts around two hours.
For more information or to apply, call Joanna Bond (administrator) on 0115 922 4826, Monday to Friday, or email abelcollinsadmin@btconnect.com


SPICE WORLD (Columbia)
If you were to make up a mock Top-40 chart of all the movies ever made featuring pop stars, the Spice Girls' "Spice World" would fit in well below Prince's "Purple Rain" and several notches above Peter Frampton and the Bee Gees' ghastly, overblown "Sgt. Pepper's Lonely Hearts Club Band." "Spice World," directed by Bob Spiers of "Absolutely Fabulous" fame, is at the very least unpretentious, with only one item on its agenda: to sell the Spice Girls in a lavish 93-minute commercial. The group's many detractors may be dismayed to discover the Girls have a winning sense of humor about themselves, their image and their art. To borrow a line from a pop princess of the past, these Girls just want to have fun, and sometimes the good humor they generate is contagious. Although the model for "Spice World" would seem to be the Beatles' film debut "A Hard Day's Night," the film most closely resembles the 1967 obscurity "Good Times," which attempted to launch Sonny and Cher as a big-screen team. The concept behind "Good Times" had the duo enacting fantasies about the kind of movie they'd like to star in, while, in the real world, they negotiated to get out of acting in a picture they knew wasn't right for them. What little plot "Spice World" has consists of filmmakers Mark McKinney and George Wendt pitching script ideas to Clifford (Richard E. Grant) , the Spice Girls' fictitious manager. At the same time, a documentary crew headed by Alan Cumming is trying to get the real story behind the hype, and the quintet of Girls are struggling to balance their loyalty to old friends with the demands of world-wide superstardom. What sets "Spice World" apart from most rock movies is its ambivilent attitude toward fame. Each of the Spices --Baby, Posh, Ginger, Scary and Sporty, and yes, you will be able to identify each of them by the end of the film-- seem to realize Spicemania won't last forever and the inevitable reversal of fortune is coming. "In the old days, it was 'where's our next meal coming from?'," says Baby Spice in one of the film's few quiet moments. "Now, it's 'where's our next single going to?'." Still, this is hardly a scathing expose of the music scene. Much of "Spice World" consists of the Girls' performances of revamped versions of "Say You'll Be There" and "Wannabe," as well as their current tunes, such as the shout-it-out salsa number "Spice Up Your Life" and the endearingly doo-wopish "Too Much." Like the film's comedy, the music is not always consistently good but it is consistently loud. Years from now, "Spice World" will undoubtedly serve as a colorful reminder of a pop phenomenon, and that seems to be all it ever intended to be. "That was absolutely perfect without actually being any good," a music director tells the group after a false start on one of their songs. The same review applies to "Spice World."
James Sanford
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Competitive Events
Hub
Events, Themes, and Updates
National Events List (NQEs)
Texas Events List (UTEs)
Themes and Problems
Competition Updates
Guides and Rulebooks
National TSA 2019 Competitive Events Guide
UTE Rulebook
The Hebron TSA Ultimate Guide
Documentation
Copyright Checklist
LEAP Report Template
LEAP Report Example
Plan of Work Log
Hebron TSA
Event Selection Form
Checkpoint Meeting Schedule
Meeting Presentations


---
layout: post
title: Bullies of the corporate world!!!!!
date: 2013-08-31 11:19:00.000000000 +05:30
categories: []
tags:
- corporate
- corporate flaws
- Discussion
- life
status: publish
type: post
published: true
meta:
blogger_bid: '2279754227642197645'
blogger_blog: ankurthetechie.blogspot.com
blogger_id: '2479192086446703039'
blogger_author: g116451164261752827176
blogger_comments: '0'
blogger_permalink: /2013/08/bullies-of-corporate-world.html
author:
login: admin@reportlingo
email<EMAIL_ADDRESS>display_name: admin@reportlingo
first_name: Ankur
last_name: Gupta
excerpt: !ruby/object:Hpricot::Doc
options: {}
---
Actually if anyone would think about their past lives - schooling days, college days..... There is a prominent appearance of a unwanted person known as BULLIES
Someone might have been a bully who would have acted as a roadblock. But as we move onto a corporate world then we think those hard times given by the bullies have gone. But, heads up its really sad to see the same bullies in the corporate world too.
Do you think people at higher posts have become meaner and are sunk in there pride??
Well it seems that these people become bully because they have been bullied in the beginning of their career by their seniors and later when they are in a respectable position they desire to bring the same wrath upon the new comers.
Because of this unwelcoming nature of the senior workers, newbies have a hard time to blend in the office culture and also could not provide their cent percent in the task allotted to them. Mostly they have fear if a thing is done wrongly once then all the blame is put upon them without giving a thought to the mental stress , will he be able to bear the blame or just perish under the blame and get exposed to the sarcasm . People at the high post just to clear their hands of the blame they plant the blame on the immediate junior and then he does to the other level and so the chain of imposition of blame continues down the hierarchy.
So it's not a person but the whole chain of bullies being followed. But If the people at good position so called bosses, team leads, group leader somebody takes the stand and does not bully the new comers, then he will definitely give space for new people who think in a progressive way. This will help in reducing the bully concept from the system. If the mangers, team leads understand the error and impose the blame on not only on the member at the lowest level but he should impose it in the team completely so that whole team of people are held responsible.
Yes someone might say that what will happen if one manager or lead does that but news flash, this small stand will help the juniors or the new comers prosper and would enhance the office environment.
So this is my view stating the problems but others might have a different opinion. I might have offended some people sorry for that, but someone needs to come forward for this.


First Name
Last Name
Email Address
Password
Confirm Password
District Name
Select Districtt Name
Dhaka
Khulna
Sylhet
Chittagong
Barisal


Upcoming Events
https://hacksocnotts.co.uk/events
Tuesdays 6:30pm, A32 Lab:
Intro to Python Workshops
Thursday 25th October 6:30pm, The Hub:
Being part of the community
and how to talk really, really good


Look up environment settings specific to different operating systems.
```javascript var osenv = require(‘osenv’) var path = osenv.path() var user = osenv.user() // etc.
// Some things are not reliably in the env, and have a fallback command: var h = osenv.hostname(function (er, hostname) { h = hostname }) // This will still cause it to be memoized, so calling osenv.hostname() // is now an immediate operation.
// You can always send a cb, which will get called in the nextTick // if it’s been memoized, or wait for the fallback data if it wasn’t // found in the environment. osenv.hostname(function (er, hostname) { if (er) console.error(‘error looking up hostname’) else console.log(‘this machine calls itself %s’, hostname) }) ```
The machine name. Calls hostname
if not found.
The currently logged-in user. Calls whoami
if not found.
Either PS1 on unix, or PROMPT on Windows.
The place where temporary files should be created.
No place like it.
An array of the places that the operating system will search for executables.
Return the executable name of the editor program. This uses the EDITOR
and VISUAL environment variables, and falls back to vi
on Unix, or
notepad.exe
on Windows.
The SHELL on Unix, which Windows calls the ComSpec. Defaults to ‘bash’ or ‘cmd’.


--- layout: default title: Home published: true ---
Hi, I'm Tommy
My two loves in life are Media: its consumption, production, and distribution; and the Internet: for all the affordances it provides Digital Media.
I work hard to help people be heard on the Web.
This is my voice: Welcome!


|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| BeanContext | The BeanContext acts a logical hierarchical container for JavaBeans. |
| BeanContextChild | JavaBeans wishing to be nested within, and obtain a reference to their execution environment, or context, as defined by the BeanContext sub-interface shall implement this interface. |
| BeanContextChildComponentProxy |
This interface is implemented by
BeanContextChildren that have an AWT Component
associated with them. |
| BeanContextContainerProxy | This interface is implemented by BeanContexts' that have an AWT Container associated with them. |
| BeanContextMembershipListener | Compliant BeanContexts fire events on this interface when the state of the membership of the BeanContext changes. |
| BeanContextProxy | This interface is implemented by a JavaBean that does not directly have a BeanContext(Child) associated with it (via implementing that interface or a subinterface thereof), but has a public BeanContext(Child) delegated from it. |
| BeanContextServiceProvider | One of the primary functions of a BeanContext is to act a as rendezvous between JavaBeans, and BeanContextServiceProviders. |
| BeanContextServiceProviderBeanInfo | A BeanContextServiceProvider implementor who wishes to provide explicit information about the services their bean may provide shall implement a BeanInfo class that implements this BeanInfo subinterface and provides explicit information about the methods, properties, events, etc, of their services. |
| BeanContextServiceRevokedListener | The listener interface for receiving
BeanContextServiceRevokedEvent objects. |
| BeanContextServices | The BeanContextServices interface provides a mechanism for a BeanContext to expose generic "services" to the BeanContextChild objects within. |
| BeanContextServicesListener | The listener interface for receiving
BeanContextServiceAvailableEvent objects. |
| Class Summary | |
|---|---|
| BeanContextChildSupport | This is a general support class to provide support for implementing the BeanContextChild protocol. |
| BeanContextEvent |
BeanContextEvent is the abstract root event class
for all events emitted
from, and pertaining to the semantics of, a BeanContext . |
| BeanContextMembershipEvent | A BeanContextMembershipEvent encapsulates
the list of children added to, or removed from,
the membership of a particular BeanContext . |
| BeanContextServiceAvailableEvent | This event type is used by the BeanContextServicesListener in order to identify the service being registered. |
| BeanContextServiceRevokedEvent |
This event type is used by the
BeanContextServiceRevokedListener in order to
identify the service being revoked. |
| BeanContextServicesSupport | This helper class provides a utility implementation of the java.beans.beancontext.BeanContextServices interface. |
| BeanContextServicesSupport.BCSSServiceProvider | subclasses may subclass this nested class to add behaviors for each BeanContextServicesProvider. |
| BeanContextSupport | This helper class provides a utility implementation of the java.beans.beancontext.BeanContext interface. |
| BeanContextSupport.BCSIterator | protected final subclass that encapsulates an iterator but implements a noop remove() method. |
Provides classes and interfaces relating to bean context. A bean context is a container for beans and defines the execution environment for the beans it contains. There can be several beans in a single bean context, and a bean context can be nested within another bean context. This package also contains events and listener interface for beans being added and removed from a bean context.
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
Copyright © 2004, 2010 Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.