I have just found this Forum and I am very interested in developing an Energy Monitor to control PV and Grid power in an eco house. I have been experimenting with Hall effect clamps and my main problem is detecting which way the power is flowing - i.e. am I exporting or importing.
I see from your display pictures that you have a clear + or - indication of power flow direction.
Having looked through most of the pages of this site (but I have not studied the software) I do not see how the OpenEnergyMonitor Arduino system does it. Does a CT sensor behave differently from a Hall sensor and give a distinct directional output, or do you compute this from voltage/current phase angles via your mains transformer ?
I have been playing with digital and mpu systems for years but am not well versed in 240v phase angle details.
Re: 240v power direction
Hello, nice plans!
There are two ways you can sense direction
1) Using a AC voltage adapter as in the Mains AC v.3 circuit.
2) If your measuring PV output and the house power consumption then we can infer direction:
Import = house - pv output.
When import is negative it is exporting.
All the best
Trystan
Re: 240v power direction
You might like to see my project which acheives your objectives. I used Trystan's No2 because it gives you greater flexibility in the home wiring circuit. (seperating the immersion power circuit from normal power usage to prevent hysteresis).
I also post the readings to Pachube so I can check on generation/usage/efficiency.
Re: 240v power direction
I am new to the open energy monitor,have just started the project with my SCT-013-030.as this kind of CT has the inbulit burden resistor i am not using any burden resistor.
My problem which i am facing is with 100W bulb i am getting ct output of 14mV and i can't give it directly to my atmega 328.any suggestion on how to amplify these 14mV to my controller level.
The other problem is, arduino is not available here can i form my own board with Atmeg 328 and other components.any suggestion Plz!
Re: 240v power direction
Hello faizan
The circuit you need to interface a CT with an atmega 328 can be found here:
http://openenergymonitor.org/emon/buildingblocks/ct-sensors-interface
and yes it will work if you build an atmega based board, it does not have to be an arduino.
Re: 240v power direction
Hi Paul,
Your project is exactly what I am also looking for. Do you mind if I ask for the schematic diagram which shows discrete components attached to Arduino circuit.
Thank you very much.
Re: 240v power direction
See "Building Blocks" for the basic theory and the emonTx Shield circuit diagrams on the Wiki for practical circuits.


|
SpiFlash
|
Particle library for SPI NOR flash memory chips
This library provides access to SPI NOR flash chips on the Particle platform. It's a low-level access that allows byte-level write-to-0 and sector-level erase-to-1.
You probably won't use this library directly; it's intended by be used as the hardware interface for a library that provides easier access, wear-leveling, flash translation, etc.. I recommend the SpiffsParticleRK library.
The full browsable API documentation can be found here.
You typically instantiate an object to interface to the flash chip as a global variable:
Use an ISSI flash, such as a IS25LQ080B. In this case, connected to the primary SPI with A2 as the CS (chip select or SS).
Use a Winbond flash, such as a W25Q32. In this case, connected to the primary SPI with A2 as the CS (chip select or SS).
Winbond flash, connected to the secondary SPI, SPI1, with D5 as the CS (chip select or SS).
Macronix flash, such as the MX25L8006EM1I-12G. In this case connected to the secondary SPI, SPI1, with D5 as the CS (chip select or SS). This is the recommended for use on the E-Series module. Note that this is the 0.154", 3.90mm width 8-SOIC package.
This is the external flash on the P1 module. This extra flash chip is entirely available for your user; it is not used by the system firmware. You can only use this on the P1; it relies on system functions that are not available on other devices.
For the primary SPI (SPI):
| Name | Flash Alt Name | Particle Pin | Example Color |
|---|---|---|---|
| SS | CS | A2 | White |
| SCK | CLK | A3 | Orange |
| MISO | DO | A4 | Blue |
| MOSI | D1 | A5 | Green |
For the secondary SPI (SPI1):
| Name | Flash Alt Name | Particle Pin | Example Color |
|---|---|---|---|
| SS | CS | D5 | White |
| SCK | CLK | D4 | Orange |
| MISO | DO | D3 | Blue |
| MOSI | D1 | D2 | Green |
Note that the SS/CS line can be any available GPIO pin, not just the one specified in the table above.
The API is described in the SpiFlashRK.h file. But you will rarely need to use the low-level API directly.
public void
begin
()
Call begin, probably from setup(). The initializes the SPI object.
public bool
isValid
()
Returns true if there is a flash chip present and it appears to be the correct manufacturer code.
public uint32_t
jedecIdRead
()
Gets the JEDEC ID for the flash device.
A 32-bit value containing the manufacturer ID and the two device IDs:
public void
readData
(size_t addr,void * buf,size_t bufLen)
Reads data synchronously. Reads data correctly across page boundaries.
addr
The address to read frombuf
The buffer to store data inbufLen
The number of bytes to readpublic void
writeData
(size_t addr,const void * buf,size_t bufLen)
Writes data synchronously. Can write data across page boundaries.
addr
The address to read frombuf
The buffer to store data inbufLen
The number of bytes to writepublic void
sectorErase
(size_t addr)
Erases a sector. Sectors are sectorSize bytes and the smallest unit that can be erased.
This call blocks for the duration of the erase, which take take some time (up to 500 milliseconds).
addr
Address of the beginning of the sector. Must be at the start of a sector boundary.public void
chipErase
()
Erases the entire chip.
This call blocks for the duration of the erase, which take take some time (several secoonds). This function uses delay(1) so the cloud connection will be serviced in non-system-threaded mode.
public inline size_t
getPageSize
() const
Gets the page size (default: 256)
public inline
SpiFlashBase
&
withPageSize
(size_t value)
Sets the page size (default: 256)
public inline size_t
getSectorSize
() const
Gets the sector size (default: 4096)
public inline
SpiFlashBase
&
withSectorSize
(size_t value)
Sets the sector size (default: 4096)


Top of the page
Practice CSS here
Open youtube
Hello This is REPetitive
Hello This is repetitive
Hello This is repetitive
About
Name
Password
Select your favourite language
Javascript
java
python
C
python
Java
javascript
-NONE-
Javascript
Java
Python
Submit
Copyright © by RD
back to top


Whoops! Something Went Wrong
It looks like you are not authorized to make changes or delete this item.
You may only edit/delete items that are registered to your account.
Since you are logged in, create your own jersey item!
Click Here To Return To Homepage!


This is the start
Thanks for deciding to use SuperBro in your project. This is just placeholder and you can start your own website / project by replacing this. If you need help you can check our documentation at SuperBro website.
Thanks for deciding to use SuperBro in your project. This is just placeholder and you can start your own website / project by replacing this. If you need help you can check our documentation at SuperBro website.


Hundreds of professional life coaches are here to teach you the skills and discipline it takes to reach your goals. Tell us what you want to achieve, and we'll match you up with coaches who can help.
Browse our coaches directory and talk with as many coaches as you want, for free, until you find the coach who best suits your needs.
Subscribe to unlimited messaging with your coach for only $29 per week. Send messages at your convenience, whenever you need advice. Cancel any time.
If messaging isn't your thing, no problem. You can book phone consultations with your coach directly through our platform.


A period is a natural process that a woman's body goes through. During ones period a females body is going through puberty. Everyone goes through puberty, it's natural. Hormones are chemical substances that travel all over your body and help control you! During puberty new hormones are being created. For females these hormones help with preparing for pregancy later on in life. Periods can start as young as 8 and as old to 16. While on your period (also known as the menstrual cycle) blood leaves a girl's body, which is the most visible part of the process. This process can last up to 3 and 10 days depending on your own body.
During a period one might feel physical and mental pain. A young woman's body is going through change! Dealing with cramps, bloating, acne breakouts, mood swings, headaches, and sleepyness are all symptoms of a period. PMS-Premenstrual syndrome- is a group of changes that can affect a person on many levels. This change comes a few weeks before your period. To help deal with period issues working out can help smoothe the body. Taking care of what goes in the body and taking care of skin is very important.
If your unfamiliar with the Pink Tax or the #PinkTax movement it's the extra amount of money that women are charged with that are produced as feminine or "luxury" items.
Some examples of products are...
This is harmful to many girls who are either homeless or don't have enough money to buy these products.
One might have an irregular period. An irregular period is when a girls cycle is different (off a few days). Most are around 28 days. A irregular period is nothing to be worried about, just be prepared for unexpectedness. This might happen because of stress, weight, or just your body getting used to having a period.
Can someone get pregnant on their period?Yes you can still get pregnant. If ones cycle is different you can ovulate early. Ovulation is the realease of eggs in ones ovaries. It is possible, so be careful.
Does using a tampon hurt?No using a tampon shouldn't hurt unless it's uncorrectly used. The body is meant to stretch.
For more information go to the planned parenthood website


public class OR_Protocol
extends java.lang.Object
| Modifier and Type | Field | Description |
|---|---|---|
static int |
FINAL_STATE |
The final state indicates the closure of the communication channel between Client and Server
|
static int |
INITIAL_STATE |
The initial state of the engine.
|
static int |
INTERACTING_STATE |
The interacting state indicates that the Client and Server are in conversation
|
| Constructor | Description |
|---|---|
OR_Protocol() |
Constructor.
|
| Modifier and Type | Method | Description |
|---|---|---|
int |
GetCurrentState() |
Returns the current state of the protocol engine.
|
java.lang.String |
GetLastReponse() |
Returns the last reponse from engine.
|
java.lang.String |
ProcessMessage(java.lang.String message) |
Returns the processed response string from the parsed message.
|
public static final int INITIAL_STATE
public static final int INTERACTING_STATE
public static final int FINAL_STATE
public OR_Protocol()
public java.lang.String ProcessMessage(java.lang.String message)
message
- (Required) Message that needs to be processed by the protocol engine.public java.lang.String GetLastReponse()
public int GetCurrentState()


|
Integrated number of events |
Integrated number of tracks |
|
Average number of tracks |
Average Chi^2/dof per track |
|
Average number of Rec hits per track |
|
|
Mean ADC counts for barrel |
Mean ADC counts for endcap |
|
Mean ADC counts for barrel |
Mean ADC counts for endcap |
|
A ratio of the number of tracks in the pixel detector to the total number of tracks |
|


public class BBPetterson
extends java.lang.Object
implements java.io.Serializable
Processor
agents. The instance
should be created by the Launcher
agent.| Modifier and Type | Field and Description |
|---|---|
private static BBPetterson |
instance |
private boolean[] |
requests |
private static long |
serialVersionUID |
private int |
tour |
| Modifier | Constructor and Description |
|---|---|
private |
BBPetterson(int n)
Private constructor of the class.
|
| Modifier and Type | Method and Description |
|---|---|
static void |
createInstance(int nbConcurrent)
Allows to create the instance of the class.
|
static BBPetterson |
getInstance()
Allows to get the instance of the class.
|
int |
getNbRequests()
Allows to get the total request number possible as the number of concurrent
Processor agents. |
boolean |
getRequest(int id)
Allows to get a
Processor agent current request state. |
int |
getTour()
Allows to get the current
Processor agent tour as its corresponding
id. |
void |
setRequest(int id,
boolean value)
Allows to define a
Processor agent current request state. |
void |
setTour(int tour)
Allows to define the current
Processor agent tour as its
corresponding id. |
private static final long serialVersionUID
private int tour
private boolean[] requests
private static BBPetterson instance
private BBPetterson(int n)
n
- the number of concurrent Processor
agents that will use the
instancepublic static BBPetterson getInstance() throws BBPettersonException
BBPetterson
class.BBPettersonException
- if the class has not been previously
instanciated in the programpublic static void createInstance(int nbConcurrent) throws BBPettersonException
nbConcurrent
- the number of concurrent Processor
agents that
will use the instanceBBPettersonException
- if the class has already been instanciated in
the programpublic int getTour()
Processor
agent tour as its corresponding
id.Processor
agent tourpublic void setTour(int tour)
Processor
agent tour as its
corresponding id.tour
- the id of the current Processor
agent tourpublic boolean getRequest(int id)
Processor
agent current request state.id
- the id of the Processor
agenttrue
if the Processor
agent is currently requesting
the access, false
otherwisepublic void setRequest(int id, boolean value)
Processor
agent current request state.id
- the id of the Processor
agentvalue
- true
if the Processor
agent wants to request the
access, false
if he wants to remove itpublic int getNbRequests()
Processor
agents.


Amount added
Date
Note
-
To deposit funds to this CasinoCoin paper wallet: send CSC to the public address
-
To check the balance of this wallet:
go to explorer.casinocoin.org and
enter the public address
-
DO NOT REVEAL THE PRIVATE KEY until you are ready to import the balance of this wallet to a CasinoCoin client, exchange or online wallet
This is an unofficial wallet. The source is available here.


Home
Groups
Sign out
Your groups
Discover more groups
Create new group
Add new group
x
University
Degree
Year
Create the group
keyboard_backspace
Your events
Discover more events
Create new event
Add new event
x
Title
Start date
End date
Create the event


BabyAI is a research platform to investigate and support the feasibility of including humans in the loop for grounded language learning.
The setup is a series of levels (of increasing difficulty) to train the agent to acquire a synthetic language (Baby Language) which is a proper subset of English language.
BabyAI platform provides support for curriculum learning and interactive learning as part of its human-in-the-loop training setup.
Curriculum learning is incorporated by having a curriculum of levels of increasing difficulty.
Interactive learning is supported by including a heuristic expert which can provide new demonstrations on the fly to the learning agent.
The heuristic expert can be thought of as the human-in-the-loop which can guide the agent through the learning process.
One downside of human-in-the-loop is the poor sample complexity of the learning agent. The heuristic agent can be used to estimate the sample efficiency.
BabyAI research platform for grounded language learning with a simulated human-in-the-loop.
Baseline results for performance and sample efficiency for the different tasks.
MiniGrid - A partially observable 2D grid-world environment.
Entities - Agent, ball, box, door, keys
Actions - pick, drop or move objects, unlock doors etc.
Synthetic Language (a proper subset of English) - Used to give instructions to the agent
Support for verifying if the task (and the subtasks) are completed or not
A level is an instruction-following task.
Formally, a level is a distribution of missions - a combination of initial state of the environment and an instruction (in Baby Language)
Motivated by curriculum learning, the authors create a series of tasks (with increasing difficulty).
A subset of skills (competencies) is required for solving each task. The platform takes into account this constraint when creating a level.
The platform supports a Heuristic expert that simulates the role of a human teacher and knows how to solve each task.
For any level, it can suggest actions or generate demonstrations (given the state of the environment).
An imitation learning baseline is trained for each level.
Data requirement for each level and the benefits of curriculum learning and imitation learning are investigated (in terms of sample efficiency).
GRU to encode the sentence, CNN to encode the input observation
FiLM layer to combine the two representations
LSTM to encode the per-timestep FiLM encoding (timesteps in the environment)
Two model variants are considered:
Large Model - Bidirectional GRU + attention + large hidden state
Small Model - Unidirectional GRU + No attention + small hidden state
Heuristic expert used to generate trajectory and the models are trained by imitation learning (to be used as baselines)
The key takeaway is that the current deep learning approaches are extremely sample inefficient when learning a compositional language.
Data efficiency of RL methods is much worse than that of imitation learning methods showing that the current imitation learning and reinforcement learning methods scale and generalize poorly.
Curriculum-based pretraining and interactive learning was found to be useful in only some cases.


An accomplished, results driven professional with expertise and training in administration, clientele research and analytics.
A self motivated individual with excellent communication and interpersonal skills.
Goal oriented with an unique ability to become a positive role model while working with in a team setting.
An effective communicator with the ability to interact effectively with all stakeholders and business partners.
Critical thinker who uses logic and reason to identify a plan, implement and strategize solutions for problems.
Technically savvy Individual with specific expertise in Microsoft office systems as well as Apple and Mac operating systems.


Neumorphism UI
Neumorphism inspired User Interface Kit that will help you prototype and design beautiful, creative and modern websites.
A Themesberg productionOver 200 components
Beatifully crafted and neumorphism inspired elements
10+ sections
Navigation bars, pricing cards, footers and many more sections to enhance page variety
5 example pages
We took the time to create a few example pages to show you how neumorphic pages can look like
5 neumorphic example pages
Notable features
You get all Bootstrap components fully customized. Besides, you receive numerous plugins out of the box and ready to use
Latest Bootstrap
A responsive and mobile-first theme built with the world's most popular CSS framework
Build with Sass
Change one variable and the theme adapts. Colors, fonts, sizes, buttons... you name it
Responsive Design
Did you know 53% of the world web traffic is mobile? Neumorphism UI is fully responsive and mobile first
Modular approach
Nicely customized components that can be reused anytime and anywhere in your project
Gulp & BrowserSync
With our custom Gulp commands & BrowserSync we offer a seemless and fast workflow for your project
Well documented
Our kit is delivered with very detailed documentation, describing all components, styles and usages
Google PageSpeed
Neumorphism UI has 80+ scores on Google PageSpeed Insights to offer you and your clients a fast website
SVG illustrations
Photography and Illustration SVGs are included in the download package and are free to use
Neumorphic design
We crafted each component with great care so it represents the latest neumorphic design trend
What's inside?
We have carefully crafted the perfect folder structure to ensure that finding the files you're looking for are easily reachable and well organized.
You need only HTML, CSS and Javascript?
Don't worry, we got you covered. We have a folder called html&css
which includes only the basic HTML5, CSS3 and Javascript technologies.
- src
-
- assets
- html
- partials
- scss
- index.html
- html&css
- .temp
- dist
- node_modules
- gulpfile.js
- package.json
- README.md
- .gitignore
You need only HTML, CSS and Javascript?
Don't worry, we got you covered. We have a folder called html&css
which includes only the basic HTML5, CSS3 and Javascript technologies.
WCAG 2.1 accessible color scheme
We've enhanced the color settings
to comply with the latest accessibility standards
Primary:
#174F84Secondary:
#10AB7CInfo:
#1E90FFWarning:
#F5B759Success:
#00BF9ADanger:
#FA5252Dark:
#2A354FLess work, more flow.
Boost productivity with BrowserSync. SCSS changes are reflected instantly and pages scroll and refresh on devices as you work.
Open source project
Neumorphism UI is an open source UI Kit that is licensed under the MIT License. Consider giving us a star on the official Github repository to spread the news!
- 200 Components
- 5 Example Pages
- Uncoventional cards
- Timelines
- E-commerce
- Widgets
- Premium Support
- 1000+ Components
- 13 Example Pages
- Uncoventional cards
- Timelines
- E-commerce
- Widgets
- Premium Support


New wave
Open
Mark Read
Leave
Folderize
...
Inbox
Archive
Contacts
Folders
Options
...
New Wave
Shared Waves
Search
...


public enum WeatherSevereType extends java.lang.Enum<WeatherSevereType>
| Modifier and Type | Field and Description |
|---|---|
protected short |
value |
| Modifier and Type | Method and Description |
|---|---|
static WeatherSevereType |
getByValue(java.lang.Short value) |
static java.lang.String |
getStringFromValue(WeatherSevereType value)
Retrieves the String Representation of the Value
|
short |
getValue() |
static WeatherSevereType |
valueOf(java.lang.String name)
Returns the enum constant of this type with the specified name.
|
static WeatherSevereType[] |
values()
Returns an array containing the constants of this enum type, in
the order they are declared.
|
public static final WeatherSevereType UNSPECIFIED
public static final WeatherSevereType TORNADO
public static final WeatherSevereType TSUNAMI
public static final WeatherSevereType HURRICANE
public static final WeatherSevereType EXTREME_WIND
public static final WeatherSevereType TYPHOON
public static final WeatherSevereType INLAND_HURRICANE
public static final WeatherSevereType HURRICANE_FORCE_WIND
public static final WeatherSevereType WATERSPOUT
public static final WeatherSevereType SEVERE_THUNDERSTORM
public static final WeatherSevereType WRECKHOUSE_WINDS
public static final WeatherSevereType LES_SUETES_WIND
public static final WeatherSevereType AVALANCHE
public static final WeatherSevereType FLASH_FLOOD
public static final WeatherSevereType TROPICAL_STORM
public static final WeatherSevereType INLAND_TROPICAL_STORM
public static final WeatherSevereType BLIZZARD
public static final WeatherSevereType ICE_STORM
public static final WeatherSevereType FREEZING_RAIN
public static final WeatherSevereType DEBRIS_FLOW
public static final WeatherSevereType FLASH_FREEZE
public static final WeatherSevereType DUST_STORM
public static final WeatherSevereType HIGH_WIND
public static final WeatherSevereType WINTER_STORM
public static final WeatherSevereType HEAVY_FREEZING_SPRAY
public static final WeatherSevereType EXTREME_COLD
public static final WeatherSevereType WIND_CHILL
public static final WeatherSevereType COLD_WAVE
public static final WeatherSevereType HEAVY_SNOW_ALERT
public static final WeatherSevereType LAKE_EFFECT_BLOWING_SNOW
public static final WeatherSevereType SNOW_SQUALL
public static final WeatherSevereType LAKE_EFFECT_SNOW
public static final WeatherSevereType WINTER_WEATHER
public static final WeatherSevereType SLEET
public static final WeatherSevereType SNOWFALL
public static final WeatherSevereType SNOW_AND_BLOWING_SNOW
public static final WeatherSevereType BLOWING_SNOW
public static final WeatherSevereType SNOW_ALERT
public static final WeatherSevereType ARCTIC_OUTFLOW
public static final WeatherSevereType FREEZING_DRIZZLE
public static final WeatherSevereType STORM
public static final WeatherSevereType STORM_SURGE
public static final WeatherSevereType RAINFALL
public static final WeatherSevereType AREAL_FLOOD
public static final WeatherSevereType COASTAL_FLOOD
public static final WeatherSevereType LAKESHORE_FLOOD
public static final WeatherSevereType EXCESSIVE_HEAT
public static final WeatherSevereType HEAT
public static final WeatherSevereType WEATHER
public static final WeatherSevereType HIGH_HEAT_AND_HUMIDITY
public static final WeatherSevereType HUMIDEX_AND_HEALTH
public static final WeatherSevereType HUMIDEX
public static final WeatherSevereType GALE
public static final WeatherSevereType FREEZING_SPRAY
public static final WeatherSevereType SPECIAL_MARINE
public static final WeatherSevereType SQUALL
public static final WeatherSevereType STRONG_WIND
public static final WeatherSevereType LAKE_WIND
public static final WeatherSevereType MARINE_WEATHER
public static final WeatherSevereType WIND
public static final WeatherSevereType SMALL_CRAFT_HAZARDOUS_SEAS
public static final WeatherSevereType HAZARDOUS_SEAS
public static final WeatherSevereType SMALL_CRAFT
public static final WeatherSevereType SMALL_CRAFT_WINDS
public static final WeatherSevereType SMALL_CRAFT_ROUGH_BAR
public static final WeatherSevereType HIGH_WATER_LEVEL
public static final WeatherSevereType ASHFALL
public static final WeatherSevereType FREEZING_FOG
public static final WeatherSevereType DENSE_FOG
public static final WeatherSevereType DENSE_SMOKE
public static final WeatherSevereType BLOWING_DUST
public static final WeatherSevereType HARD_FREEZE
public static final WeatherSevereType FREEZE
public static final WeatherSevereType FROST
public static final WeatherSevereType FIRE_WEATHER
public static final WeatherSevereType FLOOD
public static final WeatherSevereType RIP_TIDE
public static final WeatherSevereType HIGH_SURF
public static final WeatherSevereType SMOG
public static final WeatherSevereType AIR_QUALITY
public static final WeatherSevereType BRISK_WIND
public static final WeatherSevereType AIR_STAGNATION
public static final WeatherSevereType LOW_WATER
public static final WeatherSevereType HYDROLOGICAL
public static final WeatherSevereType SPECIAL_WEATHER
public static final WeatherSevereType INVALID
public static WeatherSevereType[] values()
for (WeatherSevereType c : WeatherSevereType.values()) System.out.println(c);
public static WeatherSevereType valueOf(java.lang.String name)
name
- the name of the enum constant to be returned.java.lang.IllegalArgumentException
- if this enum type has no constant with the specified namejava.lang.NullPointerException
- if the argument is nullpublic static WeatherSevereType getByValue(java.lang.Short value)
public static java.lang.String getStringFromValue(WeatherSevereType value)
public short getValue()


--- title: "Network packet analysis – Part II: Practice" subtitle: "Capturing network traffic with Wireshark (with examples of HTTP, QUIC, TCP, TLS, and other packet captures)" permalink: "/network-packet-analysis-part2.html" date: "2022-09-20" lastupdate: "2022-09-26" ogimg: "og-network-packet-practice.jpg" ---
Wireshark is a cross-platform network capture and analysis tool that gives you insight into your network traffic, including a detailed breakdown of each data packet. It can be used for improving network and application performance, detecting security threats, troubleshooting networking issues, and more.
Unlike other network analysis tools, such as tcpdump, Wireshark has a graphical user interface that allows you to inspect network packets visually, without the use of a command line interface. This post looks into how packet capturing with Wireshark works in practice.
---If you are interested in the brief theory of network packet analysis, check out the first part of this article, too, which discusses TCP/IP layers, protocols, packets, and internet communication overall.
Packets in Wireshark are called frames. A frame is a pseudo-protocol developed by Wireshark that you can see at the top of each Wireshark capture — it's essentially the summary of all the underlying data managed by a set of communication protocols (e.g. total byte size, arrival time, frame number, etc.).
Network packets, overall, are not static entities. A Wireshark capture is the snapshot of one moment — when Wireshark recognizes the presence of the packet. However, the packet is built up gradually, and each protocol involved in the process adds data to it.
Wireshark can capture packets both exchanged with external servers via the internet and used within a local network.
Before getting started with packet capturing, you need to decide which of your network connections you want to capture. Wireshark lets you choose from wired, wireless, and Bluetooth connections:
Each network packet has a layered structure defined by the Internet Protocol Suite. A Wireshark capture is named after its top-level protocol, which can belong to the application (HTTP, TLS, DNS, etc.), transport (UDP, TCP, QUIC), or link layer (e.g. ARP) — for example, you can have HTTP, QUIC, DNS, TCP, and other captures.
Here's a screenshot of the overall look of the Wireshark UI and the breakdown of a DNS (Domain Name Server) query — the DNS conversation (request: Frame 10 and response: Frame 11) is colored in red:
In the top pane (Packet List), you can see the packets captured by Wireshark, the middle pane (Packet Details) shows the used protocol stack (Ethernet, IPv4, UDP, DNS), and the bottom pane (Packet Bytes) shows the canonical hex dump of the packet data.
The data encapsulated in the packet is added by four communication protocols — each belonging to a different TCP/IP layer.
For example, Frame 10 weighs 81 bytes in total, of which:
Wireshark is showing the number of bytes added by each protocol in the bottom-left corner of the UI as you're clicking through the protocols in the Packet Details pane.
Now, let's see some other examples of Wireshark captures of different protocol stacks, too.
As we're on an Ethernet connection, the link layer always uses the Ethernet protocol, and the internet layer is always handled by IPv4 on this connection.
The transport layer is either TCP or UDP — these are the two transport protocols that all operating systems and devices support. QUIC, which is a new transport protocol, runs on top of UDP and extends it with additional features — it can be thought of as a high-level transport protocol that includes performance and security features.
Application-layer data is delivered to the destination by either TCP or UDP — e.g. HTTP/1.1, HTTP/2, and TLS use TCP, while QUIC, DNS, and HTTP/3 use UDP for transport.
HTTP/1.1 uses TCP (Transmission Control Protocol) as transport protocol. The communication starts with TCP's (SYN, SYN-ACK, ACK) handshake that establishes the connection between the client and server. The client sends the first HTTP request (Frame 240) to the server immediately after the ACK packet (Frame 239).
On the screenshots below:
The TLS (Transport Layer Security) protocol is an application-layer security protocol used for encrypting data sent by other application-layer protocols such as HTTP, SMTP, and FTP.
When it encrypts HTTPS data (can be HTTP/1.1 or HTTP/2), it uses the TCP 443 port for the transfer. So, when you see a TLS packet in Wireshark that connects to the server's TCP 443 port, it hides either HTTP/1.1 or HTTP/2 data that you can't see by default — to read the encrypted data you need to decrypt the TLS packet (for which, you'll need the appropriate session keys).
TLS currently has two versions in use: TLS v1.2 and TLS v1.3 — the newer version coming with significant performance and security improvements.
First, let's see what the TLS v1.2 handshake looks like in Wireshark.
The TLS handshake starts immediately after the TCP handshake successfully finishes and the TCP socket between the client and the server is opened. The authentication process takes two full round-trips (one trip can include more than one frame — see how packet reassembly works in Wireshark).
The client can send the first application-layer HTTP request (Frame 6113) only after the third round-trip (one for the TCP handshake, two for the TLS v1.2 handshake).
See the detailed breakdown of the TLS v1.2 handshake on TheSecMaster.
In TLS v1.3, the TLS handshake requires fewer messages between the client and server — it only takes one round-trip.
As you can see below, the client immediately sends the first HTTP request (Frame 340) once the 'Server Hello' message and the cipher spec and other server data arrive and the server starts encrypting the data (Frame 339).
See the detailed breakdown of the TLS v1.3 handshake on TheSecMaster.
TLS v1.3 also has a 0-RTT (Zero Round-Trip Time or 'early data') feature that allows the client to send an HTTP request on the first flight on connections it has previously established with the server.
QUIC is a new-ish communication protocol (standardized in 2021, but it's already widely used) that runs on top of UDP and serves as the transport-layer protocol for HTTP/3 (+ some new application-layer protocols also use QUIC).
As QUIC includes the TLS v1.3 security protocol, it can be used to set up a fully encrypted 0-RTT connection between the client and server (QUIC encrypts more data than TLS v1.3).
Data sent with QUIC is always encrypted. If it uses the server's UDP 443 port for the connection and you see the 'Protected Payload' info in Wireshark, then it hides HTTP/3 application data — to read its contents, you need to decrypt the packet in Wireshark using the belonging cryptographic session keys.
Here are the details of the UDP header belonging to Frame 126 above. As you can see, the header is just 8 bytes: 2 bytes for the source port data in hex dump format (d8 e1), 2 bytes for the destination port (01 bb), 2 bytes for the length (05 55), and 2 bytes for the checksum (f4 39).
It transports a protected QUIC payload of 1357 bytes in total, split into three parts. This is because it's the first frame in the stream that includes different types of data — you can see the details if you expand each part in the Packet Details pane. However, most frames transport the QUIC payload in one part.
This two-part article was a very brief intro to the theory and practice of network packet analysis and communication protocols.
It discussed:
To learn more about the subject, here are some useful resources too:


CHASING AMY A film review by Bradley Null Copyright 1997 Bradley Null
. The intro sequence of Chasing Amy, comic book frames of oddly familiar characters, informs us immediately that we are entering the world of Kevin Smith. That world is one over-populated with comic book fanatics, philosophical drug dealers, and ambitionless twenty-somethings. To Smith, the film's director, that world is New Jersey.
Like characters found in other recent Gen X movies, Smith's heroes are unjustifiably hip. n Chasing Amy there are two groups of characters, Jersey boys afraid of the city, and fixtures of the NYC underground. But regardless of background, every character in Chasing Amy is poised with a witty remark or comical/philosophical riff on love or life. Smith even highlights the (self)-importance of his protagonist, played by Ben Affleck, by unabashedly naming him after the coolest literary character of the twentieth century, Holden Caulfield.
Going well beyond other Gen X movies such as Swingers and Reality Bites, Chasing Amy embraces the new generation with an unparalleled frankness. Although this boy-meets-lesbian love story is more mature than Smith's earlier work, its never before seen subject matter is indicative of Smith's predilection for ignoring the taboos of film. Frank discussions of sex and perversion are common in Smith's world of wordy, quick-paced diatribes long on profanity. Smith tackles this material with characters and situations that come across, despite their wit, as strikingly awkward and realistic.  Their attempts to riff on their problems en route to solving them display a realistic ineptitude in dealing with serious problems. Either the characters have too much to say or nothing at all, but in all cases the outcome of these slipshod attempts is bad. Although the intermittent stupidity and vulgarity of Smith's characters is sometimes painful to watch, the film's refreshing realism is an invaluable experience.
Despite this powerful subtext, Smith's world is not devoid of humor. Though self-absorbed, all of Smith's characters are quite amusing, and the plot development, camera work, and editing in Chasing Amy capitalize on the humor in every situation.  Smith's hand-held camera and static long takes also serve to focus action within the frame and on the borders, which he uses for comical and emotional effect.
In all cases, Smith's awkward situations, for both the characters and audience, play off of traditional film structure in which everything fits together seamlessly. In Smith's world, you can count on only one thing: when Silent Bob (played by Smith himself) finally speaks (and he will) he is going to say something profound.

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


Let me be the guidance to your Future.
Error:
You can now make new friends. Enter the Chat Room . Help other students. Share your college experiences and expand the knowledge.


utils.js |
|
'use strict';
|
|
|
Lazily-required module dependencies (makes the application faster) |
var utils = require('lazy-cache')(require);
|
|
Temporarily re-assign This tiny bit of ugliness has the huge dual advantage of only loading modules that are actually called at some point in the lifecycle of the application, whilst also allowing browserify and webpack to find modules that are depended on but never actually called. |
var fn = require;
require = utils;
|
|
Lazily required module dependencies |
require('align-text', 'align');
|
|
Restore |
require = fn;
|
|
Expose |
module.exports = utils;
|


This example shows how to use the replace()
function with a callback allowing you to implement complex functionality into a replacement. Here words of a certain length are replaced with different words of the same length. Capitalization is also changed.


Working With Legacy Code
based on
Working Effectively with Legacy Code - By Michael Feathers
Contributors
Dan Persa
/
@danpersa
Add your name with your first pull request
/
@twitter


Interface collections.UpdatableMap
All Packages Class Hierarchy This Package Previous Next Index
Interface collections.UpdatableMap
- public interface UpdatableMap
- extends Object
- extends UpdatableCollection, Map
UpdatableMap supports standard update operations on maps.
-
putAt(Object, Object)
- Include the indicated pair in the Map
If a different pair
with the same key was previously held, it is replaced by the
new pair.
-
removeAt(Object)
- Remove the pair with the given key
-
replaceElement(Object, Object, Object)
- Replace old pair with new pair with same key.
putAt
public abstract void putAt(Object key,
Object element) throws IllegalElementException
- Include the indicated pair in the Map
If a different pair
with the same key was previously held, it is replaced by the
new pair.
- Parameters:
- key - the key for element to include
- element - the element to include
- Returns:
- condition:
includes(key, element) &&
no spurious effects &&
Version change iff !PREV(this).includesAt(key, element))
removeAt
public abstract void removeAt(Object key)
- Remove the pair with the given key
- Parameters:
- key - the key
- Returns:
- condition:
!includesKey(key)
foreach (k in keys()) at(k).equals(PREV(this).at(k)) &&
foreach (k in PREV(this).keys()) (!k.equals(key)) --> at(k).equals(PREV(this).at(k))
(version() != PREV(this).version()) ==
includesKey(key) != PREV(this).includesKey(key))
replaceElement
public abstract void replaceElement(Object key,
Object oldElement,
Object newElement) throws IllegalElementException
- Replace old pair with new pair with same key.
No effect if pair not held. (This includes the case of
having no effect if the key exists but is bound to a different value.)
- Parameters:
- key - the key for the pair to remove
- oldElement - the existing element
- newElement - the value to replace it with
- Returns:
- condition:
!includesAt(key, oldElement) || includesAt(key, newElement);
no spurious effects &&
Version change iff PREV(this).includesAt(key, oldElement))
All Packages Class Hierarchy This Package Previous Next Index


3. Houses in multiple occupation
Find out if a property is classed as a house in multiple occupation (HMO) for council tax purposes, who is responsible for paying the bill and whether any discounts or exemptions apply.
Definition of a HMO for council tax purposes
A property is classed as a house in multiple occupation for council tax purposes if it meets one of the following conditions:
- the tenant rents a room and has use of a shared kitchen and possibly shared bathroom
- the tenants are renting the whole house together but each tenant has their own tenancy agreement and pays only their own rent
- the property was constructed, or subsequently adapted, for occupation by people who do not constitute a single household, for example a house turned into bedsits with a shared kitchen and locks on the bedroom doors


Java
This beginner Python project is perfect for testing for correct variable usage and concatenation. In Python, the variable usage only ever matters if it is paired with a different datatype. For example, one would need to include a str(int) if one wanted to integrate an integer into a string. This idea is basically concatenation. Other examples of converting variables include float() and int(). For this specific example, it requires the student to create a function with no parameter (and to call this function). Identifiable variable names are given in order to practice good habits. The input's refer to the named variables and in turn these variables are then concatenated with other pieces of string. The "\n" is meant to indicate a line break.
I implore you that you should understand class structures and it's concepts before exploring the rest of this explanation. Though originally this project was not intended to be designed with a class and objects, I nonetheless did it. To explain this version, I simply first created a class called Question. I then created a constructor (def __init__) with the parameters: self, prompt, answer. The self parameter is given by default. Like any conventional constructor, I set self.prompt = prompt and self.answer = answer. Afterwards, I created a list with a few strings that include the questions and the answer choices. To supply the program with answers to these questions, I created a second list that holds the an object that includes the question (i.e. question_prompts[0]) and the correct answer as a letter (i.e. "d"). I then created a function called run_quiz(questions) which only takes one parameter "questions" whereas as of now, it is merely a variable to label the parameter. I created a variable called "score" and I set it to 0. Afterwards, I created a for loop that selects the items inside the list called "questions" where the items being selected are given the temporary variable called "question". The variable "answer" is set to the an input statement where the program prompts you with question.prompt which is basically a notation that python uses to access the attributes in an object. Notice that the for loop penetrates through the first layer of the "questions" list. so that the variable "question" represents the "Question(question_prompts[0], "d"...etc)". Then since "question" is set to each one of the list items in "questions", one can then use question.prompt in class notation to access the specific question listed in the other list: question_prompts. The if statement inside the for loop is meant to count the amount of times your inputted answer matches the question.answer which is the lowercase letter within "Question(question_prompts[0], "d")". If it does match, the score is increased by 1. After the for loop ends, I used simple string concatenation to display how many questions you answered correctly out of the total number of questions. Finally, I ran the function with the variabl "questions" to fill in as the parameter.
This simple program allows one to find all the factors of a number. I began with a function called factorials with a parameter of x. I then created an empty list called factor_list which we would append all the numbers that evenly divide into the inputted number. I created a for loop which sets the variable value to a number within the range of the inputted number + 1, to 0 (not including 0), and it decreases by 1 (hence the -1). I created an if statement inside the for loop that has a condition that if the inputted value (x) is evenly divided by the value within the specified range (hence the modulos % which calculates the remainder after division so if set to 0 it would be evenly divided), then it would set that evenly divided number to "y" and it would then be appended to the empty list called factor_list. After the for loop, the list would be printed out. Lastly, I called the function with an integer-based input that prompts the use to enter an integer number. This integer number would of course be passed into the function set to the variable "x".
This simple game is complicated in Python. I first had to import sys and random in order to generate some random choices from the computer. user1_answer is the input the player gets where they are prompted to choose rock, paper or scissors. I created another list that has 3 items that has the exact strings of "rock", "paper", and "scissors". user2_answer is the computer generated answer where I used the random module to randomly select a choice from the specified list. I then printed the user2_answer knowing full well that the player has already inputted his/her choice. I created a function that takes 2 parameters: u1, and u2. I then began the tedious process of using the conditional if statement to figure out each possibility and return a string that tells who won. Lastly, I printed while calling the compare function with user1_answer and user2_answer as the parameters.
This simple reverse function takes no parameters and is merely just called. I created a variable string that refers to the user input string. I created an empty string to house the end product. Afterwards, I created a for loop where letter refers to the position of each letter in the inputted string. I subtracted 1 because the length counts all the letter starting from 1. It continues to -1 where it does not include -1 meaning it ends at the 0 value which is crucial when talking about counting in Python where most things begin at 0. The last -1 is meant to specify the intervals at which it decreases which is 1. Within the for loop, I appended the each letter of the inputted string into another_string however since the range goes from the last position to the first, it reverses the entire string. Lastly, I printed the reversed string.
Though this function does look complicated it is merely just a concoction of many variables and if statements. The random module is imported to provide a random number. The function play_agains is empty and is merely just called. I created the variable random_generated_number which converts a random number from the range 1 to 101 (not including 101) to an integer. I prepared a few variables like user_guess and guesses to initially have virtually nothing. I created a while loop that each time it loops it adds 1 to the guesses variable where it cannot surpass 7 meaning there are 7 attempts (guesses begins at 0). I printed the random_gemerated_number as to serve as a value to test if the program is running properly. I prompt the user for a guess between 1 and 100 and I set this variable to user_guess. I then continued with a set of conditional statements that prints out whether the person guessed too low, too high, or they got it right. After the statement, I included guesses_left to inform the user of how many guesses they have left. Outside of the for loop, I also included this to tell how many guesses the user had left at the end of the guessing game. I then created another simple if statement that asks the user if they want to play again. If the inputted answer to this conditional statement is "no", then it would end, if it was "yes", then it would call itself to repeat the entire process with a new randomly generated number.
This project is similar to the last where it involves guessing a number. However, this one involves the computer guessing the user's number which is never inputted in. This method is similar to binary searching where the computer continually divides the appropriate range in half until it narrows down to only your number. In the meantime, you give the computer clues by telling it if it is too high or too low in order to appropriately narrow down the range. In this project, the computer begins with guessing 50 and if it was told that it was too low, then it would set the start value to the guessed number (50). Whereas, if it was told that it was too high, then the end value would be set to computer number. This repeats until it either correctly guesses your number or the user fails to provide the computer with clues. I created another if statement where it tells the user whether the computer won or lost and if the user wants to play again, similar to the previous project.
Java is much more complicated in terms of syntax than Python. To begin with,
the imports are jaw-dropping. One must use the extension, ".awt", to access java's
package called Abstract Window Toolkit. It allows for a programmer to create images on
a window. We begin by importing Color and Graphics. We then import Graphics2D, Rectangle, and the sub-extension ".geom"
to access Ellipse2D and Line2D to create more specific ellipses and lines. Finally,
for the imports, we import "javax.swing.JComponent".JComponent, in summary, is an abstract class
that provides greater functionality like the ".awt" extension. The second image depicts the 2 classes
needed for this project which are FaceComponent and FaceViewer. We begin with a normal public class
called FaceComponent which extends the JComponent abstract class to provide extra functionality.
We then include a method called paintComponent which is essential that it is typed exactly like this. It
takes an object from the Graphics class and this variable is called g in this case. As the picture describes,
we need to recover the Graphics2D. (Graphics2D) g must be typed this exact way whereas the "g2" can be anything
because it is a variable. Next, we create a few new color combinations and store them in a variables greyPink and
darkGreen which is self-explanatory. We then take g2 and set its color to pink which is one of many default colors.
We create an ellipse next. Note that teh ".Double" extension is meant to give specified instructions as to the location
of your drawn ellipse. This ellipse is stored in the variable called head1. Also note that the parameters within the
parentheses specifies in this specific order: (x position, y position, width, length). After setting the color, when you
draw the ellipse, it will only show that ellipse with an outlined color. To fix this problem, one can just simply do
"g2.fill(head1);". This process is repeated for 2 more ellipses, then the mouth is created by using the Line2D.Double in the
same sense where you specify (x start position, y start position, x end position, y end position). Lastly, one can finish with
"g2.drawString();" to insert a message where the numbered arguments specify the position of where the string begins.
The second class includes the imported package called JFrame from ".swing". JFrame is basically a container that holds buttons,
textfields, and whatnot to create a user interface. I created a new JFrame(); and gave it the variable name of "frame".
The next few commands like ".setSize();" and ".setTitle();" set the size of the window by width and height and give the window a title.
The ".setDefaultCloseOperator(JFrame.EXIT_ON_CLOSE);" allows the user to specify a method to close the window. Then, the FaceComponent class
is called and it is added via the ".add();" function to the JFrame. Lastly, the visibility is set to true to ensure that it is able to be seen.
This project focuses on the java.util.Scanner which allows for the user to input datatypes into the program. A standard class is created. We create a new Scanner by doing "Scanner anyVariableHere = new Scanner(System.in);". Afterwards, we print out something that prompts the user for an input. We follow this prompt with an anyVariableHere.nextdataType();. Then, this can be set to a variable in case the programmer wants to manipulate the user input. For example, ".nextInt();" specifies an expected integer, while ".nextLine();" specifies an expected String, and ".nextDouble();" specifies an expected double (otherwise a float in Python). We finally finish with printing format which is specified by "printf". The programmer can include %n where n can any specified format on the format page here. Then, there is a comma followed by variables that correspond in order and in format to the %n's.
This one is similar to the previous one except this time the programmer must calculate a few certain numbers. This, of course, is easily done with arithmetic operators. However, to calculate the minimum, maximum, and the absolute value would require either more programming or a new package. The java.lang.Math package allows us to calculate the minimum, maxmimum, and absolute value.
This one is fairly standard with a scanner. However, this program requires a conditional statement that tests if the inputted number is evenly divisible by 2 or not to determine whether the number is even or odd. Like in Python, this can be done with the "%" sign.
This program, initially, looks like a mess and in a way, it is. To cover the general premise of this function, I encased the entire program in a while loop that continues to loop while the String "playAgain" is equal to "yes". At the end of the program, I have a set of conditional statements that asks the user if they want to play again which prompts them for a "yes or no" answer which decides if the while loop will loop once again. I created a variable that accessed the Random class and I generated a random number from 0 to 3 (not including 3). This number is then ran through a conditional statement which decides whether it is a rock (R), paper (P), or scissors (S). I then have another set of conditional statements to test all the possibilities and I had the system print out which side won. One important thing to note for this project is that, unlike Python, in Java one must do ".equals()" to test if a variable is equal to the given string.
This short practice describes 3 different types of loops. The first loop is a standard while loop that begins with the integer "i", and it increases at increments of 1 smybolized by the "i++" where when it reaches 4, the loop will stop running and printing our the current number. The second loop is similar except it begins with "do" and ends in while. In summary, this loop is going to execute the command at least once before checking the "while" condition. The last example is a standard loop where the for loop requires 3 statements: the first being defining the interval integer, the second being the condition, and the last being the increments at which it increases.
We begin by importing java.util.Scanner because we want the user to prompt for a certain number. After creating the standard classes, I created a nested for loop. Now, a nested for loop, loops through the outer loop once but it specifies how many times the inner loop loops through for each one loop of the outer loop. I prepared a variable called "i" and began at 1 because the default would be 0 instead. I created a condition so that "i" would go up to the inputted "number" variable. And for every one loop of the outer loop, the inner loop with a locally defined variable "j", will loop as many times up to the numerical value of the variable "i". And for each loop of the inner loop, it will print out "i". THus it will print out the a certain number with that number's number of iterations (designated on the same line by the "System.out.print" and the "System.out.println" outside of the inner loop but inside of the outer loop).
For this project, I began with 2 standard imports so I can prompt the user for an input and also apply some math functions. I prompted the user for an integer number and I stored it in a variable called "number". Then I prepared 3 integer variables for 3 separate while loops. Each while loop begins by looping through until it reaches the number - 1. Each while loop has an if statement to test each number to see if it is adequate for the condition whether the condition is if it's a perfect square, if it's divisible by 10, or if it's two to the power to a certain number while being under the variable "number" value. A few notable things include that (int) will check if the value is an integer and System.out.print will print things on the same line instead of System.out.println where it enters the next line after a print.
I began by importing the scanner like normal and ArrayList which will basically create a list like in Python. I prompted for the viewer to input a number to go up to and I created an empty array for integers. I looped from the beginningValue of 1 all the way up to the actual inputted number and appended each value that was a perfect factor to the empty array. I then created another loop that would loop through all the numbers in the list of factors except for the actual number itself and summed all of them up. I finished with an if statement that would gauge whether the inputted number would be a perfect, deficient, or an abundant number.
This final project along with the conversion final project were both relatively simplistic in nature. This one utilized basic tools from the java.lang.Math package and also the java.util.Scanner package. Simple and fundamental math equations were applied to user inputs to ultimately determine the area of a triangle along with other constituents of it (i.e. distances, degrees of each angle, and perimeter, etc). Notable about this final project was that I had to convert the radians to degrees and that I used the sine triangle formula instead of the tradition one because the traditional one would be a bit more complicated.
This final project demanded conversions. This simple project only needed a few dozen conditional statements to satiate the prompt.
This Roman Numeral final project asked for a few dozen while loops that would continuously loop through the inputted number until it has satiated all while loops where it will begin to concatenate the letters together to ultimately form the roman numeral form of the inputted numeric number. What made this project a tad special was that the user input would have a specified amount subtracted every time it iterates through a loop and it would add to a preexisting string.
This project is fairly straightforward. Besides taking a normal specified input, one has to create a few integers that stored specific values (i.e. string length, beginning substring value, and ending substring value). Because this assignment goes from 1000 to 999999, there will only ever be 1 comma which clarifies why the if statement has a "- 3". The inner portion of the if statement stipulates where the comma will be in accordance to how long the string is. The project is finally concluded with a print statement and concatenation.
The program is fairly standard with a prompted input and a few variables for the actual nested loops. The outer while loop loops until the wordLength is 1 (not 0), and each iteration through the loop, the wordLength integer will have one deducted from it and the inner while loop will run a specified amount of times. For each loop through the outer loop, the inner loop will continuously run until the variable "i" is less than the variable "wordLength". Within the nested while loops, there is a print statement that prints out the substring of the inputted string. For example, the first iteration through, the print statement will print substrings (0, 1), (1, 2), (2, 3). This will loop until the end of the string is reached. To visualize this, the function is scanning through the string and each time it scans through, it changes its interval.
This project began with a straightforward integer array and an empty array with a length of 10. For each iteration
through the loop "i" increases by 1. The loop itself is just looping 10 times with no concern for the actual array
values and indexes itself. I then added an if statement such that the intArrayLength value will never be out of bounds
(though I believe it might be unnecessary). I then proceeded to create a random integer from 0 to 9 (inclusive). This
random integer value would then be searched in the array and the value in the array would be stored into the variable
"anotherValue". "anotherValue" is then appended to the empty second array and the last value would be stored in a
temporary variable. Then, the next two lines would swap the 2 values (the value chosen with the last value of the
array). Lastly, the finished array is printed.
The arrayList version is the exact same however this time, you can actually remove items out of the array, giving
much more leeway for the project.
This java project is not mine, rather, the credit goes to Sean Phun for sharing the code, which I'm grateful for as he has helped me on a number of other occasions. The code begins with a simple for loop that adds a bunch of random values from 1 to 6 inclusive to the array. A second loop is created to check 2 conditions: if one value is equal to the one to right of it and if it is not (else). If the conditional statement is true, then it will loop continuously until it proves to be false, in which case, it will print the ending parentheses. The else part of this conditional statement is that if it doesn't satisfy the first condition, then it will just print out the values normally. Notice how there is only 1 value being incremented and it is incremented twice throughout the entire project. That is because the second "x++;" only pertains to the while loop while the other outside of that loop.
Similar to the last one, this one has a slight variation. The innermost while loop has an if statement that checks a periodically incremented variable that is created outside the innermost while loop and inside the conditional statement that checks if one value is equal to the next value. This variable is then counting the amount of times the innermost while loop iterates. If there are 5 intervals then it will increment a counter variable that is outside of the outer while loop. This first counter variable counts how many strings of 6's or 7's or 8's (etc). This means that my first counter variable can be more than 1 or 2 since it will not break after finding a single string of adjacent 6's. Outside of the outer while loop (which loops through the 100 items of each array), the loop is surrounded by a larger for loop that iterates 10,000 times with a second array counter. This second array counter is incremented inside the largest for loop but outside the outer most while loop. It is incremented only if the first counter variable is greater than or equal to 1 meaning it will only increment if there is at least 1 string of 6 or more. Lastly, I printed out this final counter for the predicted probability to be 54-55 percent.
I firstly began by prompting the user for how many desired inputs they wanted and these inputs are facilitated by the next 2 following for loops where 2 empty arraylists (one for strings and one for integers) are filled accordingly to the user input. My next 2 for loops are to find the string (in the string array) with the greatest length and to find the integer (in the integer array) with the greatest numerical value. I also, and this is important, found the absolute value of the utmost minimum value in the integer array. I followed that with an enormous if statement that checks if the minimum value (with no absolute value applied to it) is greater than (the else statement) or less than zero (the if statement). To begin with, if the minimum value is greater than zero then the program will simply loop through the entirety of the integer array, set the value in the integer array (source) to the variable "arrayValue". It will then print the specified word you inputted as the user, and then find the difference in length between the longest word and the shortest word current word. Given this difference, it will loop through the following loop a specified amount of times (such that all the words would line up). I then printed a vertical slash to indicate that all the empty spaces and difference in length have been accomodated for. I then loop through another for loop that prints the appropriate amount of asterisks. The if statement, on the other hand, is a bit more complicated. I perform similarly as in the else statement, but I also calculate the difference between the absolute value of the minimum and the current integer in the "source" integer array. The following loop accomodates for differences in word length. Then, the succeeding if statement checks if the current integer value is above or below zero. If the current "arrayValue" is greater than zero (the else if statement), it will loop until it has accomodated for the difference in numerical value for the integers (such that the current value will accomodate for the negative spaces provided by the negative integer). Then it will simply print the vertical slash and the appropriate number of asterisks. However, if the current "arrayValue" is below zero, the 2 for loops would not only accomodate for the negative integer but also for the discrepancy in length such that the vertical slashes would all be vertically aligned.
This project is similar to the last one except that the numbers for the height do not change, only the inputted desired height changes. The do while loop prompts the user until the user inputs a number between 1 and 8 inclusive. Everything else is the same as before and you accomodate for the difference in spaces by taking the difference between the largest value and the current looped value.
This project is straight forward. I used a substring to count letters, the trim method to count words and a simple
if statement to count sentences (though all of these are fairly inaccurate). Then I calculated the Colemann-Liau Index
to assign a certain grade level to the text. Here is the sample text:
It was a bright cold day in April, and the clocks
were striking thirteen. Winston Smith, his chin nuzzled into his breast in an effort to escape the vile wind, slipped quickly
through the glass doors of Victory Mansions, though not quickly enough to prevent a swirl of gritty dust from entering along with him.
This projects only difficulty is that you must locate the ASCII numbers of each letter and check if they are in uppercase or lowercase. The rest is straightforward by shifting the letters in the given string a certain number of shifts.


A MIDI output device.
For a list of all members of this type, see OutputDevice Members .
System.Object
DeviceBase
OutputDevice
This type is safe for multithreaded operations.
Each instance of this class describes a MIDI output device installed on the system. You cannot create your own instances, but instead must go through the InstalledDevices property to find which devices are available. You may wish to examine the Name property of each one and present the user with a choice of which device to use.
Open an output device with Open and close it with Close. While it is open, you may send MIDI messages with functions such as SendNoteOn, SendNoteOff and SendProgramChange. All notes may be silenced on the device by calling SilenceAllNotes.
Note that the above methods send their messages immediately. If you wish to arrange for a message to be sent at a specific future time, you'll need to instantiate some subclass of Message (eg NoteOnMessage) and then pass it to Clock.Schedule.
Namespace: Midi
Assembly: Midi (in Midi.dll)
OutputDevice Members | Midi Namespace | Clock | InputDevice


NumericalSgps
GAP
packageWe load NumericalSgps
with LoadPackage("numericalsgps");
. When pressing the "run" button, be patient, binder may take some time to start.
gap> LoadPackage("num");
We start by defining a numerical semigroup. There are many ways to do this depending on the information we have about it. If we know a system of generators, then we can do the following. We will store the semigroup in a variable called s.
gap> s:=NumericalSemigroup(3,5,7);
Indeed, \(\{3,5,7\}\) is a minimal generating set for s.
gap> MinimalGenerators(s);
Membership can be detected with in:
gap> 1 in s; gap> 100 in s;
The set of sporadic elements (elements up to the conductor, or small elements) of the semigroup are
gap> SmallElements(s); gap> Conductor(s); gap> FrobeniusNumber(s);
This is also showing us the sets of gaps of s
gap> Gaps(s); gap> Genus(s);
Recall that from the Apéry sets, one can retreive all this information.
gap> AperyList(s);
If only the semigroup is given as argument, then the Apéry set is computed with respect to the multiplicity. Note that the output is a list, in the $i$th position we find the smallest element in s congruent with $i$ modulo the multiplicity (or the given element we specify as second argument).
gap> AperyList(s,10);
It is well know that if the second argument is in the semigroup, then the output will have length precisely this argument. It not, the we get some extra elements.
gap> AperyList(s,6);
The set of pseudo-Frobenius numbers can be computed as follows.
gap> PseudoFrobeniusOfNumericalSemigroup(s); gap> Type(s);
Let us for instance check that Wilf's conjecture holds for all numerical semigroups with conductor equal to 20 (and thus Frobenius number 19).
gap> ForAll(NumericalSemigroupsWithFrobeniusNumber(19), > s->20<=EmbeddingDimension(s)*(Length(SmallElements(s))-1)); true
We are substracting one to the number of small elements since we consider the conductor as small element.
The special gaps (those that can be use to extend the semigroup to another numerical semigroup) are
gap> SpecialGaps(s); [ 4 ] gap> t:=AddSpecialGapOfNumericalSemigroup(4,s);And the set of all oversemigroups:gap> SmallElements(t); [ 0, 3 ]
gap> OverSemigroupsNumericalSemigroup(s); gap> List(last,MinimalGenerators);
The set of fundamental gaps, is computed as follows. We can use fundamental gaps to define semigroups.
gap> FundamentalGaps(s); gap> NumericalSemigroupByFundamentalGaps([4])=s;
As we can do with small elements and gaps.
gap> NumericalSemigroupByGaps(Gaps(s))=s; true gap> NumericalSemigroupBySmallElements(SmallElements(s))=s; true
Our semigroup example `s` is not symmetric, but it is pseudo-symmetric.
gap> IsIrreducible(s); true gap> IsSymmetric(s); false
Symmetric numerical semigroups have type one, whole pseudo-symmetric have type equal to two.
gap> List(IrreducibleNumericalSemigroupsWithFrobeniusNumber(19), > MinimalGenerators);
Every numerical semigroup can be expressed (though not uniquely) as the intersection of irreducible numerical semigroups.
gap> t:=NumericalSemigroup(10,11,12,13); gap> List(DecomposeIntoIrreducibles(t),MinimalGenerators);
We can actually find all oversemigroups of `t` that are irreducible.
gap> o:=OverSemigroupsNumericalSemigroup(t);; gap> oi:=Filtered(o,IsIrreducible);; gap> Length(oi); 35 gap> t=Intersection(oi); true
There are some special families of symmetric numerical semigroups, as complete intersections, free, telescopic, ...
gap> s:=NumericalSemigroup(4,6,9); gap> IsFree(s); true gap> lf:=FreeNumericalSemigroupsWithFrobeniusNumber(19);; gap> List(lf,MinimalGenerators);
We can construct almost symmetric numerical semigruops from irreducible numerical semigroups by removing some of its elements.
gap> AlmostSymmetricNumericalSemigroupsFromIrreducible(s); gap> List(last,MinimalGenerators);
Actually, one can compute with this idea the set of all almost symmetric numerical semigroups with given Frobenius number.
gap> t:=First(AlmostSymmetricNumericalSemigroupsWithFrobeniusNumber(19), > s->not(IsIrreducible(s))); gap> MinimalGenerators(t); gap> Genus(t)=(FrobeniusNumber(t)+Type(t))/2;
An ideal of a numerical semigroup can be defined by means of a generating system.
gap> s:=NumericalSemigroup(6,9,20); gap> i:=[2,3]+s; gap> MinimalGenerators(i);
The above ideal is not included in its ambient semigroup, and so it is not integral.
gap> IsIntegral(i); gap> AmbientNumericalSemigroupOfIdeal(i);
We can check membership with in.
gap> 8 in s; false gap> 8 in i; true
Ideals also have conductors, since they are unions of translations of numerical semigroups.
gap> Conductor(i); gap> SmallElements(i);
The basic operations include intersection, sum, addition, translations and difference.
gap> j:=10+s; gap> i+j; gap> MinimalGenerators(i+j); gap> MinimalGenerators(10+i); gap> Difference(i,j); gap> MinimalGenerators(Intersection(i,j));
The colon operation of ideals of rings translates in ideals of numerical semigroups to \(I-J=\{z\in \mathbb{Z} \mid z+J\subseteq I\}\).
gap> MinimalGenerators(i-j);
There are a couple of special ideals, one is the maximal ideal and the other the canonical (unique up to translations).
gap> m:=MaximalIdealOfNumericalSemigroup(s); gap> c:=CanonicalIdealOfNumericalSemigroup(s); gap> c-(c-i)=i; gap> MinimalGenerators(m); gap> MinimalGenerators(c); gap> IsCanonicalIdeal(10+c);
The blow up of an ideal $I$ of a numerical semigroup \(S\) is defined as \(\bigcup_{n\in \mathbb{N}}(nI-nI)\).
gap> MinimalGenerators(BlowUpIdealOfNumericalSemigroup(i)); gap> List([1..10], n->HilbertFunctionOfIdealOfNumericalSemigroup(n,i));
If the ideal is the maximal ideal, then it coincides with the Lipman semigroup of \(S\).
gap> MinimalGenerators(BlowUpOfNumericalSemigroup(s)); gap> LipmanSemigroup(s); gap> MinimalGenerators(last);
One can keep computing Lipman semigroups until we reach \(\mathbb{N}\), and the multiplicities of these semigroups conform the multiplicity sequence of \(S\)
gap> MultiplicitySequenceOfNumericalSemigroup(s);
gap> s:=NumericalSemigroup(6,9,20); gap> FactorizationsElementWRTNumericalSemigroup(36,s);
And the set of \(\mathcal{R}\)-classes as
gap> RClassesOfSetOfFactorizations(last);
The set of Betti elements is
gap> BettiElementsOfNumericalSemigroup(s);
And a minimal presentation is obtained with
gap> MinimalPresentationOfNumericalSemigroup(s);Recall that we can produce this also by using elimination.
gap> x:=Indeterminate(Rationals,"x");; gap> y:=Indeterminate(Rationals,"y");; gap> z:=Indeterminate(Rationals,"z");; gap> t:=Indeterminate(Rationals,"t");; gap> R:=PolynomialRing(Rationals,[x,y,z,t]); gap> i:=Ideal(R,[x-t^6,y-t^9,z-t^20]); gap> GroebnerBasis(i,EliminationOrdering([t]));The graph $G_n$ can be calculated in the following way.
gap> GraphAssociatedToElementInNumericalSemigroup(60,s);In this example, it has three vertices and a single edge. We can also calculate the shaded set of an element.
gap> ShadedSetOfElementInNumericalSemigroup(60,s);The Hilbert series (or generating function of $S$) is computed via the polynomial associated to $S$.
gap> HilbertSeriesOfNumericalSemigroup(s,x); gap> NumericalSemigroupPolynomial(s,x);Actually, this polynomial has all its roots in the unit circle.
gap> IsKroneckerPolynomial(last);
gap> LengthsOfFactorizationsElementWRTNumericalSemigroup(100,s);
gap> ElasticityOfFactorizationsElementWRTNumericalSemigroup(100,s); gap> ElasticityOfNumericalSemigroup(s);
gap> DeltaSetOfFactorizationsElementWRTNumericalSemigroup(100,s);Or even of the whole semigroups
gap> DeltaSetOfNumericalSemigroup(s);Recall that the maximum is reached in the Betti elements of the semigroup.
gap> List(B,b->DeltaSetOfFactorizationsElementWRTNumericalSemigroup(b,s));
gap> List(B, b->CatenaryDegreeOfElementInNumericalSemigroup(b,s)); gap> CatenaryDegreeOfNumericalSemigroup(s);
gap> OmegaPrimalityOfElementInNumericalSemigroup(100,s); gap> OmegaPrimalityOfNumericalSemigroup(s);Because for the atoms we obtain
gap> A:=MinimalGenerators(s); gap> List(A, a->OmegaPrimalityOfElementInNumericalSemigroup(a,s));
gap> TameDegreeOfElementInNumericalSemigroup(100,s); gap> TameDegreeOfNumericalSemigroup(s); gap> l:=Intersection(s,[1..100]); gap> List(l,x->TameDegreeOfElementInNumericalSemigroup(x,s));
gap> l:=List([1..20], _->RandomNumericalSemigroup(5,500));; gap> ll:=Filtered(l, s->EmbeddingDimension(s)=4);; gap> Filtered(ll, s->Length(MinimalPresentationOfNumericalSemigroup(s))=7); gap> MinimalGenerators(last[1]);


Please submit an extension above to begin
The Chrome Extension Analyzer
Your extension is in the queue to be analyzed, please wait...
(this may take a few minutes, grab a coffee for big extensions)
Your extension has been analyzed! Results are now being pushed to your browser.
(this may take a few seconds depending on your connection speed)
Known Vulnerable Libraries (
retire.js
)
{{vulnerability.definition_name}} {{vulnerability.version}}
Location: /{{vulnerability.file_path}}
URI: chrome-extension://{{extension_id}}/{{vulnerability.file_path}}
Risk Rating: High
Risk Rating: Medium
Risk Rating: Low
Summary: {{vulnerability.vulnerability.identifiers.summary}}
CVE(s):
OSVDB ID(s):
-
{{osvdb}}
Further Information:
manifest.json
{{report_data.manifest_text}}
Entry Point(s)
-
{{visible_entity_name}}
Description:
{{entrypoint.context_block}}
Note: Line numbers are for "beautified extension". You can download this version via the menu on the left-side of the page..
/{{entrypoint.javascript_path}}
URI:
chrome-extension://{{extension_id}}/{{entrypoint.javascript_path}}
Content Script Background Script Browser Action (Popup) Script
-
{{match_url_pattern}}
-
chrome-extension://{{extension_id}}/{{html_page_path}}
Web Accessible Navigation Blocked Background Page
Dangerous Function(s)
-
{{visible_entity_name}}
Description:
{{dangerousfunction.context_block}}
Note: Line numbers are for "beautified extension". You can download this version via the menu on the left-side of the page..
/{{dangerousfunction.javascript_path}}
URI:
chrome-extension://{{extension_id}}/{{dangerousfunction.javascript_path}}
Content Script Background Script Browser Action (Popup) Script
-
{{match_url_pattern}}
-
chrome-extension://{{extension_id}}/{{html_page_path}}
Web Accessible Navigation Blocked Background Page
Content Security Policy (CSP) Report
{{report_data.content_security_policy}}
Risk: {{csp_issue.risk.toUpperCase()}}
Description: {{csp_issue.description}}
Special thanks to Moloch for the Python CSP-Bypass library and the following folks for their CSP-bypass lists: Google's CSP Evaluator Core Library, GoSecure CSP Auditor, and Mozilla HTTP Observatory.
Extension Fingerprinting
List of fingerprintable extension URI(s):
-
chrome-extension://{{extension_id}}/{{web_accessible_resources_path}}
{{report_data.fingerprint_js}}
{{view_file_filename}}
{{view_file_contents}}
Potentially Clickjackable Page(s)
web_accessible_resources
Set
The following HTML pages were found to have the web_accessible_resources
directive set. This directive allows for the iframing of these pages in external web pages. If any of these pages contain sensitive application UI, the UI could potentially be redressed to perform a clickjacking attack. Note that these results must be validated and are context specific.
-
chrome-extension://{{extension_id}}/{{html_page}}


--- title: Tutorial - Templates (Intermediate) keywords: fastai sidebar: home_sidebar summary: "Intermediate overview of using templates" description: "Intermediate overview of using templates" nb_path: "nbs/tutorials/tutorials.template.intermediate.ipynb" ---
This tutorial follows from the Basic Template Tutorial. This tutorial looks more under the hood at filter functions and how they can be extended
import sys
sys.path.append('..')
from mrl.imports import *
from mrl.core import *
from mrl.chem import *
from mrl.templates.all import *
from rdkit import Chem
from rdkit.Chem import rdMolDescriptors
First lets get some compounds
df = pd.read_csv('../files/smiles.csv')
# if in Collab
# download_files
# df = pd.read_csv('files/smiles.csv')
smiles = df.smiles.values
mols = to_mols(smiles)
len(mols)
Previously we looked at building templates from existing filters in the library. Now we'll look at creating custom filters.
Property filters calculate some property of a compound and determine if it fallls within a specific range. This is impemented in the PropertyFilter
class. A PropertyFilter
takes in a mol_function
, which is any function that converts an RDKit Mol
to a numeric value.
For example, say we wanted to create a filter for the number of amide bonds in a molecule. We first need to define a function that computes our desired property - in this case the number of amide bonds - and choose a range
def my_property_function(mol):
return rdMolDescriptors.CalcNumAmideBonds(mol)
my_filter = PropertyFilter(my_property_function, min_val=None, max_val=2, name='amide bonds')
my_filter
Now we have a filter that will return True
if a molecule has 2 or fewer amide bonds.
One important point to note is creating my_property_function
as a wrapper around the rdMolDescriptors.CalcNumAmideBonds
. Why don't we just pass rdMolDescriptors.CalcNumAmideBonds
like my_filter = PropertyFilter(rdMolDescriptors.CalcNumAmideBonds, ...)
Filters and templates automatically use parallel processing to evauate large numbers of molecules. RDKit functions break python's multiprocessing because RDKit functions can't be pickled. Creating a wrapper around RDKit functions fixes this issue.
Now we can filter compounds based on the 2 or fewer amide bond criteria.
outputs = my_filter(mols)
passes = []
fails = []
for i, mol in enumerate(mols):
if outputs[i]:
passes.append(mol)
else:
fails.append(mol)
print(len(passes), len(fails))
Under the hood, the filter function performs two steps. The first is to compute PropertyFilter.property_function
, which for this filter computes the value of my_property_function
, the number of amide bonds. The result of the property function is then sent to PropertyFilter.criteria_function
, which converts the output of the property function to a boolean value based on the min_val
, max_val
arguments we passed.
Under the hood, it looks like this:
class PropertyFilter(Filter):
def __init__(self, mol_function, min_val=None, max_val=None, score=None, fail_score=0., name=None):
self.mol_function = mol_function
self.min_val = min_val
self.max_val = max_val
if name is None:
name = mol_function.__name__
super().__init__(score, name, fail_score=fail_score)
def property_function(self, mol):
return self.mol_function(mol)
def criteria_function(self, property_output):
lower_bound = (property_output>=self.min_val) if self.min_val is not None else True
upper_bound = (property_output<=self.max_val) if self.max_val is not None else True
output = lower_bound and upper_bound
return output
To make custom filters, subclass the main Filter
function and define your own property_function
and criteria_function
. For a simple example, look at the SingleCompoundFilter
class. This filter determines if a molecule is a single compound. In SMILES strings, different compounds are separated by a period .
. To filter based on the single compound criteria, we need to set up our property_function
and criteria_function
to return True
if a period is not found in the SMILES string.
class SingleCompoundFilter(Filter):
def __init__(self, score=None, name=None, fail_score=0.):
if name is None:
name = 'Single Compound Filter'
super().__init__(score, name, fail_score=fail_score)
self.priority=1
def property_function(self, mol):
smile = to_smile(mol)
return smile
def criteria_function(self, property_output):
return not '.' in property_output
my_filter = PropertyFilter(my_property_function, min_val=None, max_val=2, name='amide bonds',
score=1, fail_score=0)
Passing some mols to the filter with with_score=True
will return the soft score rather than the hard boolean values
my_filter(mols[:10], with_score=True)
Now the filter returns 1
for passing molecules and 0
for failing molecules. For most MPO functions, this will be sufficient. However, we can use fancier score methods if we want to
Under the hood, scores are determined by the ScoreFunction
class. A score function has a __call__
method that takes in the output of a filter's property_function
and criteria_function
and returns a numeric value.
Lets say for the amide bond example we want our score to actually return 1/(1+n)
where n
is the number of amide bonds. We can implement that as follows:
class MyScore(ScoreFunction):
def __call__(self, property_output, criteria_output):
return 1/(1+property_output)
Now we can pass an instance of MyScore
to the score
keyword argument in PropertyFilter
. The Filter will verify the passes score function is an instance of the main ScoreFunction
class, so it's important to subclass
score = MyScore()
my_filter = PropertyFilter(my_property_function, min_val=None, max_val=2, name='amide bonds',
score=score)
Now we can get pass some mols to our filter and see the score defined by our custom score function
my_filter(mols[:10], with_score=True)
If your property or score calculation is complex, it can be easier to abstract the property calculation and score computation entirely. This can be done with the PassThroughScore
class, which just returns the output of the property function.
class PassThroughScore(ScoreFunction):
"Pass through for no score"
def __call__(self, property_output, criteria_output):
return property_output
We can set up a filter using this like so
my_filter = PropertyFilter(my_property_function, min_val=None, max_val=None, name='my filter',
score=PassThroughScore())
The above filter when used as a soft filter will simply return the output of my_property_function
. When used as a hard filter will always return True
since min_val
and max_val
are None
.


{% extends "home.html" %} {% load filters %} {% load livewhale_api %} {% block title %} Physical Evaluation — Medical History — Health and Counseling — Carthage College {% endblock %} {% block content %}
Photo or scan of your physical evaluation form signed by your doctor
{% include "includes/errors_text.html" %}


pips Red=139 White=160
(CorrectAnswer= 0/0, ErrorScore= 0)
Blitzkrieg is defined as an intense military campaign intended to bring about a swift victory. In backgammon, not only does a blitz bring about a swift victory when it succeeds, but it frequently brings the reward of a gammon and double points.
Before the advent of computers we really did not play blitzes that well, often not being aggressive enough and letting the defending player make an anchor. Once the defender makes an anchor he often has a strong game because the attacking side may have blots strewn around the board that can subsequently be attacked. The likes of JellyFish, Snowie and XG have taught us to be super-aggressive when laying blitzes, often leaving two home board blots to prevent the defender making an anchor. One bad roll by the defender then means that the blitz can be resumed full force.
Players also now have a much better understanding of doubling tactics in blitzes and, once again, are far more aggressive than they used to be, recognising that four points for a doubled gammon is worth the risk of the occasional loss.
We start off by learning the blitzes that can occur after the early roll of a double in the opening, typically after the opponent has split his rear checkers and then the attacking side rolls a good double. Everybody should know the correct doubling actions after an opening roll split followed by a good double in response. For example, after the sequence: White 21: 24/23, 13/11 Black 55: 8/3(2), 6/1(2)* White: Fan, what is the correct doubling action for both players? If you don’t know the answer then you should find a copy of Kit Woolsey’s “The Backgammon Encyclopedia - Volume 1” which looks at all these early game scenarios.
Once we are out of the opening we need to rely on some guiding principles to make our doubling decisions. The attacking side needs to look at the number of checkers in the attack zone, the strength of the defender’s home board (which may limit the aggression), the number of loose blots and, of course, the race. For the defender he needs to look at the probability of anchoring and where that anchor might be, the quality of his home board (to contain a hit checker) and of course the race.
I had this week’s position in a match and noted that most of the elements were in my favour. True my opponent has a three-point home board but it is a very poor one and I would have no qualms about being very aggressive with my blitz. White has five blots for me to shoot at. I doubled and was surprised when my opponent took. He paid the price when my blitz succeeded and those five blots were closed out. In fact it is a double blunder to take.
Note however, that if you move the blot on White’s 9-pt to his 8-pt, giving him his 8-pt and only three blots then the position is only just a double and a trivial take. As ever with backgammon the devil is in the detail. What is really needed is for someone to provide an extensive book of reference positions for blitzes - any volunteers?
Before the advent of computers we really did not play blitzes that well, often not being aggressive enough and letting the defending player make an anchor. Once the defender makes an anchor he often has a strong game because the attacking side may have blots strewn around the board that can subsequently be attacked. The likes of JellyFish, Snowie and XG have taught us to be super-aggressive when laying blitzes, often leaving two home board blots to prevent the defender making an anchor. One bad roll by the defender then means that the blitz can be resumed full force.
Players also now have a much better understanding of doubling tactics in blitzes and, once again, are far more aggressive than they used to be, recognising that four points for a doubled gammon is worth the risk of the occasional loss.
We start off by learning the blitzes that can occur after the early roll of a double in the opening, typically after the opponent has split his rear checkers and then the attacking side rolls a good double. Everybody should know the correct doubling actions after an opening roll split followed by a good double in response. For example, after the sequence: White 21: 24/23, 13/11 Black 55: 8/3(2), 6/1(2)* White: Fan, what is the correct doubling action for both players? If you don’t know the answer then you should find a copy of Kit Woolsey’s “The Backgammon Encyclopedia - Volume 1” which looks at all these early game scenarios.
Once we are out of the opening we need to rely on some guiding principles to make our doubling decisions. The attacking side needs to look at the number of checkers in the attack zone, the strength of the defender’s home board (which may limit the aggression), the number of loose blots and, of course, the race. For the defender he needs to look at the probability of anchoring and where that anchor might be, the quality of his home board (to contain a hit checker) and of course the race.
I had this week’s position in a match and noted that most of the elements were in my favour. True my opponent has a three-point home board but it is a very poor one and I would have no qualms about being very aggressive with my blitz. White has five blots for me to shoot at. I doubled and was surprised when my opponent took. He paid the price when my blitz succeeded and those five blots were closed out. In fact it is a double blunder to take.
Note however, that if you move the blot on White’s 9-pt to his 8-pt, giving him his 8-pt and only three blots then the position is only just a double and a trivial take. As ever with backgammon the devil is in the detail. What is really needed is for someone to provide an extensive book of reference positions for blitzes - any volunteers?
Cube analysis 2-ply cubeless equity +0.648 0.686 0.325 0.039 - 0.314 0.086 0.003 Cubeful equities: 1. Double, pass +1.000 2. Double, take +1.083 (+0.083) 3. No double +0.761 (-0.239) Proper cube action: Double, pass


THE WEDDING BANQUET A film review by Mark R. Leeper Copyright 1993 Mark R. Leeper
Capsule review: Marriage-of-convenience comedy of a gay, well-to-do, Chinese-American businessman marrying a citizenship-seeking artist in order to please his parents. The is an enjoyable Taiwanese comedy (filmed and set in Manhattan) but what we see of Chinese culture is more of interest than the well-trodden material about gays and straights. Rating +1 (-4 to +4)
Miss Wei-Wei and Mr. Wai-Tung Gao are in love and are getting married. Wei-Wei (May Chin) is in love with Wai-Tung (Winston Chao) and Wai-Tung is in love with Simon (Mitchell Lichtenstein), his long-time roommate and lover. So why is Wai-Tung marrying Wei-Wei? His parents do not know that he is gay and would not be able to handle knowing it. They have tried for years to get him paired with a nice Chinese girl, and Wai-Tung has not had the heart to tell them his sexual orientation. Wai-Tung is a well-off landlord and his tenant Wei-Wei, an out-of-work artist and an illegal alien, has been attracted to him and also would like American citizenship. So Simon has suggested this charade of a marriage and the two Chinese have reluctantly decided it was a good idea.
The most disappointing aspect of this film, written and directed by Ang Lee, is that while it is pleasant enough, the basic story is overly familiar. It is very much a LA CAGE AUX FOLLES set in the Chinese-American community. (And even CAGE itself was derivative of Frank Capra films such as LADY FOR A DAY.) So THE WEDDING BANQUET is an engaging view into a community too rarely depicted in film, but the story itself could occur in just about any culture and has little in the plot that is not telegraphed. I think I learned more about Chinese-American marriage customs and life in general in their community than I learned about gays from THE WEDDING BANQUET. Where this film shows us what we have not seen, it is in Gao's parents' cultural fascination with Chinese calligraphy; it is in some odd wedding tradition about a piece of what looks like fried chicken on a string. Then there is the wild party after the banquet that seems so out of character with the usually staid outward appearances of the Chinese. Take these out of the film and it becomes a television-level situation comedy with a few very pat lessons. In fact, it is even a bit uneven as a comedy. The showpiece scene seems to be the marriage ceremony with the two principles having almost no command of English. That seems a bit contrived since at other times they seem to have considerably more command of English.
Generally, performances are very good. Sihung Lung as the father has little to do but look stiff and dignified in the early parts of film, yet still finds opportunity to make his the most memorable character of the movie. Perhaps because he is enigmatic for so much of the story. Lichtenstein is winning, if a little overly bright-eyed. The score, by Mader, is a bit of a disappointment as it is neither particularly melodic music, nor does it use Chinese themes. But it is always interesting to see foreign films set and filmed in the United States just to get some idea how other people view the United States. This Taiwanese film really effectively uses its Manhattan locations.
This is an enjoyable film, though perhaps not as good as word-of-mouth would have it. I would say it is just average for theatrical films I have seen this year, giving it a +1 on the -4 to +4 scale.
Mark R. Leeper att!mtgzfs3!leeper<EMAIL_ADDRESS>.
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


You really,really need to enable JavaScript to view this page. You know,it's written in JavaScript. And it will make your life much easier,but it's up to you.


“Give me problems, give me work.”
In the year 1878 I took my degree of Doctor of Medicine of the University of London, and proceeded to Netley to go through the course prescribed for surgeons in the army. Having completed my studies there, I was duly attached to the Fifth Northumberland Fusiliers as Assistant Surgeon. The regiment was stationed in India at the time, and before I could join it, the second Afghan war had broken out. On landing at Bombay, I learned that my corps had advanced through the passes, and was already deep in the enemy’s country.
- SHERLOCKHOLMES
- DR JOHN HEMISHWATSON
- MYCROFTHOLMES
- PROF JAMESMORIARTY
- IRENEADLER
- JAMESWINTER


I enrolled in the University of Nottingham as a full-time Electronic and Computer Engineering
student in September 2017. Since then, I has been involved in projects ranging from building
robotic cars to sensor systems for extreme environments. Outside of my studies, I am extremely
passionate about encouraging and empowering girls and women to pursue careers in STEM fields.
This fuelled my motivation to become one of the founding members of the university's first
Women's Engineering Society.
Since joining university, I have enjoyed trying new things and
exploring new places such as spending a summer studying AI and Wearable Electronics in Hong Kong,
learning salsa dancing and participating in inter-university competitions (and winning some awards!)
and winning 2nd place at the 2019 Google BGN Hackathon.
Here are a few exciting things I have done in the past!


Notes tutorial app
Sign in
Register
Keep your notes in order
A simple application to keep your own notes in order.