K-pop star Goo Hara found dead in Seoul
Body of 28-year-old Korean pop singer Goo Hara has been discovered at her home in Seoul
by Taiwan NewsKorean celebrity entertainer Goo Hara, formerly a member of the girl group Kara, passed away at the age of 28, South Korean police said Sunday.
Her body was discovered in her apartment in southern Seoul, authorities added. The cause of death was still under investigation.
Goo completed a mini-tour in Japan and released a Japanese-language single, "Midnight Queen," earlier this month. The shows were widely seen as a comeback for the singer after a reported suicide attempt in May.
The K-pop star was hospitalized in May after her manager found her, unconscious, in her home. The day before, the singer posted "Goodbye" on her Instagram account. Goo has been engaged in a public row with her ex-boyfriend, who had threatened to release a sex video of her.
String of suicides
The 28-year-old singer also complained of depression and spoke out against cyberbullying. A close friend of hers, fellow singer and actress Sulli, is believed to have committed suicide in October.
"I hope Jin-ri is now in a place where she can do whatever she wants," Goo wrote on her Instagram page at the time, using Sulli's real name.
Suicide is one of the leading causes of death for young South Koreans. A string of celebrity suicides in recent years sparked a discussion on the pressures and public scrutiny faced by Korean entertainers from a young age.
"It is almost as if these deaths are 'part of the show' and are reported as such," Emanuel Pastreich, director of the Seoul-based Asia Society, told DW's Julian Ryall last month.
If you are suffering from emotional strain or suicidal thoughts, seek professional help. You can find information on where to find help, no matter where you live in the world, at this website: www.befrienders.org.
dj/sms (AP, AFP, Reuters)
DW's editors send out a selection of the day's news and features. Sign up here.


there are about this many people travelling in Canada
one square is equivalent to 1 million passengers


{% extends 'index.html' %} {% block title %}Login{% endblock %} {% block content %} FunnySociety Log in {% csrf_token %} {{ form.as_p }} Sign In Don't have an account yet? Sign Up now {% endblock %}
Don't have an account yet? Sign Up now


Seems your browser doesn't support Javascript! Websockets rely on Javascript being enabled. Please enable Javascript and reload this page!
Peers


Please make the application/config/database.php file writable. Example:chmod 777 application/config/database.php
chmod 777 application/config/database.php


Youtube Comment Analysis.
- Enter a video name to see what people think!
- Click here to learn more.
Welcome to my project!
Introduction
This is my portion of the 2020 Google STEP Capstone project. With this feature, you can enter in a Youtube video name or ID and get a solid estimate on how the video was received via comment analysis.
In order to achieve this, I took advantage of the Google Natural Language (NLP) and Google Perspective APIs to analyze comments returned to me from the Youtube Data API.
Method
In order to ensure the most accurate analysis while handling the minimum amount of data, this tool takes 20 random comments from the Youtube API, aggregates them into a single string of sentences, and runs the chunk through both the NLP and Perspective APIs. Here is what each API is responsible for:
NLP
NLP returns a magnitude and score value which give us the Overall Response. The score value contributes to the corresponding adjective: Positive, Negative, or Mixed. If a video is "Clearly" one of these values, NLP returned a high magnitude rating and thus is confident that the given data supports its score. Click here for the official documentation.
Perspective
Perspective returns a series of probabilities which correspond to attributes such as Toxicity, Insult, Identity Attack, etc. These probabilities indicate how likely the text is to have these effects on the readers. It is important to note that all attributes except for Toxicity are in the experimental phase right now. Click here for further explanation.
Programming techniques
I've implemented techniques like caching, pattern-matching, search, and string manipulation to provide the best possible experience and just to have some fun with this. The code is all open source and can be found here.
Limitations
Unfortunately, there are some limitations on how the tool can work since this technically is a Google product and I am under the jurisdiction of the company. Here are the biggest ones:
- The API quota only allows for 94 search calls a day, assuming no visitors use the Youtube API on one of my podmates' pages. Please use a video ID if you can!
- I can only fetch and parse through so many comments with the small quota. The video matching and comment parsing algorithms I have are decent, but they are constrained.


{{ member.position }}
I am a climate scientist motivated by the potential for climate studies to minimize future disaster risk to vulnerable communities around the world. Towards this goal, my research explores the physical drivers of climate extremes, and their impacts on agriculture, water availability and human health. I combine a variety of tools including observations, paleoclimate evidence, remote sensing data, and model simulations, to study extremes in the past and future climates. I am particularly interested in studying extremes such as intense rainfall, droughts, and heat waves in monsoonal climates that affect the billions of people with relatively poor adaptive capacity living in these regions.
I am an Assistant Professor in the School of the Environment at Washington State University Vancouver (WSUV). I was a postdoctoral fellow at the Lamont-Doherty Earth Observatory of Columbia University. I received my Ph.D. in Environmental Earth System Science from Stanford University in 2015 working with Dr. Noah Diffenbaugh. My dissertation investigated trends in daily-scale extremes events in different regions, the associated physical processes, and the role of natural and anthropogenic factors in shaping their spatial and temporal characteristics. In 2015, I was recognized as a Kavli 'Frontiers of Science' Fellow by the U.S. National Academy of Sciences.
Prior to my career in earth sciences, I completed a Master's in Aeronautics and Astronautics Engineering from Purdue University while researching environmentally friendly alternatives for aviation fuels in Dr. Li Qiao's group . This interest was fueled by my passion for all things aviation-related, my research with Dr. Sudarshan Kumar at the Indian Institute of Technology Bombay for two years, and my Bachelor's in Mechanical Engineering at Vishwakarma Institute of Technology, Pune University, India.
I am passionate about building a more inclusive academic environment. At multiple institutes, I have initiated organizations aimed to improve gender diversity in STEM fields and have been involved in a number of mentoring programs targeting students from underrepresented backgrounds. I strongly believe that a more diverse community will be more effective in addressing the complex challenges facing the world today.
When I'm not actively working, I am out on adventures with my pibble Patches discovering the diverse wildlife in NYC parks including racoons and rodents, hiking both urban and natural environments, or working with the wonderful dogs at Posh Pets Rescue.
{{ topic.description }}


Your browser does not support HTML5.
Demo is above this text
Your browser does not support the audio element.
Your browser does not support the audio element.
Your browser does not support the audio element.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/leanproject.20issues.html ---
Hello,
I'm trying to use "leanproject get <github repo>" to pull a project from github, but I'm getting this error:
... Looking for GitHub mathlib oleans Info: No github section found in 'git config', we will use GitHub with no authentication 403 {"message": "API rate limit exceeded for <IP_ADDRESS>. (But here's the good news: Authenticated requests get a higher rate limit. Check out the documentation for more details.)", "documentation_url": "https://developer.github.com/v3/#rate-limiting"}
Can someone help me fix this? BTW I use SSH to normally communicate with Github.
Thank you!
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Introduction to Python
Microsoft
Sophomore | Pythonist | Passionate | Tech Blogger | ECE Undergrad
Eat . Sleep . </> . Repeat
This is my old site. New Site is live at http://iamayan.me
"Dreams aren't those which come to you when you sleep. Dreams are those which don't let you sleep" - Dr. APJ Abdul Kalam.
A second year Undergrad student at Kalyani Government Engineering College. I love to develop and code new tech or product that can ease the work of masses. If not coding , you would find me playing Cricket or Badminton or trying to learn new sports on the field. Apart from being a vivid web surfer, I also enjoy writing my own articles which you can find in my blog.
A Introductory article for all those who want start learning R programming. It gives an overview of R and other statistical programing packages.
A tutorial to create a console chat application which also supports realtime file transfer system.
Multithreading is a way of achieving multitasking. Most of the code we write in Python is single threaded.
PyCrypt : A Python package of cryptographic algorithms.
Blocker : A Chrome Extension to block Advertisement sites as well as helps to stop autoplay in Chrome.
Pydl : Command Line Utility to download music from Youtube , Soundcloud and many others sites.
Comlid : A Command Line based Dictionary cum Translator.
Switch : Python implementation of Switch Case statement.
Terminal Chat Network : A console chatting application prototype with in-app realtime file transfer capabilities
iamayan.me : My Personal Website
PyCrypt : A Python package of cryptographic algorithms.
Pydl : Command Line Utility to download music from Youtube , Soundcloud and many others sites.
Comlid : A Command Line based Dictionary cum Translator.
Switch : Python implementation of Switch Case statement.
Terminal Chat Network : A console chatting application prototype with in-app realtime file transfer capabilities
Terminal Chat Network : A console chatting application prototype with in-app realtime file transfer capabilities
iamayan.me : My Personal Website
Blocker : A Chrome Extension to block Advertisement sites as well as helps to stop autoplay in Chrome.
15 March 2018
Microsoft
25 June 2018
ChalkStreet
25 June 2018
ChalkStreet
19 September 2018
17 November 2018
Udemy
WANT TO KNOW MORE ABOUT ME


Welcome to modbusproxy_cpe_cb’s documentation!¶
A proxy service for a ClearBlade Edge that takes optimized Modbus slave data sent via the Inmarsat global satellite network and re-maps to native Modbus registers for use within a private Enterprise environment.
Uses a secure HTTP connection between the Enterprise and ClearBlade public or private cloud, running within your LAN environment on private IP addresses. Data collected from the field runs over the Inmarsat private network with secure connectivity to the ClearBlade platform.
The solution imports a simple text configuration file of your Modbus RTU/outstation, compatible with Inmarsat’s IsatData Pro Modbus Proxy application running on ORBCOMM IDP/Lua terminals such as the ST6100. You specify the set of registers you want to poll, and optimize the refresh rate plus compress the data to minimize network costs. Supplement regular polling with remote analytics and alerts that make sure you trap relevant events or changes within seconds. Your SCADA/master can poll within your Enterprise domain more frequently without missing an event, while getting less critical data in due course.
Reliable, secure, scalable data from your remote field devices anywhere in the world.
modbus_server_adapter¶
Inmarsat Modbus Proxy Adapter for ClearBlade connects to your ClearBlade cloud/platform using secure credentials. In ClearBlade you define Collections that map an IDP MobileID to a proxy IP address and TCP port. The Adapter runs on an Edge device such as Raspberry Pi, reads the mapping from the platform and sets up concurrent Modbus servers using PyModbus and the Twisted.internet framework. The Adapter creates IP aliases on the Edge and listens for Modbus TCP connections on each of the virtual interfaces.
ClearBlade Collection Example ModbusProxyRtus
for mapping MobileID to a local IP address:
| mobile_id | ip_address | tcp_port | slave_id | config_file | latitude | longitude | altitude |
| 00000000SKYEE3D | <IP_ADDRESS> | 502 | 1 | <blob> | <meta> | <meta> | <meta> |
ClearBlade Collection Example ModbusProxyData
that holds the latest reported data from the field:
| ip_address | tcp_port | slave_id | register_address | register_data | register_type | timestamp |
| <IP_ADDRESS> | 502 | 1 | 0 | 123 | ir | 01/21/2019 07:00:00 |
Register Types:
ir
Input Register also sometimes referred to as read-only analog inputshr
Holding Register sometimes referred to as read/write or output registersdi
Discrete Input read-only boolean values sometimes called digital inputs or contact closuresco
Coil read/write boolean values associated with digital outputs
Todo
- Setup for multiple instances running on virtual IP address/ports from a single host
- Proper credits for ClearBlade / Jim Bouquet
Inmarsat Modbus Proxy Adapter for ClearBlade
usage: modbus_server_adapter.py [-h] [--url URL] --systemKey SYSTEMKEY
--systemSecret SYSTEMSECRET
[--deviceName DEVICENAME] --deviceKey
DEVICEKEY [--_slaves SLAVES_COLLECTION]
[--data DATA_COLLECTION] [--net NET_IF]
[--ip IP_ADDRESS] [--tcp TCP_PORT]
[--logLevel {INFO,DEBUG}]
[--heartbeat HEARTBEAT]
Named Arguments¶
| --url | The URL of the ClearBlade Platform the adapter will connect to. Default: “https://platform.clearblade.com” |
| --systemKey | The System Key of the ClearBlade platform System the adapter will connect to. |
| --systemSecret | The System Secret of the ClearBlade plaform System the adapter will connect to. |
| --deviceName | The id/name of the device that will be used for device authentication against the ClearBlade platform or Edge, defined within the devices table of the ClearBlade platform. Default: “ModbusProxyServerAdapter” |
| --deviceKey | The active key of the device that will be used for device authentication against the ClearBlade platform or Edge, defined within the Devices table of the ClearBlade platform. |
| --_slaves | The ClearBlade Collection name with RTU proxy definitions Default: “ModbusProxyRtus” |
| --data | The ClearBlade Collection name with proxy data Default: “ModbusProxyData” |
| --net | The physical port of the network listener Default: “eth0” |
| --ip | The local IP Address the PyModbus server will listen on Default: “localhost” |
| --tcp | The local TCP Port the PyModbus server will listen on Default: 502 |
| --logLevel | Possible choices: INFO, DEBUG The level of logging that will be utilized by the adapter. Default: “INFO” |
| --heartbeat | The logging heartbeat interval in seconds. Default: 30 |
context¶
Establishes a PyModbus server/slave context that maps to ClearBlade platform collections. Requires a unique instance per slave device represented in the platform.
-
class
context.
ClearBladeModbusProxySlaveContext
(server_context, config, **kwargs)¶ A Modbus slave context integrated with ClearBlade, derived from an Inmarsat IDP Modbus Proxy template file. Represents a single remote outstation / RTU
The ClearBlade collection must have a row defining at least the following:
ip_address
(str) the proxy address (IPv4) assigned to the remote outstation/RTUip_port
(int) the (TCP) port of the proxy address for the RTUslave_id
(int) the Modbus Slave ID / Unit ID (0..254)zero_mode
(bool)last_report_time
(ts) timestamp of the most recently received data from the RTU in the field (metadata)config_file
(str) a formatted text file conforming to Inmarsat’s IDP Modbus Proxy template
Todo
Add URL link to Modbus Proxy template
Parameters: - server_context (ClearBladeModbusProxyServerContext) – the parent server context
- config (dict) – a row returned from reading the Clearblade collection for RTU configuration
- kwargs – optional arguments such as log
-
reset
()¶ NOT IMPLEMENTED - placeholder for future
-
validate
(fx, address, count=1)¶ Validates the request to make sure it is in range
Parameters: - fx – The function we are working with
- address – The starting address
- count – The number of values to test
Returns: True if the request in within range, False otherwise
-
getValues
(fx, address, count=1)¶ Validates the request to make sure it is in range
Parameters: - fx – The function we are working with
- address – The starting address
- count – The number of values to retrieve
Returns: The requested values from address:address+count
-
setValues
(fx, address, values)¶ Sets the datastore with the supplied values
Parameters: - fx – The function we are working with
- address – The starting address
- values – The new values to be set
-
class
context.
ClearBladeModbusProxyServerContext
(cb_system, cb_auth, cb_slaves_config, cb_data, **kwargs)¶ A Modbus server context, initialized by reading a ClearBlade collection defining Slave configurations / templates
Initialize the Server context
Parameters: - cb_system (clearblade.ClearBladeCore.System) – a ClearBlade System
- cb_auth (clearblade.ClearBladeCore.Device) – a ClearBlade authenticated Device
- cb_slaves_config (str) – the name of the ClearBlade Collection holding Slave definitions
- cb_data (str) – the name of the ClearBlade Collection holding data
- kwargs – optionally takes log definition
store¶
Subclasses of the PyModbus data blocks integrated with a ClearBlade Platform.
-
class
store.
CbModbusSequentialDataBlock
(context, register_type, address, values)¶ A custom subclass of the sequential data block that includes metadata for the ClearBlade platform context, register type, and timestamps of the field data
Initializes the sequential datastore
Parameters: - context (context.ClearBladeModbusProxySlaveContext) – the parent/context of the data block
- register_type (str) – select from hr, ir, di, co
- address (int) – the starting address for the sequential block
- values (iterable) – Either a dictionary or list of values
-
getValues
(address, count=1)¶ Returns the requested values of the datastore
Parameters: Returns: The requested values from address:address+count
Return type:
-
class
store.
CbModbusSparseDataBlock
(context, register_type, values)¶ Initializes the sparse datastore. Using the input values it creates the default datastore value and the starting address
Parameters: - context (context.ClearBladeModbusProxySlaveContext) – the parent/context of the data block
- register_type (str) – select from hr, ir, di, co
- values (dict) – Either a dictionary or list of values
-
getValues
(address, count=1)¶ Returns the requested values of the datastore
Parameters: - address – The starting address
- count – The number of values to retrieve
Returns: The requested values from a:a+c
-
setValues
(address, values)¶ Sets the requested values of the datastore
Parameters: - address – The starting address
- values – The new values to be set
-
get_timestamps
(address, count=1)¶ Returns the timestamps of the field data for the specified registers
Parameters: Returns: timestamps of the requested registers in the format {address: timestamp}
Return type: dict of str
-
store.
read_collection_data
(context, register_type, address, count, fill=0)¶ Retrieve data from the specified collection. When retrieving sequential blocks if the ClearBlade collection is missing registers between the start and end, those will be filled (optionally)
Parameters: - context (context.ClearBladeModbusProxySlaveContext) – The ClearBlade parent metadata to query against.
- register_type (str) – the type of register (‘co’, ‘di’, ‘hr’, ‘ir’)
- address (int) – The starting address
- count (int) – The number of values to retrieve
- fill (int) – automatically fills gaps in sequential register blocks with this value (or None)
Returns: values, timestamps of the data read from the ClearBlade collection/proxy
Return type:
-
store.
write_collection_data
(context, register_type, address, data)¶ Retrieve input register values from the Analog_Input_Registers collection
Parameters: - context (context.ClearBladeModbusProxySlaveContext) – The ClearBlade parent metadata to query against.
- register_type (str) – the type of register (co, di, hr, ir)
- address (int) – The starting address
- data – The data value(s) to write
constants¶
A set of constants used in the ClearBlade platform Collections
and the Modbus Proxy Lua service config.dat
file.


Hot-keys on this page
n s m x c change column sorting
| Module | statements | missing | excluded | coverage |
|---|---|---|---|---|
| Total | 334 | 46 | 0 | 86% |
| manage.py | 12 | 2 | 0 | 83% |
| tests/__init__.py | 0 | 0 | 0 | 100% |
| tests/test_forms.py | 0 | 0 | 0 | 100% |
| tests/test_models.py | 0 | 0 | 0 | 100% |
| tests/test_urls.py | 22 | 0 | 0 | 100% |
| tests/test_views.py | 24 | 8 | 0 | 67% |
| wine/__init__.py | 0 | 0 | 0 | 100% |
| wine/settings.py | 25 | 0 | 0 | 100% |
| wine/urls.py | 7 | 1 | 0 | 86% |
| wines/__init__.py | 1 | 0 | 0 | 100% |
| wines/admin.py | 55 | 3 | 0 | 95% |
| wines/apps.py | 4 | 0 | 0 | 100% |
| wines/forms.py | 11 | 0 | 0 | 100% |
| wines/migrations/0001_initial.py | 7 | 0 | 0 | 100% |
| wines/migrations/0002_auto_20200424_1556.py | 5 | 0 | 0 | 100% |
| wines/migrations/0003_auto_20200425_1117.py | 4 | 0 | 0 | 100% |
| wines/migrations/0004_auto_20200429_1124.py | 5 | 0 | 0 | 100% |
| wines/migrations/__init__.py | 0 | 0 | 0 | 100% |
| wines/models.py | 75 | 7 | 0 | 91% |
| wines/templatetags/__init__.py | 0 | 0 | 0 | 100% |
| wines/templatetags/wine_tag.py | 10 | 0 | 0 | 100% |
| wines/tests.py | 1 | 0 | 0 | 100% |
| wines/urls.py | 3 | 0 | 0 | 100% |
| wines/views.py | 63 | 25 | 0 | 60% |
No items found using the specified filter.


Plaintext
Institution markup
Page with 50 Database Queries
Multiple ajax
Baseline
Baseline with resources
Frontend base
Symfony with multiple ajax requests


Tutorial #7
- Font Creation
- Creating a glyph (tracing outlines)
- Create glyph outlines using spiro points
- Importing a glyph from Inkscape (or Illustrator, or some other vector editor)
- Navigating to other glyphs
- On to the next glyph (consistent directions)
- Consistent serifs and stem widths
- Building accented glyphs
- Building a ligature
- Lookups and features
- Examining metrics
- Kerning
- Glyph variants
- Anchoring marks
- Conditional features
- Checking your font
- Generating it
- Font Families
- Final Summary
- Bitmap strikes
- Scripting Tutorial
- Notes on various scripts
- Searching the documentation: (Powered by Google)
Conditional Features
OpenType and Apple fonts both provide contextual features. These are features which only take place in a given context and are essential for typesetting Indic and Arabic scripts. In OpenType a context is specified by a set of patterns that are tested against the glyph stream of a document. If a pattern matches then any substitutions it defines will be applied. In an Apple font, the context is specified by a state machine -- a mini program which parses and transforms the glyph stream.
Conditional features may involve substitutions, ligatures or kerning (and some more obscure behaviors). First I shall provide an example of a contextual substitution, later of contextual ligatures.
Instead of an Indic or Arabic example, let us take something I'm more familiar with, the problem of typesetting a latin script font where the letters ``b,'' ``o,'' ``v'' and ``w'' join their following letter near the x-height, while all other letters join near the baseline. Thus we need two variants for each glyph, one that joins (on the left) at the baseline (the default variant) and one which joins at the x-height. Let us call this second set of letters the ``high'' letters and name them ``a.high,'' ``b.high'' and so forth.
OpenType Example
Warning
The following example may not work! The font tables produced by it are all correct, but early implementations of OpenType did not support decided the "Contextual Alternative" ('calt') feature for the latin script.
Why do I provide an example which might not work? It's the best I can do. If I knew enough about Indic or Arabic typesetting I would provide an example for those scripts. But I don't. The procedures are the same. If you follow them for some other scripts they will work.
As time has gone on 'calt' has been supported by more applications for latn and this warning is no longer as applicable as it once was.
We divide the set of possible glyphs into three classes: the letters ``bovw'', all other letters, and all other glyphs. We need to create two patterns, the first will match a glyph in the ``bovw'' class followed by another glyph in the ``bovw'' class, while the second will match a glyph in the ``bovw'' class followed by any other letter. If either of these matches the second glyph should be transformed into its high variant.
- [bovw] [bovw] => Apply a substitution to second letter
- [bovw] <any other letter> => Apply a substitution to the second letter
(You might wonder why I don't just have a class of all letters and use one rule instead of two? Because in this case all my classes must be disjoint, I mayn't have one glyph appearing in two classes).
The first thing we must do is create a simple substitution mapping each low letter to its high variant. This is a "Simple Substitution" lookup, but it will not be attached to any feature, instead it will be invoked by a contextual lookup. Let us call this lookup "high". We must (of course) create a subtable to go with our lookup, and we can use the [Default with Suffix:] button to fill it up with the high variants.
The tricky part is defining the context. This is done by defining yet another lookup, a contextual chaining lookup which should be associated with a 'calt' feature. And of course we want an associated subtable). This will pop up a series of dialogs to edit a contextual subtable
The first dialog allows you to specify the overall format of the substitution. We want a class based system -- we've already mentioned what the glyph classes will be.
The next dialog finally shows something interesting. At the top is a pattern to match and substitutions that will be applied if the string matches. Underneath that are the glyph classes that this substitution uses. A contextual chaining dialog divides the glyph stream into three sections: those glyphs before the current glyph (these are called backtracking glyphs), the current glyph(s) itself (themselves), which may have simple substitutions applied to them, and finally glyphs after the current glyph (these are called lookahead glyphs).
Each category of glyphs may divide glyphs into a different set of classes, but in this example we use the same classes for all categories (this makes it easier to convert the substitution to Apple's format). The first line (in the ``Matching rules'' field) should be read thus: If a backtracking glyph (the glyph before the current one) in class "high-after" is followed by the current glyph in class "letter", then that letter in the match string (that is the current glyph) should have simple substitution `To-TopJoin' applied to it.
If you look at the glyph class definitions you will see that class "high-afters" includes those glyphs which must be followed by a high variant, so this seems reasonable.
Now there should be a second line which would look like "high-after | high-after @<To-TopJoin> |"
to handle the second case mentioned above. Unfortunately that doesn't seem to work. The OpenType spec allows for it, but implementations of OpenType don't seem to support it. Instead that line must be in a separate sub-table in the same lookup.
To edit a glyph class simply click on it and type. To create a new one press the <New> button (at the bottom of the list). You can also click on the little box thingy off on the right. This produces another dialog showing a font view. You can select glyphs in the font view if that is easier than remembering their names.
You may edit a pattern in the obvious way. As you enter glyph names they will be auto completed for you. There are two buttons down at the bottom of the pattern list, one to start a new section (go from back tracking to active, or from active to lookahead), and one to add a new lookup reference.
A warning about contextual behavior: Not all software supports them. And even more confusing software may support them for some scripts and not for others.
Apple advanced typography
Apple specifies a context with a finite state machine, which is essentially a tiny program that looks at the glyph stream and decides what substitutions to apply. Each state machine has a set of glyph class definitions (just as in the OpenType example), and a set of states. The process begins in state 0 at the start of the glyph stream. The computer determines what class the current glyph is in and then looks at the current state to see how it will behave when given input from that class. The behavior includes the ability to change to a different state, advancing the input to the next glyph, applying a substitution to either the current glyph or a previous one (the ``marked'' glyph).
Using the same example of a latin script font... We again need a simple substitution to convert each letter into its high alternate. The process is the same as it was for OpenType, and indeed we can use the same substitution. Again we divide the glyphs into three classes (Apple gives us some extra classes whether we want them or no, but conceptually we use the same three classes as in the OpenType example). We want a state machine with two states (again Apple gives us an extra state for free, but we shall ignore that), one is the start state (the base state -- where nothing changes), and the other is the state where we've just read a glyph from the ``bovw'' class.
Apple Advanced Typography does not quite fit into the OpentType concepts of lookups and features, but it is close enough that I sort of force it to. So once again we create a GSUB lookup. This time the lookup type is "Mac Contextual State Machine", and the feature is actually a mac feature/setting, two numbers. When we create a new subtable of this type we get a state machine dialog, as shown below.
At the top of the dialog we see a set of class definitions, and at the bottom is a representation of the state machine itself.
Double clicking on a class brings up a dialog similar to that used in OpenType.
Clicking on a transition in the state machine (there is a transition for each state / class combination) produces a transition dialog. This controls how the state machine behaves when it is in a given state and receives a glyph in a given class. In this example it is in state 2 (which means it has already read a ``bovw'' glyph), and it has received a glyph in class 4 (which is another ``bovw'' glyph). In this case the next state will be state 2 again (we will have just read a new ``bovw'' glyph), read another glyph and apply the ``high'' substitution to the current glyph.
At the bottom of the dialog are a series of buttons that allow you to navigate through the transitions of the state machine.
Pressing [OK] many times will extract you from this chain of dialogs and add a new state machine to your font.
OpenType, Greek ligatures
Greek has a character (U+03D7) which is equivalent to the Latin ampersand. Just as the ampersand is (originally) a ligature of "E" and "t", so U+03D7 is a ligature of "kappa" and "iota". However this ligature should only be used if "kappa" and "iota" make up a word unto themselves, it should not be used for more normal occurances of the two within a longer word.
So the first thing to do is create the ligature itself. Add the glyph for U+03D7, and then create a ligature lookup and subtable (with Element->Font Info->Lookups)
to bind U+03D7 to be a ligature of "kappa" and "iota". This lookup will never be used directly -- only under the control of another, a conditional feature -- so we don't give it a feature tag.
Next the conditional bit.
I'm going to use the notation <letters> to represent a class consisting of all greek letters.
- <letters> kappa iota => no substitution
- kappa iota <letters> => no substitution
- kappa iota => apply the ligature "WORD"
(Now as I read the standard all these rules could be put into one subtable, and the font validation tools I have agree with me -- but the layout engines do not. The layout engines seem to insist that each rule live in its own subtable. This is inconvenient (the classes must be defined in each subtable) but it seems to work.)
These rules will be executed in order, and the first one that matches the input text will be the (one and only) rule applied. Consider these three strings, , , all contain kappa and iota but each contains more letters around them, so none should be replaced by the ligature.
- The first string, , will match the first rule above (it contains letters before the kappa iota sequence) and no substitution will be done. It also matches the third rule, but we never get that far.
- The second string, , will match the second rule above (it contains letters after the sequence) and again no substitution will be done. It would match the third rule, but we stop with the first match.
- The third string, , matches all the rules, but since the search stops at the first match, only the first rule will be applied, and no substitution will be done.
- The string, , matches neither of the first two rules but does match the last, so here the ligature will be formed.
You might wonder why I don't just have one rule
- <any non-letter> kappa iota <any non-letter> => apply our ligature
It seems much simpler.
Well there's one main reason:
- This does not work if the kappa is at the beginning of the input stream (it will not be preceded by any glyphs, but might still need replacing), or iota at the end.
Now how do we convert these rules into a contextual lookup?
We use Element->Font Info->Lookups->Add Lookup
to create a new contextual chaining lookup. This is the top level lookup and should be bound to a feature tag in the Greek script.
We have three rules, each rule lives in its own subtable, so we will create three subtables, one for each. The order in which these subtables n the Lookups pane is important because that is the order in which the rules they contain will be executed. We must insure that that final rule which actually invokes the ligature is the last one executed (and the last one in the list).
Since we are planning on using the class of all greek letters we will want to use a class format for this feature. Then we press the [Next>]
button.
The main match will be on the letters kappa and iota in all three rules, so we need one class for each of them. So in the Match Classes area we press the [New]
button...
And type in the word "kappa" and press [Next>]
Now we have a class containing the single glyph "kappa". We want to do the same thing for "iota" so we press [New]
again.
Again type in "iota" and press [Next>]
Now we have all the classes we need here. We still need to create classes for the lookahead and backtrack. We only need one class for these groups and that class will consist of all greek letters.
The check box [*] Same as Match Classes
is set, but we don't want that, we want our own classes here. So uncheck it.
Now the buttons become active and we can create a new class by pressing [New]
Now you could go back to the font view and select all of the greek letters, and then press the [Set From Font] button in the class dialog.
But in this case the class we are interested in (all the greek letters) is built it, and you can select it from the Standard Class pulldown list (Letters in script(s)) Then press [Next>]
.
Then go through the same process for the look ahead classes (adding one class which consists of all the greek letters.
Now we have all our classes defined and are finally ready to create the patterns for our rules. So underneath "List of lists of class numbers" press the [New]
button.
The first rule begins with all the greek letters in the backtrack area, so click on the "Backtrack" tab, and then press on the class consisting of all the greek letters. This puts the class number into the pattern area (the List of class numbers)
In the match area we want to match kappa and then iota, so click on the Match tab, and then on the entries for "kappa" and "iota".
This rule has no substitutions, so leave the bottom area blank and press [Next>]
.
We are done with the first rule. It says:
- The previous character should match class 1 of the backtrack classes (and that class contains all greek letters, which is what we want)
- The current character should match class 1 of the match classes (and that class contains "kappa")
- The next character should match class 2 of the match classes (which is iota)
- And if the match is successful, do absolutely nothing.
We've got two more rules though, so press [OK]
and then [Add Subtable]
. Then go through the process of adding all the classes, and then add the match string for this rule.
We are done with the second rule. It says:
- The current character should match class 1 of the match classes (and that class contains "kappa")
- The next character should match class 2 of the match classes (which is iota)
- The character after that should match class 1 of the lookahead classes (and that class contains all the greek letters)
- And if the match is successful, do absolutely nothing.
Press [OK]
and[Add Subtable]
for the final rule.
This rule does have substitutions -- we want to take the two characters and convert them into a ligature. So Press [New]
under the sequence position list, we want to start at the first character (sequence position 0) and apply the ligature we called "WORD":
So if anything doesn't match the first two rules, and does contain a kappa followed by an iota, it must be a two letter stand-alone greek word. And we want to apply our ligature to it.
Now we are done. Press a series of [OK]
s until all the dialogs have been accepted.
Once you have created your lookups you may test the result in the metrics view.
(This example was provided by Apostolos Syropoulos)


| Package | flare.animate |
| Class | public class Scheduler |
By default, the Scheduler issues updates to all scheduled items each
time the Flash Player advances to the next frame, as reported by the
Event.ENTER_FRAME
event. To instead set the update interval
manually, see the timerInterval
property.
| Property | Defined by | ||
|---|---|---|---|
| instance : Scheduler
[static][read-only] The default Scheduler instance.
| Scheduler | ||
| timerInterval : Number
Sets the timer interval (in milliseconds) at which the scheduler
should process events.
| Scheduler |
| Method | Defined by | ||
|---|---|---|---|
|
Scheduler(lock:Class)
Creates a new Scheduler--this constructor should be not used;
instead use the
instance property. | Scheduler | ||
|
add(item:ISchedulable):void
Adds an object to the scheduling list.
| Scheduler | ||
|
cancel(id:String):Boolean
Cancels any scheduled object with a matching id.
| Scheduler | ||
|
isScheduled(id:String):Boolean
Indicates if an object with the given id is currently in the
scheduler queue.
| Scheduler | ||
|
lookup(id:String):ISchedulable
Looks up the scheduled object indicated by the given id, if any.
| Scheduler | ||
|
remove(item:ISchedulable):Boolean
Removes an object from the scheduling list.
| Scheduler | ||
|
tick(event:TimerEvent):void
Frame/timer callback that invokes each scheduled object.
| Scheduler |
| instance | property |
instance:Scheduler
[read-only]The default Scheduler instance.
Implementation public static function get instance():Scheduler
| timerInterval | property |
timerInterval:Number
[read-write]Sets the timer interval (in milliseconds) at which the scheduler should process events.
Implementation public function get timerInterval():Number
public function set timerInterval(value:Number):void
| Scheduler | () | constructor |
public function Scheduler(lock:Class)
Creates a new Scheduler--this constructor should be not used;
instead use the instance
property.
lock:Class — a lock object to emulate a private constructor
|
| add | () | method |
public function add(item:ISchedulable):void
Adds an object to the scheduling list.
Parametersitem:ISchedulable — a schedulable object to add
|
| cancel | () | method |
public function cancel(id:String):Boolean
Cancels any scheduled object with a matching id.
Parametersid:String — the id to cancel
|
Boolean — true if an object was found and cancelled, false otherwise
|
| isScheduled | () | method |
public function isScheduled(id:String):Boolean
Indicates if an object with the given id is currently in the scheduler queue.
Parametersid:String — the id to check for
|
Boolean — true if an object with that id is currently scheduled,
false otherwise
|
| lookup | () | method |
public function lookup(id:String):ISchedulable
Looks up the scheduled object indicated by the given id, if any.
Parametersid:String — the id to lookup
|
ISchedulable —
the scheduled object with matching id, of null if none
|
| remove | () | method |
public function remove(item:ISchedulable):Boolean
Removes an object from the scheduling list.
Parametersitem:ISchedulable — the object to remove
|
Boolean — true if the object was found and removed, false otherwise
|
| tick | () | method |
public function tick(event:TimerEvent):void
Frame/timer callback that invokes each scheduled object.
Parametersevent:TimerEvent — the event that triggered the callback
|


Reserve accomodation
Name:
Surname:
Type of accomodation:
Hotel
Villa
Village house
Number of nights:
3
5
7
Phone:


--- title: Design 101, from a Non-Designer date: 2017-09-25 hero_image: writing/design-101.png hero_style: large featured_image: writing/design-101-cover.png medium_url: https://medium.com/@danrschlosser/design-101-from-a-non-designer-a383e20dbfcb ---
For many, design can seem like magic — a dark art that only few can master. It can be intimidating to learn, especially since many people think that design sense is innate: either you’re born with it or you’re out of luck. (Not true.)
Disclaimer: I’m not a designer. I’m an engineer and product manager but I’ve picked up a few tricks from my colleagues that have helped me hold my own in design reviews and projects.
My perspective is that becoming an advanced designer requires years of practice but that the basics of design is like learning guitar: You only need to learn four simple chords to play a lot of the music from the past 50 years. I’ve collected a few equivalent design fundamentals that have served me well. Most of the examples I’ll use here are from web design (my wheelhouse), but my hope is that you’ll find them broadly applicable.


Manage the creation of stunning brand assets.
Research the market, competitors, and trends using Python/Spark. (Recent data-ing)
Custom and advanced analytics on campaigns to build growth marketing models.
Have led the companies I've worked for to millions in growth with an eye toward efficiency.


‘Like a general orders his soldiers’: Barbers says caseless arrests vs vapers lawful
Contradicting lawyers in the government, dangerous drugs House committee chair Robert Ace Barbers believes that the President’s verbal e-cigarette ban is enough to consider as effective as a written executive order
by Michelle AbadSubscribe
Email Address
Newsletters
- Glenda Gloria's Take this Tuesday
- Huddle by Miriam Grace Go
- The Newsbreak Agenda by Chay Hofileña
- Sometimes, all you need is video by Lilibeth Frondoso


{{ page.title }}
{{ page.date | date_to_string }} {{ content }}Go back to contents, contact me via email or find me at Twitter if you have a comment.
--- layout: default ---
Go back to contents, contact me via email or find me at Twitter if you have a comment.


OpenSolaris
Collectives
Discussions
Documentation
Download
Source Browser
Free CD
Log-in
|
en
Project rm
:
Resource Pools
>
Usability Enhancements
Top Menu
Show
:
Comments
Attachments
History
Information
Print
:
Print
Print preview
Export as PDF
Export as RTF
Export as HTML
Export as XAR
Wiki code for
Usability Enhancements
Hide Line numbers
1: == Enhancing the usability of Resource Pools 2: 3: === Overview 4: 5: This topic discusses the current usuability concerns with the pools administrative interfaces, and proposes changes to address them. Please send 6: comments on this topic to [](rm-discuss@opensolaris.org). 7: 8: === Evalution 9: 10: Users evaluating Solaris Containers have expressed usability difficulties 11: when attempting to configure Resource Pools ~(via poolcfg~(1m~)/pooladm~(1m~)~) in order to partition cpu resources among Zones. 12: 13: Users are particularly interested in using Resource Pools with Zones 14: because of the strong process/processor-set binding which takes place when 15: a Zone is bound to a Resource Pool. This binding has been recognized by some 16: ISV’s which license software per cpu. In the future customers will be further 17: interested in using Resource Pools as it is the framework through which memory 18: and swap partitioning will be made available. 19: 20: Users have expressed satisfaction the the Zones administrative interfaces 21: ~(zonecfg~(1m~)/zoneadm~(1m~)~), and would most likely prefer a similar interface for configuring pools. Both the new Zones and SMF administrative interfaces introduced in Solaris 10 include interactive modes along with built-in help and context sensitive modes, all of which greatly enhance usability, especially for new users. 22: 23: By evaluating the Resource Pools administrative interfaces, a number of usability issues can be raised: 24: 25: ====1. Most property names and values are accepted 26: 27: Incorrect property ~(misspelled name, invalid value~) produces no error message. By contrast, zonecfg will complain about unknown property names or invalid values assigned to properties. 28: 29: ====2. There is no verbose validation. 30: 31: There are few useful error messages when modifying a configuration, and there are no useful error messages when committing a configuration fails. Both zonecfg~(1m~) and zoneadm~(1m~) offer validate commands which will generate lists of configuration errors. 32: 33: ====3. The need to set min and max on resource is not intuitive to customers not using Dynamic Resource Pools. 34: 35: Most Customers just want to set a resource set’s size and in fact they specifically cannot set the size. This is confusing. Also, attempts to simply transfer cpus into a pset will fail if the administrator does not first modify pset.min and pset.max. poolcfg~(1m~) could automatically adjust a resource set’s min and max properties to accommodate administrative actions. poolcfg~(1m~) could also provide a property by which the administrator could suggest the desired size. 36: 37: ====4. There is no interactive mode with built-in help. 38: 39: Failed commands do not produce context sensitive error or usage message. There is no help listing all available commands, or supported property names and values. 40: 41: ====5. The need to quote each command is error-prone. 42: 43: This is not a command based interface like zonecfg and svccfg, confusing customers that think it is. 44: 45: ====6. The need to use parenthesis when setting properties. 46: 47: This does not get along with most shells, producing errors when improperly escaped or quoted. 48: 49: ====7. There is no context sensitive modes. 50: 51: By contrast, zonecfg and svccfg via the various select/add/end commands that 52: produce context sensitive help and error messages. 53: 54: ====8. Many commands are needed to create a pool, pset, mset, and set up associations. 55: 56: These commands include "create", "modify", "associate", and optionally "transfer". Each command has a different syntax which must be learned. The "transfer" command has two forms depending on what is being transferred ~(specific cpus, or quantities of cpu or memory~). In contrast, Zones can be configured using just the "create" and "set" commands, and the admin is specifically instructed to use the "create" command when entering interactive mode. zonecfg also has "verify" and "commit" commands which are automatically applied when the interactive mode is terminated. 57: 58: ====9. Transferring cpuids, or quantities of cpu,on a static config works, but is meaningless. 59: 60: These cpus are not used when the configuration is instanciated on the system. Instead transfering cpus only has the effect of indirectly modifying a psets’s size, which again is not used when the configuration is instanciated on the system. This is confusing. 61: 62: ====10. The need to explicitly enable pools before pools can be configured is an unnecessary administrative step. 63: 64: There are multiple issues here. 65: * Pools could be enabled by default. 66: * Simply working with a static config should not require that pools are enabled. 67: * Some commands (such as "pooladm -c", could automatically enable pools). 68: 69: ====11. Listing of the current configuration in presented in an overly verbose and hard to read format. 70: 71: There are no concise table-formatted output modes for viewing the current configuration. 72: 73: ====12. Properties with implied values (such as system.allocate-method) do not exist by default even though their implied meaning is in affect. 74: 75: This is uninformative to the user and results in an incomplete list of the actual configuration. 76: 77: ====13. Each property is named with a property prefix (system.//, pool.//, pset.*) matching the resource type that the property is on. 78: 79: This is implementation specific information which to the administrator is redundant. Property types for properties that already exist must also be entered, which is again redundent. 80: 81: Example: 82: 83: {{{ 84: modify pset pset~_default ~( uint pset.min = 4 ~) 85: }}} 86: 87: This command could be reduced to: 88: 89: {{{ 90: modify pset pset\//default ~( min = 4 ~) 91: }}} 92: 93: ====14. The Resource pools configuration terminology is confusing and inconsistent when compared to itself and to the Zones configuration terminology. 94: 95: The terms "static" and "dynamic" configuration have no analog in other subsystems. The term "dynamic" refers to both the state of the running system, as well as to "dynamic" pools, which are pools that are reconfigured periodically depending on administrative objectives. The term "commit" is used by zones meaning to validate and save the configuration, while Resource Pools use the term "commit" to refer to instanciating the configuration on the running system. 96: 97: ====15. Setting DRP objectives is error-prone. 98: 99: DRP objective properties can be misspelled and can be given invalid values, with no immediate negative feedback or error messages. 100: 101: === Proposed changes/enhancements to poolcfg 102: 103: This topic proposes the following modifications to poolcfg in order to eliminate the usability points above. 104: 105: ====A. Implied types and prefixes when specifying properties and entity names. 106: * When setting a property with the modify or create command, if the property already exists, it will not be necessary to specify its type. 107: * When setting a property, it will not be necessary to include the "entity." prefix in the property name. Example, the property "pset.min" and be specified using "min". 108: * When specifying and entity, it will not be necessary to include the entity prefix "entity\//". For example, the entity "pset~_default" can be specified using just "default". 109: 110: ====B. Consolidation of the create, modify, associate, and transfer commands command into the create and modify commands. 111: 112: This is accomplished by allowing resource and component associations to be declared as properties: 113: 114: {{{ 115: create | modify entity name ~[ "~(" expression [;expression...] "~)" ~] 116: }}} 117: 118: Where: 119: 120: {{{ 121: expression == property = value | entity = name | component = name~[,name...~] 122: }}} 123: 124: When a configuration is instanciated on the system (during boot, or during "pooladm -c", libpool will first attempt to transfer the specified cpu components to the pset resource before it begins dealing out remaining components among resource sets. Example, to create a pool with a specific set of cpus with the current interfaces: 125: 126: {{{ 127: # poolcfg -f - <<EOF 128: create pset foo ~(uint pset.min = 2; uint pset.max = 2~) 129: transfer to pset foo ~(cpu 1; cpu 2~) 130: create pool bar 131: associate pool bar ~(pset foo~) 132: EOF 133: }}} 134: 135: With the proposed enhancements: 136: 137: {{{ 138: # poolcfg 139: poolcfg:> create pset foo ~( cpus = 1,2 ~) 140: poolcfg:> create pool bar ~( pset = foo ~) 141: poolcfg:> <EOF> 142: }}} 143: 144: ====C. Introduction of "res" as a read/write property on resource sets. 145: 146: When a configuration is instanciated ~(pooladm -c~), each resource set will receive "res" resources before the remaining resources are dealt out among sets. 147: 148: When the "component = name~[,name...~] expression is used to specify the components in a resource set, the "res" property is automatically updated to match the number of cpus specified. 149: 150: Example: 151: 152: {{{ 153: modify pset foo ~( cpus = 0,1,2,4 ~) 154: }}} 155: 156: Will automatically set "res" equal to 4. 157: 158: Example, these commands will currently create a pool with two cpus: 159: 160: {{{ 161: # poolcfg -f - <<EOF 162: create pset foo ~(uint pset.min = 2; uint pset.max = 2~) 163: create pool bar 164: associate pool bar (pset foo) 165: EOF 166: }}} 167: 168: In the proposed new interfaces, this is sufficient: 169: 170: {{{ 171: # poolcfg 172: poolcfg:> create pset foo ~( res = 2 ~) 173: poolcfg:> create pool bar ~( pset = foo~) 174: poolcfg:> <EOF> 175: }}} 176: 177: ====D. Elimination of ordering constraints on resource.min and resource.max properties by adding unspecified values. 178: 179: min and max properties are only used by: 180: 181: * "pooladm -c", to implement resource dealing to resource sets 182: * poold(1m), as constraints on moving resources among sets 183: * Dynamic Reconfiguration, as a bounds on shrinking resource sets to allow for the removal of system resources. 184: 185: In all cases, reasonable values can be assumed for min and max when they are unspecified. This would avoid confusing errors when attempting to specify simple configurations. 186: 187: Example, user specifies pset.min without specifying pset.max, currently: 188: 189: {{{ 190: # poolcfg -c ’modify pset foo (uint pset.min = 2)’ 191: poolcfg: put property pset.min failed: Error putting property 192: }}} 193: 194: There is no real reason for this to fail. If pset.min is 2 and pset.max is unspecified (or less than 2), the correct solution in all cases above is just to treat the configuration as if pset.max = 2. 195: 196: ====E. Multi-line create/modify commands using set/remove/cancel/end. 197: 198: Omitting the ()’s after a create or modify command will cause poolcfg 199: to apply the following commands to the given entity, until either the 200: "end" or "cancel" commands are given. The "remove" command can be 201: used to remove a property, association, or component specification. 202: 203: Example, for an existing pset, remove specified cpus and declare a cpu range: 204: 205: {{{ 206: # poolcfg 207: poolcfg:> modify pset foo 208: poolcfg:pset foo> remove cpus 209: poolcfg:pset foo> set min = 1 210: poolcfg:pset foo> set max = 4 211: poolcfg:pset foo> set importance = 10 212: poolcfg:pset foo> end 213: poolcfg:> set allocate-method = "importance based" 214: poolcfg:> <EOF> 215: }}} 216: 217: The "set"/"remove" commands act on the currently entity, and can be 218: used to manipulate properties, resource associations, and component 219: associations. If there is no current entity, the system entity is modified. 220: 221: Example, create a new pool with a new pset containing two cpus. 222: 223: {{{ 224: # poolcfg 225: poolcfg:> create pset foo 226: poolcfg:pset foo> set res = 2 227: poolcfg:pset foo> end 228: poolcfg:> create pool bar 229: poolcfg:pool bar> set pset = foo 230: poolcfg:pool bar> end 231: poolcfg:> <EOF> 232: }}} 233: 234: ====F. Addition of the "verify" command. 235: 236: The verify command checks that the entity currently selected entity can be instanciated on the system. If no entity is selected, the entire configuration is checked. 237: 238: ====G.  If -c is specified, the configuration is also instanciated on the live system as if "pooladm -c" was run. The commit command autmatically does a "verify" first, and prompts the user if the verify fails, poolcfg is in interactive mode, and the force ~(-F~) flag is not. 245: 246: ====H. Addition of the "revert" command. 247: 248: The "revert" command throws away the changes made since the last successful commit command or since poolcfg was invoked. 249: 250: ====I. Addition of the "export" command. 251: 252: {{{ 253: export ~[-f output-file~] 254: }}} 255: 256: The export command writes the configuration currently being edited to standard output, or output-file if the -f option is specified. The output includes all changes since the last commit. 257: 258: ====J. Addition of the "exit" command 259: 260: {{{ 261: exit ~[ -f ~] 262: }}} 263: 264: The exit command terminates poolcfg when in interactive mode or processing a script file. If there are unsaved changes and the -F option is not specified, the user is prompted to verify and save changes. 265: 266: ====K. Extend "destroy", "rename", and "info" commands to be context sensitive. 267: 268: If an entity is selected by a "create" or "modify" command, these commands will operate on the selected entity if given no arguments. 269: 270: Example: 271: 272: {{{ 273: # poolcfg 274: poolcfg:> modify pset foo 275: poolcfg:pset foo> rename bar 276: poolcfg:pset bar> 277: }}} 278: 279: ====L. Addition of "help" command. 280: 281: Help will give detailed help for all commands. "help set" will list all meaningful properties which can be set on the currently selected (by a create or modify command), or all entity types if no entity is selected. 282: 283: ====M. Changes to output of "info" command 284: 285: The info command output will have page tabbing when in interactive mode. It will also not require an argument when an entity is selected. 286: 287: Example: 288: 289: {{{ 290: # poolcfg 291: poolcfg:> modify pset pset~_default 292: poolcfg:pset pset~_default> info 293: pset pset~_default: 294: int sys~_id -1 295: boolean default true 296: uint res 1 297: uint min 1 298: uint max 65536 299: string units "population" 300: string comment "" 301: cpu 0: 302: int sys~_id 0 303: string comment "" 304: string status "on-line" 305: cpu 1: 306: int sys~_id 1 307: string comment "" 308: string status "on-line" 309: poolcfg:pset~_default> 310: }}} 311: 312: ====N. New "list" subcommand. 313: 314: {{{ 315: list [ pools | psets | msets | cpus ] 316: }}} 317: 318: This subcommands lists entities in the pools configuration in a table format. "-" represents an unspecified value. 319: 320: Examples: 321: 322: {{{ 323: # poolcfg list pools 324: NAME PSET MSET 325: pool~_default pset~_default mset~_default 326: pool~_foo pset~_foo mset~_foo 327: pool~_bar pset~_bar mset~_bar 328: }}} 329: 330: {{{ 331: # poolcfg list psets 332: NAME MIN MAX RES LOCALITY CPUS 333: pset~_default 1 - - true - 334: pset~_foo 1 4 - true 3,4 335: pset~_bar - - 1 true - 336: }}} 337: 338: ====O. Addition unit modifiers. 339: 340: Support for binary unit modifiers when setting/displaying integer values. 341: Example: 342: 343: {{{ 344: poolcfg -c "create mset foo ( res = 100mb )" 345: }}} 346: 347: ====P. Automatic enabling of pools. 348: 349: With no configuration present, invoking poolcfg should generate a default config as if pools where enabled. If this config is committed, then pools will automatically enabled. If the configuration contains any dynamic pools objectives, dynamic pools will also be enabled. 350: 351: Examples: 352: 353: * Create a configuration with two pools with unique msets, sharing a pset which should use cpus on the same core if possible: 354: 355: {{{ 356: # poolcfg 357: poolcfg:> create mset A ( res = 100mb ) 358: poolcfg:> create mset B ( res = 100mb ) 359: poolcfg:> create pset shared ( res = 4 ) 360: poolcfg:> create pool A ( pset = shared , mset = A ) 361: poolcfg:> create pool B ( pset = shared , mset = B) 362: poolcfg:> commit -c 363: poolcfg:> <EOF> 364: }}} 365: 366: * Here is the same example, using the "add/end", and specifying specific cpus instead of setting the cpu quantity (res): 367: 368: {{{ 369: # poolcfg 370: poolcfg:> create mset A 371: poolcfg:mset A> set res = 100mb 372: poolcfg:mset A> end 373: poolcfg:> create mset B 374: poolcfg:mset B> set res = 100mb 375: poolcfg:mset B> end 376: poolcfg:> create pset shared 377: poolcfg:pset shared> set cpus = 4,5,6,7 378: poolcfg:pset shared> end 379: poolcfg:> create pool A 380: poolcfg: pool A> set pset = shared 381: poolcfg: pool A> set mset = A 382: poolcfg: pool A> end 383: poolcfg:> add pool B 384: poolcfg:pool B> set pset = shared 385: poolcfg:pool B> set mset = shared 386: poolcfg:pool B> end 387: poolcfg:> commit -c 388: poolcfg:> <EOF> 389: 390: }}}
Search
Collectives
Community Group
Academic and Research
Accessibility
Advocacy
Appliances
Approachability
Architecture Process and Tools
BrandZ
Chinese Users
Community Advisory Board
Databases
Desktop
Device Drivers
Distribution
Documentation
DTrace
Emerging Platforms
Fault Management
Games on OpenSolaris
HA Clusters
HPC Developer
Installation and Packaging
Internationalization and Localization
Laptop
Logical Domains
Modular Debugger (MDB)
Networking
NFS
Observability
OpenSolaris Governing Board (OGB)
OpenSolaris Printing
OS/Net (ON)
Performance
Power Management
PowerPC
Security
Service Management Facility (smf(5))
Software Porters
Solaris Volume Manager
Storage
Systems Administration Community Group
Testing
Tools Home
Unix File Systems (UFS)
Website Community
X Window System
Xen
ZFS
Zones
Project
ADSL Modem Enhancement
ARC Process Definition
ARM Platform Port
Automatic Data Migration
BIND Update
Bluetooth Stack & Drivers
Brocade FC HBA - Initiator
Brocade FC HBA - Target
Brussels - unified network link configuration
Caiman, Solaris Install Revisited
Celeste
Český portál
Chime Visualization Tool for DTrace
CIFS client for Solaris
CIFS Server
Clearview: Network Interface Coherence
Cluster Agent: Informix Dynamic Server
Cluster Agent: OpenSolaris Container
Cluster Agent: OpenSolaris xVM
Cluster Agent: Oracle E-Business Suite
Cluster agent: PostgreSQL
Cluster Agent: Samba
Cluster Agent: Tomcat
CMT
Coarse Data Flow Parallelism
Colorado: Open HA Cluster on OpenSolaris
Command Assistant
Common Array Manager
Companion - /opt/sfw: Free and Open Source software
COMSTAR: Common Multiprotocol SCSI Target
Content
Contest
CPU Observability
Credentials Process Groups
Crossbow: Network Virtualization and Resource Control
Crypto KMS Agent Toolkit
Cryptographic Framework
Data Migration Manager
Data Tethers
Deutsches Portal
Device Detection Tool
Device Driver Utility
Device Manager
Device Mapper
Direct Rendering Infrastructure & 3D drivers
DTrace Guide
Duckwater: Simplified name services management
Easy Tools
Emancipation
Emulex Fibre Channel Device Driver
Emulex Advanced Ethernet Device Driver
Enable/Enhance Solaris support for Intel Platform
Enhance the support of USB webcams
Enhanced SMF Profiles
Enhancements for AMD-based Platforms
Erlang DTrace Integration
Ethernet bridge module for Solaris
Evaluate Conary
Events Registry
Ext3 file system support
F/OSS Package Base
Facilitation
Fibre Channel over Ethernet
Fine Grained Access Policy (FGAP)
Fingerprint Authentication
Flexible Mandatory Access Control
Forensic Tools
Fully Open X Project
Fuse on Solaris
gcore
Generic Machine Check Architecture Improvements
Google SOC
HA-JBoss
HA-MySQL
Hadoop Live CD
Hitachi
HoneyComb Fixed Content Storage
HPC Stack
Image Packaging System
Improved Performance MIB
Indiana
Innovation Awards
Input Method
Intel Graphics
Internet Key Exchange, version 2
Interrupt Resource Management
IP Datapath Refactoring
IP over Infiniband
IPsec Tunnel Reform
iSCSI Extensions for Remote DMA (iSER)
iSNS Server
JeOS - Just enough Operating System
JKstat - a java binding for libkstat
Journaled File System (JFS)
K Desktop Environment
Kerberos
Kernel Sockets
Kernel SSL Enhancements
Key Management Framework
Korn Shell 93 integration/migration project
Labeled IPsec
LatencyTOP
Layer 2 Filtering
LDoms Manager
Lending
libMicro - portable microbenchmarks
Link Layer Discovery
Live Media: Technologies for distributions running from CD and other media
Locale Data
lofi compression and cryptography support
lx64 brand
Media Management System
Mega_sas
Mexico
MilaX minimal Live Distribution
MIPS Platform Port
Mozilla DTrace
MRSL.NONsharedDevice
Multi-lingual Glossary
Multi-pathing software (MPxIO)
Multiple disk sector size support
Multiple DOI
Muskoka: An open repository for OpenSolaris technical content
Navigator
Nemo: A Framework for High-Performance Networking
Network Auto-Magic
Network Data Management Protocol
Network MIBs
Network Performance Projects
Network Storage
Network Time Protocol (NTP)
Nevada Globalization
New Design of 4over6 Mechanism Based on OpenSolaris
NFS RDMA transport update and performance analysis
NFS Server in non-Global Zones
NFS version 4.1 pNFS
NFSv4 namespace extensions
Nightingale: Port Songbird to OpenSolaris
NPort ID Virtualization (NPIV)
NUMA
Object Storage Device (OSD) support for Solaris
OHACGE Script Based Plug-in
ON/Nevada (ONNV) Project
Open Development Infrastructure
Open HA Cluster Utilities
Open Sound System
OpenGrok
OpenPegasus CIM Server
OpenRTI
OpenSolaris Busybox
OpenSolaris Desktop
OpenSolaris Hispano
OpenSolaris Security Audit
OpenSolaris support for the QEMU processor emulator: host and guest
PEF: Packet Event Framework
Performance Wrappers
Pkgfactory
Polski Portal
Portail Francophone
Portal Brasil
Portals
Power Management Usability Interfaces
Presto: Automatic Printing Configuration
Printable Many Page Solaris Manuals
Promise SuperTrak RAID HBA Driver
QLogic Converged Network Adapter GLDv3 NIC Driver
Quagga Routing Protocol Suite Integration
RAID Configuration Utility
RBridge (IETF TRILL) support
RDMA Offload Framework
Reno: Login Process Enhancements for Interop
Resource Management
s10brand
SAM/QFS
SCM Migration Project
SCSI RDMA Protocol
SDcard Drivers
Sensor Abstraction Layer
Session Initiation Protocol
SFW
Shell: bourne shell, korn shell, C shell, etc.
Sierra: Intel WiFi Chipsets Support
Simple Panels
SM-HBA Based SAS HBA Management
SMF Documentation
Solaris iSCSI Target
Solaris PowerPC Port
SourceJuicer
Sparks: name service switch/nscd enhancements
Squashfs
Star integration/migration project
Starfish
Starter Kit
Storage Power Management
Sun Security Toolkit
Sun StorageTek Availability Suite
Support for OpenFabrics User Verbs / API on OpenSolaris OS
Support gcc4/GCCfss in Solaris
Suspend/Resume
SVR4 Packaging
Systemz
Tamarack: Removable Media Enhancements in Solaris
Tesla: OpenSolaris Enhanced Power Management
Test Development
Tickless Kernel Architecture
TIPC
Trademarks
Trusted networking interface policy database for Trusted Extensions
Trusted Platform Module support
Use Case
Validated Execution Project
Virtual Console
Virtual Network Machines
Visual Panels
Visualization for HPC
Volo
VRRP: Virtual Router Redundancy Protocol Implementation
VSCAN service
Web Stack
Website
Winchester: Schema mapping and ID mapping for AD Interoperability
Wireless USB Support
Wireless Wide Area Network
X Consolidation
x86 Generic FMA Topology Enumerator
Xen Gate
Xfce: A lightweight desktop environment
ZFS Boot and Install
ZFS on disk encryption support
Zone Manager
Zone Statistics
Русский портал
البوابة العربية
भारतीय पोर्टल
中国门户
日本ポータル
한국 포탈
User Group
Adelaide
Argentina
Arizona
Atlanta
Baltimore-Washington
Bangalore
Bangkok
Bangladesh
Beijing
Bélem
Berlin
Bhimavaram
Bloomington
Campus Ambassadors
Capital Region
Cardiff
Ceara
Charlotte
Chengdu
Chennai
Chihuahua
Chile
Cleveland
Colombia
Columbus
Connecticut
Cracow
Czech
Dallas/Ft. Worth
Danish
Delaware
Edinburgh
Egypt
Finland
Florida
Front Range
FuZhou
Great Lakes
Greece
Hangzhou
Hawaii
HeFei
Houston
Hong Kong
Hyderabad
Indonesia
Irish
Israel
Italian
Jinan
Jogja
Kabul
Kansas City
Latvia
London
Madurai
Manchester
Mato Grosso
Melbourne
Minas Gerais
Minnesota
Montreal
Moscow
Mumbai
Munich
NEA
Netherlands
New England
New York City
New Zealand
NIT Hamirpur
Noroeste
Nuremberg-Erlangen
Oklahoma City
Osnabrück
Peru
Philadelphia
Piaski
Pittsburgh
Porto Alegre
Puget Sound
Pune
Queensland
Rio de Janeiro
Research Triangle Park
Romania
Russia
San Antonio
San Diego
San Francisco
São Paulo
Scottish
Serbia
Shanghai
Shenzhen
Silicon Valley
Singapore
Slovak
South African
Southern Connecticut
St. Louis
Stavanger
Sweden
Switzerland
Sydney
Szczecin
Taiwan
Tecum
Thames Valley
Tokyo
Toronto
Trondheim
Tulsa
Turkey
Ufa
Ukraine
University of Melbourne
Vale do Paraíba
Vancouver
Venezuela
Welsh - Cymru
Wisconsin
Xi'an
Subsites
Code Reviews
Code Repositories
Package Search
Bugster
Bugzilla
Test Machines
Planet
Mailing Lists
Elections & Polls
ARC Case Logs
Source Juicer
Package Factory
User Authentication
Project rm Pages
Documentation and Examples
Resource Pools
Memory Sets
Usability Enhancements
Resource Controls
CPU caps
System V IPC
RM for Zones


Habits vs. Tasks
Whether you realize it or not, you’re full of habits that you hew to every single day. Your morning routine, bedtime ritual, and news consumption while commuting may all play out exactly the same each day. When something is so natural and comfortable it doesn’t need to be recorded and managed in your trusted system because you are the trusted system. Understanding how your mind and body separates habits with things you may categorize as tasks is important for your productivity and organization.
Habits
hab·it
noun
1. an acquired behavior pattern regularly followed until it has become almost involuntary.
A great example of a habit is your morning ritual. You’ll wake up and involuntarily hop out of bed, make the bed, brush your teeth, and do the rest of the things that you do every morning. The habit is so recurring that it has taken your body over and handles all the thinking and execution for you.
Tasks
task, tahsk
noun
1. a definite piece of work assigned to, falling to, or expected of a person; duty.
As we’ve discussed, a task is a single action that has to get done. Your morning ritual habit is technically comprised of multiple tasks. Breaking it down we can find a handful of specific items that have clear outcomes — but we don’t understand our habits as multiple tasks; they’re merely one big conglomerate known as, "the morning ritual".
Evolution: Task ⇨ Habit
There will come a point when you get so involved with your trusted task manager that you record everything that has to get done. You may find yourself scheduling and setting deadlines for things like sleeping, eating dinner, and commuting. It’s okay to keep track of all the things you’re doing and going to do but when there’s a more efficient and effective method it’s your duty to optimize the system.
When you notice things are going into the task manager grouped together and always at the same time and/or place, it may be a sign to form a habit. It’s redundant and time-consuming to check off, "shred documents before leaving the office" or, "brush teeth before bed" ever single day. Managing the actual task of shredding and brushing your teeth is going to accumulate to a significant chunk of time that could’ve been avoided if you formed habits that took care of these things on auto-pilot.
This is different from a recurring task like, "add hours and email invoice" that has to be done every 14 days. No one is expected to habitually take care of something that infrequent and so easily forgettable. However, some habits for me may be definite daily or weekly reminders for you. Many people need a bound weekly task that forces them to review their task manager when I take care of that completely on my own.
Single-Step & Multi-Faceted Habits
Not all tasks are created equal — as we’ve discussed, many times a task will turn into a project. This is not a problem and in fact easier to understand, if slightly more difficult to maintain, than if we weren’t looking at a project. Although projects look more complex, they’re easier to execute because of the well-defined steps. This translates well to habits because there are almost always multiple steps that have to be executed.
Habitual projects are summed up as routines:
- Arrive at the office
- Greet Debbie, the secretary
- Start brewing your fancy imported coffee
- Check the office bulletin for any new updates
- Fire up your computer and email
- Begin the day
Easily a 5 - 20-minute process was all understood and executed without a single reference to the task manager.
Notice that checking email isn’t included in the systematized project. Checking your email and inevitably responding to and creating action items for emails is a genuine task by itself and may require a scheduled block of time. Although maintaining email seems like a habit and may very well be, the time it takes is too variable to rely on. Even habits that are so significant should be managed unless you want to find yourself at lunchtime asking where the day went, how you missed that 11 am-deadline, and why you’re still responding to email.
 It may sound luxurious to be free of thought for half the day while you’re taking care of some of these tasks, but this is exactly how things fall through the cracks
Commuting, for example, requires you to be in commute mode. If you’re driving to the office you’re in driving to work mode, more specifically. You don’t understand your commute as a set of different turn-by-turn instructions — each as its own unique task on your task manager. You understand it as one habitual drive.
There may be situations where there are so many things that have to be done a habit is just impossible. If your morning routine lasts two hours and involves communicating with people, obtaining certain items, and more, a checklist may be in order. It’s going to be an interesting divide between habits, checklists, projects, and actions, but there’s no one-size-fits-all solution and every person will require unique methodologies.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/Universal.20algebra.html ---
Hello!
I would like to know if universal algebra would be interesting for Lean? It could factorize a lot of definitions such as closure, stability, morphisms and other stuff.
Kindly
Universal algebra would be interesting to investigate, but I would put a big warning if you are investigating this for refactoring purposes, because there is a much higher bar for usability in this case. Just because something is a special case of something else in maths doesn't mean it is actually useful as a generalization in formal maths
It doesn't hurt to formalize the general theory and look into applications when it is already mostly fully formed, though. What is the actual scope of theorems that can be proven in this context?
What do you mean by higher bar of usability?
I mean that it shouldn't be harder to apply the general theorem in the specific instance than it is to prove the theorem directly in the specific instance
the shallower the theorems and the more convoluted the generalization the harder it gets to meet this criterion
The best generalizations are those where the application overhead is minimal and there are still nontrivial theorems to be had. Things like the elementary theory of rings and groups are good examples of this
@Hamza Maimoune As a crazy example: in Lean we have the notion of group
and add_group
. And we automatically duplicate all theorems about groups to theorems about additive groups.
The only difference: notation
Did you copy paste the theorems?
Basically (in an automated way)
This is done in order to minimize application overhead
Even though the theories of multiplicative and additive groups are obviously isomorphic, the application overhead of using an additive theorem on a multiplicative group via a translation is sufficiently high that it is easier to just prepare all the theorems in both contexts
Therefore, universal algebra would induce a lot of application overhead? If we would implement it, we wouldn't use it to deduce properties on specific algebras, right?
I'm not saying it necessarily would, only that if you are seriously targeting using it to generalize existing theorems you have to pay very close attention to application overhead and do everything you can to keep it reasonable
You don't necessarily have to worry about this for the first pass, though. When setting up the initial theory, just do things in the mathematically natural way, and leave application to specific algebras until later
But easy application to diverse fields is certainly not something that happens for free unless you prepared everything with this in mind beforehand
Okay thank you for your answer
I'll try to dive into this to see if there is anything useful
@Hamza Maimoune there are two subtly different things here.
In the real world, almost no mathematicians knows anything about universal algebras, because they are not useful for real world mathematics: the benefits are not worth the effort. This fact is not necessarily relevant to formal mathematics. In the real world almost nobody knows about filters. The benefits are not worth the efforts because mathematicians in the real world have no trouble at all saying that everything they prove for limits of sequences hold, mutatis mutandis, for limits of functions etc. But in the formal mathematics world, filters are definitely worth the effort. So it could be that universal algebras are worth the effort in formal mathematics.
But now comes the second aspect of the discussion. Formalized mathematics happen in a formal context, here a flavor of dependent type theory, and in a given software, say Lean but the same would apply elsewhere. Hence there are usability issues, coming from flaws in the foundational theory or in the software. And this has to be weighted against the theoretical benefits. For filters everything is very usable. They blend easily into type theory, and translating back and forth between filters and epsilons is very easy. Hence they are everywhere in formalized maths. Proving theorems about limits of sequences of real numbers as special cases of super abstract theorems about filters is very easy.
Now consider abstract category theory. It's mostly useless in the real world of course (but nice to play with!). In mathlib we have a huge library of category theory, which comes with an gigantic usability barrier. As far as I know, we still have a total of zero specific lemma proved using a general theorem from the category theory library.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


ledger
/
net.corda.v5.ledger.services.vault
/
builder
builder
inline
fun
<
A
>
builder
(
block
:
Builder
.
(
)
->
A
)
:
A


FizzBuzz is a counting game. The rules are as follows:
Output a set of numbers (say, 1-15), but whenever a number is divisible by 3, you output Fizz instead. If it’s divisible by 5, you output Buzz instead. If it’s divisible by 3 and 5, you output FizzBuzz instead.
Enter a number to FizzBuzz up to:


PIT Transcriptor makes transcriptions for podcasters easy. It offers quick transcriptions with the ability to make and store quick edits that make the service faster and more tailored to you each time you use it.
Productivity in Tech (PIT) works with developers creating media-rich content for others. This comes in the form of digital marketing and consulting as well as editing and transcription services.


The entrance to SCP-1184 at the moment of discovery.
SCP-1184; the passage and the door are off-screen
Item #: SCP-1184-RU
Object Class: Euclid
Special Containment Procedures: The territory on which Mine ██-█████ ██████ is situated is to be enclosed with chain-link fence around the security perimeter. An observation post is to be erected next to the former mine constructions, to accommodate staff members of the Internal Security Department guarding the object, as well as engineer and research staff during scheduled works with the object.
Every other month all the constructions connected to SCP-1184 are to be surveyed by Engineering and Technical Service Department. If necessary, the mine crown and all the passages leading to the object are to be reinforced.
Sound and video recording equipment is to be placed inside SCP-1184; any changes inside the mine should be reported to the staff member in charge of the object.
Description: SCP-1184 is a room of unknown purpose, the only known entrance to which is located in former ██-█████ ██████ mine. At the moment of initial discovery the mine was abandoned due to its depletion which made further meaning lose economic sense. All former mine workers claimed that SCP-1184 had not previously existed.
According to the mine plans, a blind shaft which was previously used for transporting miners to the gallery level instead leads to SCP-1184. Getting to the level by any other means is not possible; the rest of the passages are strewn with refuse rock and can not be cleared out without collapsing the entirety of the underground passage system. SCP-1184 has the appearance of an old abandoned room with simple furnishings. The following is an up-to-date list of items that have been discovered inside SCP-1184:
- Several pieces of furniture and everyday objects with signs of age and wear; the only remaining label on a night-desk says that it was produced by Moscow Furniture Assembly Plant #2 in 1988
- Old speleological equipment
- A certain amount of food supplies (already spoiled at the moment of discovery), the date of manufacture is 1988
- ██████ ████'s diary (see Addendum)
It should be noted that a street can be seen through the only window inside SCP-1184 (possibly, [REDACTED] Street), however, a building which can offer such a view does not exist. All the attempts to open the window, break it, or leave the room by any other means have failed.
Also inside SCP-1184 is closed wooden door, which is impossible to open. Approximately once a day sounds of someone trying to open it can be heard from the other side; however, nothing happens apart from that.
Addendum-1184-A.
Excerpts from the document found inside SCP-1184 are provided below. The document itself is presumed to be a diary of one ██████ ████, who officially went missing in 1988.
I found a notebook here. That's a start. With my pencil it will at least allow me to make some notes about what's happening to me here.
My name is ██████ ████, I am an amateur spelunker. I went down here out of my interest of old abandoned mines, and here I am. Crap.
 I was going down the mine further and further, from one level to another. The lower I got, the more peculiar these mines looked. Haphazard, entangled, sometimes even without proper ventilation or proper support of the passages, as if they were dug by some idiots. I decided to go down a bit more, but this tunnel was the only way here. And in the end my hook slipped. At least I'm okay, that's good. But where did I turn up in the end?
I tried to escape this place. The room looks as good as new, only it seems abandoned. And I can't leave this place. There is no way I can climb up, un-strengthened walls will collapse, and if I fall from more or less decent height, broken bones will kill me. And I can't go outside, the windows and the door are as if made of steel. Luckily, I have a decent supply of food.
 I don't know how I didn't notice it previously. Will try getting out through it. It's already late today. I haven't been keeping track of time for a good while though, but I want to sleep.
I hope the batteries inside the flashlight won't die. It's strange, but the view out the window doesn't change. And there's no people. Although it's strange that this particular thing seems extraordinary to me in my situation.
 There are some caves out there. I saw Tom and Jerry standing in front of me, and then they jumped into the ceiling.  What is going on?
And I haven't found the exit. I thought I was walking forward, but turned up in front of this cursed place. I guess I am destined to die here.
Strangely, I don't need a flashlight. All the caves are lit with some omnipresent and soft light, dim as it may be.  And these hallucinations keep multiplying.
This is the last note in the diary. The subject's body and the key for the door were not found.
Addendum-1184-B: Test Log 1184-13
This experiment was provoked by D-14716's reaction to SCP-1184. During a scheduled descent the subject claimed that he sees no room there but a gallery level without any anomalies. After a brief discussion a decision was made to convoy D-14716 for conducting an experiment. The audio log of the conversations during the experiment is presented below.
Dr. Goodwin (in charge of the object): Ugh, comms check, does everybody hear me?
██████ (a staff member of Internal Security Department convoying D-14716): Loud and clear.
D-14716: Yes, doc.
Dr. Goodwin: What do you see, D-14716?
D-14716: You've already asked. I see an ordinary mine. Nothing special, except for this thug you've assigned to me
██████: Keep talking an I'll thug you some. I see only SCP-1184. No mine.
 I wonder how does he even have the ability to talk to you.
Dr. Goodwin: What do you mean? Explain yourself.
D-14716: I'm serious, he looks like a zombie. Is he shell-shocked or something?
██████: What is he talking about?
 Even a pot plant looks brighter.
After the discussion a decision was made to continue the experiment no matter the consequences.
Dr. Goodwin: Walk a little further and tell me what you see.
D-14716: Nothing. It's an ordinary mine.  He is just standing in the centre of the room!
Dr. Goodwin: Let's go on.
D-14716: Nothing special. For now. I have a very strong uneasy feeling though.
Dr. Goodwin: Ugh… hold on, we're having trouble with the video connection. We'll try to fix it, but you should go forward and tell me what you see.
D-14716: Oh, there are even more passages below, but they are filled with water. I don't need to go there, do I? I think that the equipment you gave me is hardly suitable for this.
Dr. Goodwin: Go ahead as far as you can. But don't go into the water, naturally…
D-14716: Okay. Here is… Wait, I think there is something moving up ahead. Hey, dude! Where did you come from and what are you doing here? Are you alri—
Dr. Goodwin: D-14716, respond. D-14716!
██████: Hey, doc, he's disappeared! He had just been standing in front of me, and now he's vanished!
No signs of D-14716 were discovered, he never responded again. The equipment the subject was carrying didn't broadcast anything. The experiment is considered to be finished.
'I do not know which one of them was right. And I do not know what those damned miners found while doing their goddamn digging. But a certain thought haunts my mind, a thought that one day it won't be a room in a mine, but a room in an ordinary house. And I don't really feel like standing there frozen with a face of a retard. That is, if I'm not standing like that right now'. — Dr. Goodwin


Horseman receives life-saving transplant; ‘thanks is not enough’
by HRN StaffCarlos Santamaria, who works as an assistant trainer for California-based Simon Callaghan, has handled, among others, multiple Grade 1 winner Bellafina and the promising juvenile filly Donna Veloce.
In addition to being an integral part of the day-to-day operation of a major racing stable, Santamaria has also been dealing with serious health issues. Earlier this year, Santamaria was diagnosed with kidney failure. Doctors informed him that he needed a transplant, and he needed it as soon as possible.
In April, when Santamaria was at Churchill Downs helping prepare Bellafina for the Kentucky Oaks, he was put in touch with Mulligans, a Louisville-based volunteer organization that supports kidney-failure patients who need live donors.
According to a report from Cincinnati's FOX 19, ads were placed to spread awareness that the horseman needed help. He ended up finding it in Suzanne Levanda, a family friend who underwent testing to confirm she's a match.
FOX 19 reported the pair underwent surgery on Monday at the University of Cincinnati Medical Center.
“Thanks is not enough,” Santamaria told the station. “You know, for me, like I told her, now she’s part of my family. I’m part of her family.”
“All of my friends, everyone who heads about it, they tell me, ‘you’re heroic,’” Levenda added. “And I say, ‘no, this is about being human.’”


College football schedule Week 14: What games are on today? TV channels, times, scores for top 25
by Zac Al-KhateebThe single-most important slate of games of the college football season is here: Rivalry Week.
MORE: Watch NCAA football games live with fuboTV (7-day free trial)
Yes, there are games that will impact the College Football Playoff race, such as ranked meetings in The Game, Iron Bowl and Bedlam. But this extends beyond the postseason: Winners of Friday and Saturday's top-25 games can count the season as a success with just a single victory over their rivals.
Highlights from this week's games include the top-10 showdown between No. 2 Ohio State and No. 10 Michigan and ranked matchups between No. 5 Alabama and No. 16 Auburn and No. 7 Oklahoma at No. 21 Oklahoma State. Other notable games include the Big Ten West-deciding game between No. 13 Wisconsin and No. 9 Minnesota and arguably the top Group of 5 game of the year in No. 18 Cincinnati at No. 17 Memphis.
Here's how you can tune in and watch it all:
WEEK 14 PICKS: Straight up | Against the spread
College football schedule Week 14: What games are on today?
Here's the full schedule for Saturday's Week 14 top-25 college football games, plus final scores and how to watch every game live.
You can keep up with live scores and stats with SN's live scoreboard.
Friday, Nov. 29
| Game | Time (ET) | TV channel |
| No. 23 Virginia Tech at Virginia | Noon | ABC |
| No. 19 Iowa at Nebraska | 2:30 p.m. | Big Ten Network, fuboTV |
| No. 18 Cincinnati at No. 17 Memphis | 3:30 p.m. | ABC |
| No. 20 Boise State at Colorado State | 3:30 p.m. | CBS Sports Network, fuboTV |
| No. 22 Appalachian State at Troy | 6 p.m. | ESPN+ |
Saturday, Nov. 30
| Game | Time (ET) | TV channel |
| No. 2 Ohio State at No. 10 Michigan | Noon | FOX, fuboTV |
| No. 3 Clemson at South Carolina | Noon | ESPN |
| No. 4 Georgia at Georgia Tech | Noon | ABC |
| No. 5 Alabama at No. 16 Auburn | 3:30 p.m. | CBS, fuboTV |
| No. 13 Wisconsin at No. 9 Minnesota | 3:30 p.m. | ABC |
| No. 11 Baylor at Kansas | 3:30 p.m. | ESPN |
| Rutgers at No. 12 Penn State | 3:30 p.m. | BTN, fuboTV |
| Oregon State at No. 14 Oregon | 4 p.m. | Pac-12 Network, fuboTV |
| No. 15 Notre Dame at Stanford | 4 p.m. | FOX, fuboTV |
| Texas A&M at No. 1 LSU | 7 p.m. | ESPN |
| No. 24 Navy at Houston | 7 p.m. | ESPN2 |
| Colorado at No. 6 Utah | 7:30 p.m. | ABC |
| Florida State at No. 8 Florida | 7:30 p.m. | SEC Network |
| No. 7 Oklahoma at No. 21 Oklahoma State | 8 p.m. | FOX, fuboTV |
How to watch, live stream college football games
The Week 14 games involving ranked teams will be televised live on national TV, with games appearing on ESPN, ABC, CBS, CBS Sports Network, FOX, Fox Sports 1, NBC, ESPNU and ESPN+, as well as conference-focused channels such as the SEC Network and Big Ten Network.
College football scores Week 14
| Game |
| No. 23 Virginia Tech at Virginia |
| No. 19 Iowa at Nebraska |
| No. 18 Cincinnati at No. 17 Memphis |
| No. 20 Boise State at Colorado State |
| No. 22 Appalachian State at Troy |
| No. 2 Ohio State at No. 10 Michigan |
| No. 3 Clemson at South Carolina |
| No. 4 Georgia at Georgia Tech |
| No. 5 Alabama at No. 16 Auburn |
| No. 13 Wisconsin at No. 9 Minnesota |
| No. 11 Baylor at Kansas |
| Rutgers at No. 12 Penn State |
| Oregon State at No. 14 Oregon |
| No. 15 Notre Dame at Stanford |
| Texas A&M at No. 1 LSU |
| No. 24 Navy at Houston |
| Colorado at No. 6 Utah |
| Florida State at No. 8 Florida |
| No. 7 Oklahoma at No. 21 Oklahoma State |


Team
A football team is a group of players selected to play together in the
various team sports known as football. Such teams could be selected to play in a
match against an opposing team, to represent a football club, group, state or nation,
an all-star team or even selected as a hypothetical team (such as a Dream Team or Team of
the Century) and never play an actual match.There are several varieties of football, notably
association football, gridiron football, Australian rules football, Gaelic football, rugby
league and rugby union. The number of players selected for each team within these varieties
and their associated codes can vary substantially. Sometimes, the word "team" is limited to
those who play on the field in a match and does not always include other players who may take
part as replacements or emergency players. "Football squad" may be used to be inclusive of
these support and reserve players.
The term football club is the most commonly used for a sports club which is an organised
or incorporated body with a president, committee and a set of rules responsible for ensuring
the continued playing existence of one or more teams which are selected for regular competition
play (and which may participate in several different divisions or leagues). The oldest football
clubs date back to the early 19th century. The words team and club are sometimes used interchangeably
by supporters, although they typically refer to the team within the club playing in the highest
division or competition.
Football is a family of team sports that involve, to varying degrees, kicking a ball to score a goal.
Unqualified, the word football normally means the form of football that is the most popular where the
word is used. Sports commonly called football include association football (known as soccer in some
countries); gridiron football (specifically American football or Canadian football); Australian rules
football; rugby football (either rugby league or rugby union); and Gaelic football.[1][2] These various
forms of football are known as football codes.
There are a number of references to traditional, ancient, or prehistoric ball games played in many different
parts of the world.[3][4][5] Contemporary codes of football can be traced back to the codification of these
games at English public schools during the 19th century.[6][7] The expansion of the British Empire allowed
these rules of football to spread to areas of British influence outside the directly controlled Empire.[8]
By the end of the 19th century, distinct regional codes were already developing: Gaelic football, for example,
deliberately incorporated the rules of local traditional football games in order to maintain their heritage.[9]
In 1888, The Football League was founded in England, becoming the first of many professional football
competitions. During the 20th century, several of the various kinds of football grew to become some of
the most popular team sports in the world.


How to check for scroll event, and get size of an element and its position relative to the viewport
20 5 10How to check for scroll event, and get size of an element and its position relative to the viewport
10 3 10How to check for scroll event, and get size of an element and its position relative to the viewport
7 2 10